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

0.5.8 refactor of all files, party, yml based system, damage listener

Browse source
This commit is contained in:
unurled 2023-04-25 16:27:23 +02:00
parent 3f5e9b1f5e
commit 39de57bf69
160 changed files with 11215 additions and 6137 deletions
Download patch file Download diff file Expand all files Collapse all files

260
src/main/java/me/unurled/raxen/Raxen.java
View file

@ -16,153 +16,167 @@ import org.bukkit.plugin.java.JavaPlugin;
public final class Raxen extends JavaPlugin {
private static final String prefix =
"<aqua>Rx</aqua><light_purple>></light_purple> ";
private static final String prefix =
"<aqua>Rx</aqua><light_purple>></light_purple> ";
@Getter
private static String version = "0.5.7";
@Getter
private static String version = "0.5.8";
private boolean loading = true;
private final PluginManager pm = getServer().getPluginManager();
private boolean loading = true;
private final PluginManager pm = getServer().getPluginManager();
private static Raxen plugin;
private static Raxen plugin;
private static Logger logger;
private static Logger logger;
private static Config config;
private static Config config;
private static PlayerConfig playerConfig;
private static PlayerConfig playerConfig;
@Getter
private ProtocolManager protocolManager;
@Getter
private ProtocolManager protocolManager;
@Getter
private Manager manager;
@Getter
private Manager manager;
/**
* Method when the server launch the plugin.
*/
@Override
public void onEnable() {
plugin = this;
logger = getLogger();
/**
* Method when the server launch the plugin.
*/
@Override
public void onEnable() {
plugin = this;
logger = getLogger();
version = this.getPluginMeta().getVersion();
version = this.getPluginMeta().getVersion();
manager = new Manager();
manager.set(plugin);
manager = new Manager();
manager.set(plugin);
// Config
config = new Config(plugin);
// Config
config = new Config(plugin);
protocolManager = ProtocolLibrary.getProtocolManager();
protocolManager = ProtocolLibrary.getProtocolManager();
playerConfig = new PlayerConfig(plugin);
playerConfig = new PlayerConfig(plugin);
//register Commands and Events
registerCommands();
registerEvents();
//register Commands and Events
registerCommands();
registerEvents();
Bukkit
.getConsoleSender()
.sendMessage(
colorComp(prefix + "<green>Server Started Successfully!</green>")
);
Bukkit
.getConsoleSender()
.sendMessage(
colorComp(
prefix + "<green>Server Started Successfully!</green>"
)
);
manager.getListenerManager().getServerPingEvent().setLoading(false);
loading = false;
}
/**
* register the command in the command manager class.
*/
private void registerCommands() {
manager.getCommandManager().register();
Bukkit
.getConsoleSender()
.sendMessage(colorComp(prefix + "<green>Commands Registered!</green>"));
}
/**
* register the events in the event manager class.
*/
private void registerEvents() {
manager.getListenerManager().register();
Bukkit
.getConsoleSender()
.sendMessage(colorComp(prefix + "<green>Events Registered!</green>"));
}
/**
* Method when the server stops the plugin.
*/
@Override
public void onDisable() {
if (!loading) {
manager.getListenerManager().getServerPingEvent().setLoading(true);
Reload.kickAll();
playerConfig.close();
manager.getListenerManager().getServerPingEvent().setLoading(false);
loading = false;
}
Bukkit
.getConsoleSender()
.sendMessage(
colorComp(prefix + "<red>Server Stopped Successfully!</red>")
);
}
/**
* register the command in the command manager class.
*/
private void registerCommands() {
manager.getCommandManager().register();
/**
* getter for the logger
* @return the plugin logger
*/
public Logger getPluginLogger() {
return logger;
}
Bukkit
.getConsoleSender()
.sendMessage(
colorComp(prefix + "<green>Commands Registered!</green>")
);
}
/**
* getter for the bukkit's plugin manager
* @return plugin manager
*/
public PluginManager getPm() {
return pm;
}
/**
* register the events in the event manager class.
*/
private void registerEvents() {
manager.getListenerManager().register();
/**
* return the instance which is launched.
* @return main instance
*/
public Raxen getPlugin() {
return plugin;
}
Bukkit
.getConsoleSender()
.sendMessage(
colorComp(prefix + "<green>Events Registered!</green>")
);
}
/**
* getter for the raxen prefix
* @return string prefix
*/
public static String getPrefix() {
return prefix;
}
/**
* Method when the server stops the plugin.
*/
@Override
public void onDisable() {
if (!loading) {
manager.getListenerManager().getServerPingEvent().setLoading(true);
Reload.kickAll();
/**
* getter for the yml's player configs.
* @return player config instance
*/
public PlayerConfig getPlayerConfig() {
return playerConfig;
}
playerConfig.close();
}
/**
* getter for an instance of the config utility class
* @return raxen's config
*/
public Config getConf() {
return config;
}
// save tutorial state
public void disable() {
this.setEnabled(false);
}
Bukkit
.getConsoleSender()
.sendMessage(
colorComp(prefix + "<red>Server Stopped Successfully!</red>")
);
}
/**
* getter for the logger
*
* @return the plugin logger
*/
public Logger getPluginLogger() {
return logger;
}
/**
* getter for the bukkit's plugin manager
*
* @return plugin manager
*/
public PluginManager getPm() {
return pm;
}
/**
* return the instance which is launched.
*
* @return main instance
*/
public Raxen getPlugin() {
return plugin;
}
/**
* getter for the raxen prefix
*
* @return string prefix
*/
public static String getPrefix() {
return prefix;
}
/**
* getter for the yml's player configs.
*
* @return player config instance
*/
public PlayerConfig getPlayerConfig() {
return playerConfig;
}
/**
* getter for an instance of the config utility class
*
* @return raxen's config
*/
public Config getConf() {
return config;
}
public void disable() {
this.setEnabled(false);
}
}

395
src/main/java/me/unurled/raxen/commands/RaxenCommand.java
View file

@ -16,207 +16,220 @@ import org.jetbrains.annotations.Nullable;
public class RaxenCommand implements TabExecutor {
private Raxen main;
private Raxen main;
public RaxenCommand(Raxen main) {
this.main = main;
}
public RaxenCommand(Raxen main) {
this.main = main;
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command cmd,
@NotNull String msg,
@NotNull String[] args
) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (!(player.hasPermission("raxen."))) {
msgPlayer(
player,
coloredString(Raxen.getPrefix()) +
colorTextComp(
"<red>You can't execute this command. Insufficient permission."
)
);
}
switch (args.length) {
case 0 -> msgPl(player, 0);
case 1 -> {
switch (args[0]) {
case "mongodb", "mongo", "MONGODB", "MONGO" -> {
//print info about connection
sender.sendMessage(
stringToComp(
Raxen.getPrefix() +
colorTextComp(
"<gold>Printing About Raxen's MongoDB connection..."
)
)
);
msgPlayer(
player,
coloredString(Raxen.getPrefix()) +
colorTextComp(
"<gold>---------------------------------------------"
)
);
msgPlayer(player, colorTextComp("<red>MONGO DB<white>"));
msgPlayer(
player,
StorageManager
.getMongodb()
.getMongoClient()
.getClusterDescription()
.toString()
);
msgPlayer(
player,
StorageManager.getMongodb().getMongoDatabase().getName()
);
msgPlayer(
player,
StorageManager
.getMongodb()
.getMongoCollection()
.getNamespace()
.toString()
);
msgPlayer(
player,
"<gold>---------------------------------------------"
);
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command cmd,
@NotNull String msg,
@NotNull String[] args
) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (!(player.hasPermission("raxen."))) {
msgPlayer(
player,
coloredString(Raxen.getPrefix()) +
colorTextComp(
"<red>You can't execute this command. Insufficient permission."
)
);
}
case "v", "version", "ver" -> {
msgPlayer(player, Raxen.getVersion());
switch (args.length) {
case 0 -> msgPl(player, 0);
case 1 -> {
switch (args[0]) {
case "mongodb", "mongo", "MONGODB", "MONGO" -> {
//print info about connection
sender.sendMessage(
stringToComp(
Raxen.getPrefix() +
colorTextComp(
"<gold>Printing About Raxen's MongoDB connection..."
)
)
);
msgPlayer(
player,
coloredString(Raxen.getPrefix()) +
colorTextComp(
"<gold>---------------------------------------------"
)
);
msgPlayer(
player,
colorTextComp("<red>MONGO DB<white>")
);
msgPlayer(
player,
StorageManager
.getMongodb()
.getMongoClient()
.getClusterDescription()
.toString()
);
msgPlayer(
player,
StorageManager
.getMongodb()
.getMongoDatabase()
.getName()
);
msgPlayer(
player,
StorageManager
.getMongodb()
.getMongoCollection()
.getNamespace()
.toString()
);
msgPlayer(
player,
"<gold>---------------------------------------------"
);
}
case "v", "version", "ver" -> {
msgPlayer(player, Raxen.getVersion());
}
case "hemlp", "?", "h" -> {
//print help
}
}
}
}
case "hemlp", "?", "h" -> {
//print help
} else {
switch (args.length) {
case 0 -> {
msgSender(
sender,
Raxen.getPrefix() + "<gold>Printing About Raxen...",
"<gold>---------------------------------------------",
"<dark_aqua> Raxen ",
"<dark_aqua> - Version: " + Raxen.getVersion(),
"<dark_aqua> - Author: <b><red>U<gold>n<yellow>u<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>"
);
TextComponent txt = colorTextComp(
"<dark_aqua> - Website: https://unurled.me"
);
sender.sendMessage(txt);
sender.sendMessage(
colorComp(
"<gold>---------------------------------------------"
)
);
return true;
}
case 1 -> {
switch (args[0]) {
case "mongodb", "mongo", "MONGODB", "MONGO" -> {
//print info about connection
msgSender(
sender,
Raxen.getPrefix() +
"<gold>Printing About Raxen's MongoDB connection...",
"<gold>---------------------------------------------" +
"<red>MONGO DB"
);
sender.sendMessage(
stringToComp(
StorageManager
.getMongodb()
.getMongoClient()
.getClusterDescription()
.toString()
)
);
sender.sendMessage(
stringToComp(
StorageManager
.getMongodb()
.getMongoDatabase()
.getName()
)
);
sender.sendMessage(
stringToComp(
StorageManager
.getMongodb()
.getMongoCollection()
.getNamespace()
.toString()
)
);
sender.sendMessage(
stringToComp(
coloredString(
"<gold>---------------------------------------------"
)
)
);
return true;
}
case "v", "version", "ver" -> {
msgSender(
sender,
Raxen.getPrefix() +
"<gold>Printing About Raxen...",
"<gold>---------------------------------------------",
"<dark_aqua> Raxen ",
"<dark_aqua> - Version: " + Raxen.getVersion(),
"<dark_aqua> - Author: <b><red>U<gold>n&eu<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>"
);
TextComponent txt = colorTextComp(
"<dark_aqua> - Website: https://unurled.me"
);
sender.sendMessage(txt);
sender.sendMessage(
colorComp(
"<gold>---------------------------------------------"
)
);
return true;
}
case "hemlp", "?", "h" -> debug(main, "print help"); //print help
}
}
}
}
}
}
} else {
switch (args.length) {
case 0 -> {
msgSender(
sender,
Raxen.getPrefix() + "<gold>Printing About Raxen...",
"<gold>---------------------------------------------",
"<dark_aqua> Raxen ",
"<dark_aqua> - Version: " + Raxen.getVersion(),
"<dark_aqua> - Author: <b><red>U<gold>n<yellow>u<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>"
);
TextComponent txt = colorTextComp(
"<dark_aqua> - Website: https://unurled.me"
);
sender.sendMessage(txt);
sender.sendMessage(
colorComp("<gold>---------------------------------------------")
);
return true;
}
case 1 -> {
switch (args[0]) {
case "mongodb", "mongo", "MONGODB", "MONGO" -> {
//print info about connection
msgSender(
sender,
Raxen.getPrefix() +
"<gold>Printing About Raxen's MongoDB connection...",
"<gold>---------------------------------------------" +
"<red>MONGO DB"
);
sender.sendMessage(
stringToComp(
StorageManager
.getMongodb()
.getMongoClient()
.getClusterDescription()
.toString()
return false;
}
public void msgPl(Player player, Integer in) {
switch (in) {
case 0:
msgPlayer(
player,
Raxen.getPrefix() + "<gold>Printing About Raxen...",
"<gold>---------------------------------------------",
"<dark_aqua> Raxen ",
"<dark_aqua> - Version: " + Raxen.getVersion(),
"<dark_aqua> - Author: <b><red>U<gold>n&eu<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>"
);
TextComponent txt = (TextComponent) colorComp(
"<dark_aqua> - Website: https://unurled.me"
)
);
sender.sendMessage(
stringToComp(
StorageManager.getMongodb().getMongoDatabase().getName()
)
);
sender.sendMessage(
stringToComp(
StorageManager
.getMongodb()
.getMongoCollection()
.getNamespace()
.toString()
)
);
sender.sendMessage(
stringToComp(
coloredString(
.clickEvent(ClickEvent.openUrl("https://unurled.me"));
player.sendMessage(txt);
msgPlayer(
player,
"",
"<gold>---------------------------------------------"
)
)
);
return true;
}
case "v", "version", "ver" -> {
msgSender(
sender,
Raxen.getPrefix() + "<gold>Printing About Raxen...",
"<gold>---------------------------------------------",
"<dark_aqua> Raxen ",
"<dark_aqua> - Version: " + Raxen.getVersion(),
"<dark_aqua> - Author: <b><red>U<gold>n&eu<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>"
);
TextComponent txt = colorTextComp(
"<dark_aqua> - Website: https://unurled.me"
);
sender.sendMessage(txt);
sender.sendMessage(
colorComp("<gold>---------------------------------------------")
);
return true;
}
case "hemlp", "?", "h" -> //print help
debug(main, "print help");
}
);
}
}
}
return false;
}
public void msgPl(Player player, Integer in) {
switch (in) {
case 0:
msgPlayer(
player,
Raxen.getPrefix() + "<gold>Printing About Raxen...",
"<gold>---------------------------------------------",
"<dark_aqua> Raxen ",
"<dark_aqua> - Version: " + Raxen.getVersion(),
"<dark_aqua> - Author: <b><red>U<gold>n&eu<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>"
);
TextComponent txt = (TextComponent) colorComp(
"<dark_aqua> - Website: https://unurled.me"
)
.clickEvent(ClickEvent.openUrl("https://unurled.me"));
player.sendMessage(txt);
msgPlayer(
player,
"",
"<gold>---------------------------------------------"
);
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}

195
src/main/java/me/unurled/raxen/commands/admin/CustomModelDataCommand.java
View file

@ -19,104 +19,109 @@ import org.jetbrains.annotations.Nullable;
public class CustomModelDataCommand implements TabExecutor {
/**
* change custom model data of an item
* @param sender Source of the command
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args Passed command arguments
* @return
*/
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
errorConsoleSender(sender);
return true;
/**
* change custom model data of an item
* @param sender Source of the command
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args Passed command arguments
* @return
*/
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
errorConsoleSender(sender);
return true;
}
Player p = (Player) sender;
if (!(p.hasPermission("raxen.custommodeldata.cmd"))) {
p.sendMessage(noPerms());
return true;
}
ItemStack it = p.getInventory().getItemInMainHand();
if (args.length == 0) {
p.sendMessage(
colorComp(
"<gold>Usage: /custommodeldata <model-data-value> <item-name></gold>"
)
);
return true;
}
if (!(isInt(args[0]))) {
Material material = Material.getMaterial(args[1]);
if (material != null) {
it =
customModelData(
new ItemStack(material),
Integer.parseInt(args[0])
);
p.getInventory().setItemInMainHand(it);
p.updateInventory();
} else {
p.sendMessage(
colorComp(
"<red>Please specify a valid Item Name or a valid Integer.</red>"
)
);
}
} else {
if (it != null && it.getType() != Material.AIR) { // check if player has an item in hand
// has item in hand applying the custom model data
it = customModelData(it, Integer.parseInt(args[0]));
p.getInventory().setItemInMainHand(it);
p.updateInventory();
} else {
p.sendMessage(
colorComp(
"<red>Get an item in hand please or specify an item</red>"
)
);
p.sendMessage(
colorComp(
"<gold>Usage: /custommodeldata <model-data-value> <item-name></gold>"
)
);
}
}
return true;
}
Player p = (Player) sender;
if (!(p.hasPermission("raxen.custommodeldata.cmd"))) {
p.sendMessage(noPerms());
return true;
}
ItemStack it = p.getInventory().getItemInMainHand();
if (args.length == 0) {
p.sendMessage(
colorComp(
"<gold>Usage: /custommodeldata <model-data-value> <item-name></gold>"
)
);
return true;
}
if (!(isInt(args[0]))) {
Material material = Material.getMaterial(args[1]);
if (material != null) {
it =
customModelData(new ItemStack(material), Integer.parseInt(args[0]));
p.getInventory().setItemInMainHand(it);
p.updateInventory();
} else {
p.sendMessage(
colorComp(
"<red>Please specify a valid Item Name or a valid Integer.</red>"
)
);
}
} else {
if (it != null && it.getType() != Material.AIR) { // check if player has an item in hand
// has item in hand applying the custom model data
it = customModelData(it, Integer.parseInt(args[0]));
p.getInventory().setItemInMainHand(it);
p.updateInventory();
} else {
p.sendMessage(
colorComp("<red>Get an item in hand please or specify an item</red>")
);
p.sendMessage(
colorComp(
"<gold>Usage: /custommodeldata <model-data-value> <item-name></gold>"
)
);
}
}
return true;
}
/**
* @param sender Source of the command. For players tab-completing a
* command inside of a command block, this will be the player, not
* the command block.
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args The arguments passed to the command, including final
* partial argument to be completed
* @return
*/
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
final List<String> completions = new ArrayList<>();
/**
* @param sender Source of the command. For players tab-completing a
* command inside of a command block, this will be the player, not
* the command block.
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args The arguments passed to the command, including final
* partial argument to be completed
* @return
*/
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
final List<String> completions = new ArrayList<>();
List<String> SUB_COMMANDS = new ArrayList<>();
List<String> SUB_COMMANDS = new ArrayList<>();
if (!(isInt(args[0]))) {
return Arrays.asList("§c" + args[0]);
if (!(isInt(args[0]))) {
return Arrays.asList("§c" + args[0]);
}
if (args.length == 2) {
for (Material mat : Material.values()) {
SUB_COMMANDS.add(mat.name());
}
StringUtil.copyPartialMatches(args[1], SUB_COMMANDS, completions);
Collections.sort(completions);
}
return completions;
}
if (args.length == 2) {
for (Material mat : Material.values()) {
SUB_COMMANDS.add(mat.name());
}
StringUtil.copyPartialMatches(args[1], SUB_COMMANDS, completions);
Collections.sort(completions);
}
return completions;
}
}

72
src/main/java/me/unurled/raxen/commands/admin/EntitiyCommand.java
View file

@ -9,41 +9,41 @@ import org.jetbrains.annotations.Nullable;
public class EntitiyCommand implements TabExecutor {
/**
* Get the egg spawn of a custom entity :)
* @param sender Source of the command
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args Passed command arguments
* @return
*/
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
return false;
}
/**
* Get the egg spawn of a custom entity :)
* @param sender Source of the command
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args Passed command arguments
* @return
*/
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
return false;
}
/**
* @param sender Source of the command. For players tab-completing a
* command inside a command block, this will be the player, not
* the command block.
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args The arguments passed to the command, including final
* partial argument to be completed
* @return
*/
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
return null;
}
/**
* @param sender Source of the command. For players tab-completing a
* command inside a command block, this will be the player, not
* the command block.
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args The arguments passed to the command, including final
* partial argument to be completed
* @return
*/
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
return null;
}
}

93
src/main/java/me/unurled/raxen/commands/admin/ItemListCommand.java
View file

@ -1,6 +1,8 @@
package me.unurled.raxen.commands.admin;
import static me.unurled.raxen.utils.Utils.*;
import static me.unurled.raxen.utils.Utils.colorString;
import static me.unurled.raxen.utils.Utils.log;
import static me.unurled.raxen.utils.Utils.msgPlayer;
import java.util.List;
import lombok.Getter;
@ -15,49 +17,56 @@ import org.jetbrains.annotations.Nullable;
public class ItemListCommand implements TabExecutor {
private Raxen main;
private Raxen main;
@Getter
private ItemListGui itemListGui;
@Getter
private ItemListGui itemListGui;
public ItemListCommand(Raxen main) {
this.main = main;
this.itemListGui = new ItemListGui(this.main);
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command cmd,
@NotNull String msg,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
log("Console can't execute this command atm.");
return true;
public ItemListCommand(Raxen main) {
this.main = main;
this.itemListGui = new ItemListGui(this.main);
}
Player player = (Player) sender;
if (!(player.hasPermission("raxen.itemlist.cmd"))) {
msgPlayer(
player,
colorString(
"<red>You'dont have the permission to execute this command."
)
);
return true;
}
//openGui logic
player.openInventory(itemListGui.getInv());
return false;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command cmd,
@NotNull String msg,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
log("Console can't execute this command atm.");
return true;
}
Player player = (Player) sender;
if (!(player.hasPermission("raxen.itemlist.cmd"))) {
msgPlayer(
player,
colorString(
"<red>You'dont have the permission to execute this command."
)
);
return true;
}
int page = 1;
if (args.length > 0) {
try {
page = Integer.parseInt(args[0]);
} catch (NumberFormatException ignored) {
}
}
//openGui logic
itemListGui.openInventory(player, page);
return false;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}

80
src/main/java/me/unurled/raxen/commands/admin/ItemTo64Command.java
View file

@ -13,46 +13,46 @@ import org.jetbrains.annotations.Nullable;
public class ItemTo64Command implements TabExecutor {
/**
* @param sender Source of the command
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args Passed command arguments
* @return
*/
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (sender instanceof Player p) {
msgPlayer(p, itemTo64(p.getInventory().getItemInMainHand()));
} else {
errorConsoleSender(sender);
return true;
/**
* @param sender Source of the command
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args Passed command arguments
* @return
*/
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (sender instanceof Player p) {
msgPlayer(p, itemTo64(p.getInventory().getItemInMainHand()));
} else {
errorConsoleSender(sender);
return true;
}
return false;
}
return false;
}
/**
* @param sender Source of the command. For players tab-completing a
* command inside of a command block, this will be the player, not
* the command block.
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args The arguments passed to the command, including final
* partial argument to be completed
* @return
*/
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
return null;
}
/**
* @param sender Source of the command. For players tab-completing a
* command inside of a command block, this will be the player, not
* the command block.
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args The arguments passed to the command, including final
* partial argument to be completed
* @return
*/
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
return null;
}
}

227
src/main/java/me/unurled/raxen/commands/admin/NbtCommand.java
View file

@ -17,123 +17,136 @@ import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class NbtCommand implements TabExecutor {
private final Raxen main;
private final Raxen main;
public NbtCommand(Raxen main) {
this.main = main;
}
public NbtCommand(Raxen main) {
this.main = main;
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command cmd,
@NotNull String msg,
@NotNull String[] args
) {
if (!(sender instanceof Player player)) {
error(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),
colorString("<red>You can't execute this command as the Console!")
);
return true;
}
if (player.getInventory().getItemInMainHand().getType() == Material.AIR) {
msgPlayer(player, colorTextComp("<red>You must hold an Item in hand."));
return true;
} else {
player.getInventory().getItemInMainHand();
}
switch (args.length) {
case 0, 1 -> msgPlayer(
player,
colorTextComp("<red>You must specify an nbt and an int.")
);
case 2 -> {
debug("'" + args[0] + "'", "'" + args[1] + "'");
ItemStack it = player.getInventory().getItemInMainHand();
NBTItem nbti = new NBTItem(it);
int a = 0;
if (nbti.hasTag(args[0])) {
a = nbti.getInteger(args[0]);
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command cmd,
@NotNull String msg,
@NotNull String[] args
) {
if (!(sender instanceof Player player)) {
error(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),
colorString(
"<red>You can't execute this command as the Console!"
)
);
return true;
}
List<Component> lore = new ArrayList<>();
// ItemMeta itm = it.getItemMeta();
// lore.add((Component) itm.lore());
boolean yes = false;
boolean ever = false;
for (Component ct : lore) {
if (ct != null) {
if (ct.contains(Component.text("Attributes:"))) {
yes = true;
ever = true;
} else {
if (yes) {
//ct.append(Component.text(colorString(attributes(args[0]) + ": " + (Integer.parseInt(args[1]) + a)))); deprecated
yes = false;
}
if (
player.getInventory().getItemInMainHand().getType() == Material.AIR
) {
msgPlayer(
player,
colorTextComp("<red>You must hold an Item in hand.")
);
return true;
} else {
player.getInventory().getItemInMainHand();
}
switch (args.length) {
case 0, 1 -> msgPlayer(
player,
colorTextComp("<red>You must specify an nbt and an int.")
);
case 2 -> {
debug("'" + args[0] + "'", "'" + args[1] + "'");
ItemStack it = player.getInventory().getItemInMainHand();
NBTItem nbti = new NBTItem(it);
String a = "";
if (nbti.hasTag(args[0])) {
a = nbti.getString(args[0]);
}
List<Component> lore = new ArrayList<>();
// ItemMeta itm = it.getItemMeta();
// lore.add((Component) itm.lore());
boolean yes = false;
boolean ever = false;
for (Component ct : lore) {
if (ct != null) {
if (ct.contains(Component.text("Attributes:"))) {
yes = true;
ever = true;
} else {
if (yes) {
//ct.append(Component.text(colorString(attributes(args[0]) + ": " + (Integer.parseInt(args[1]) + a)))); deprecated
yes = false;
}
}
}
}
if (!ever) {
lore.add(colorTextComp("<red>Attributes:"));
//lore.add(colorTextComp(attributes(args[0]) + ": " + (Integer.parseInt(args[1]) + a))); deprecated
}
// itm.lore(lore);
// it.setItemMeta(itm);
PlayerManager pm =
(
(Raxen) Objects.requireNonNull(
Bukkit.getPluginManager().getPlugin("Raxen")
)
).getManager()
.getPlayerManager();
try {
nbti.setInteger(
args[0],
Integer.parseInt(args[1]) + Integer.parseInt(a)
);
} catch (NumberFormatException ignored) {
nbti.setString(args[0], args[1]);
}
if (nbti.hasTag("SPEED")) {
pm.getSpeed().add(player, nbti.getInteger("SPEED"));
}
if (nbti.hasTag("HEALTH")) {
pm.getHealth().add(player, nbti.getInteger("HEALTH"));
}
if (nbti.hasTag("DEFENSE")) {
pm.getDefense().add(player, nbti.getInteger("DEFENSE"));
}
if (nbti.hasTag("STRENGTH")) {
pm.getStrength().add(player, nbti.getInteger("STRENGTH"));
}
it = nbti.getItem();
msgPlayer(
player,
colorTextComp(
Raxen.getPrefix() +
"<white>You successfully added the nbt " +
/*attributes(args[0])*/args[0] +
"<white>with " +
args[1] +
"<white>."
)
);
updateSkills(main, player);
player
.getInventory()
.setItem(player.getInventory().getHeldItemSlot(), it);
}
}
}
if (!ever) {
lore.add(colorTextComp("<red>Attributes:"));
//lore.add(colorTextComp(attributes(args[0]) + ": " + (Integer.parseInt(args[1]) + a))); deprecated
}
// itm.lore(lore);
// it.setItemMeta(itm);
PlayerManager pm =
(
(Raxen) Objects.requireNonNull(
Bukkit.getPluginManager().getPlugin("Raxen")
)
).getManager()
.getPlayerManager();
nbti.setInteger(args[0], Integer.parseInt(args[1]) + a);
if (nbti.hasTag("SPEED")) {
pm.getSpeed().add(player, nbti.getInteger("SPEED"));
}
if (nbti.hasTag("HEALTH")) {
pm.getHealth().add(player, nbti.getInteger("HEALTH"));
}
if (nbti.hasTag("DEFENSE")) {
pm.getDefense().add(player, nbti.getInteger("DEFENSE"));
}
if (nbti.hasTag("STRENGTH")) {
pm.getStrength().add(player, nbti.getInteger("STRENGTH"));
}
it = nbti.getItem();
msgPlayer(
player,
colorTextComp(
Raxen.getPrefix() +
"<white>You successfully added the nbt " +
/*attributes(args[0])*/args[0] +
"<white>with " +
args[1] +
"<white>."
)
);
updateSkills(main, player);
player
.getInventory()
.setItem(player.getInventory().getHeldItemSlot(), it);
}
return true;
}
return true;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}

72
src/main/java/me/unurled/raxen/commands/admin/ReloadCommand.java
View file

@ -1,6 +1,8 @@
package me.unurled.raxen.commands.admin;
import static me.unurled.raxen.utils.Utils.*;
import static me.unurled.raxen.utils.Utils.colorString;
import static me.unurled.raxen.utils.Utils.log;
import static me.unurled.raxen.utils.Utils.noPerms;
import java.util.List;
import me.unurled.raxen.utils.Reload;
@ -9,42 +11,48 @@ import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class ReloadCommand implements TabExecutor {
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String msg,
@NotNull String[] args
) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (!player.hasPermission("raxen.reload.cmd")) {
player.sendMessage(noPerms());
return true;
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String msg,
@NotNull String[] args
) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (!player.hasPermission("raxen.reload.cmd")) {
player.sendMessage(noPerms());
return true;
}
}
Reload.kickAll();
log(
colorString(
"<red>Server stopping!\n Using: /rlpl.\n Please wait a little bit."
)
);
new BukkitRunnable() {
@Override
public void run() {
Bukkit.getServer().shutdown();
}
}.runTaskLater(Bukkit.getPluginManager().getPlugin("Raxen"), 80L);
return false;
}
Reload.kickAll();
log(
colorString(
"<red>Server stopping!\n Using: /rlpl.\n Please wait a little bit."
)
);
Bukkit.getServer().shutdown();
return false;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}

350
src/main/java/me/unurled/raxen/commands/admin/SpawnEntity.java
View file

@ -26,187 +26,187 @@ import org.jetbrains.annotations.Nullable;
public class SpawnEntity implements TabExecutor {
private Raxen main;
private EntityNamespacedKey namespacedKey;
private Raxen main;
private EntityNamespacedKey namespacedKey;
public SpawnEntity(Raxen main) {
this.main = main;
this.namespacedKey = new EntityNamespacedKey(main);
}
public SpawnEntity(Raxen main) {
this.main = main;
this.namespacedKey = new EntityNamespacedKey(main);
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
log(colorTextComp("<red>Console can't execute this command!"));
try { // /entityspawn ZOMBIE "&cHello folks" x:0 y:0 z:0 level health defense speed strength itemStackBinary64: helmet, chestplate, leggings, boots, main-hand, off-hand
if (validateArgs(args, 16)) {
args = setNullInArgs(args);
} else {
log(
colorTextComp(
"<red>Please use null if you don't want some parameters in the command.</red>"
)
);
log(
colorTextComp(
"<red>Follow this command: /entityspawn TYPE \"name\" x y z level health defense speed strength " +
"helmet(itemStackBinary64) chestplate(itemStackBinary64) leggings(itemStackBinary64) boots(itemStackBinary64) main-hand(itemStackBinary64) off-hand(itemStackBinary64)</red>"
)
);
return false;
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
log(colorTextComp("<red>Console can't execute this command!"));
try { // /entityspawn ZOMBIE "&cHello folks" x:0 y:0 z:0 level health defense speed strength itemStackBinary64: helmet, chestplate, leggings, boots, main-hand, off-hand
if (validateArgs(args, 16)) {
args = setNullInArgs(args);
} else {
log(
colorTextComp(
"<red>Please use null if you don't want some parameters in the command.</red>"
)
);
log(
colorTextComp(
"<red>Follow this command: /entityspawn TYPE \"name\" x y z level health defense speed strength " +
"helmet(itemStackBinary64) chestplate(itemStackBinary64) leggings(itemStackBinary64) boots(itemStackBinary64) main-hand(itemStackBinary64) off-hand(itemStackBinary64)</red>"
)
);
return false;
}
EntityType types = EntityType.valueOf(args[0]);
Location loc = new Location(
Bukkit.getWorld("world"),
Double.parseDouble(args[2]),
Double.parseDouble(args[3]),
Double.parseDouble(args[4])
);
Entity e = loc.getWorld().spawnEntity(loc, types, false);
setNameSpacedKeys(
e,
getStringFromArg(args),
Integer.parseInt(args[6]),
Integer.parseInt(args[7]),
0,
Integer.parseInt(args[8]),
0,
Integer.parseInt(args[9]),
0,
Integer.parseInt(args[10]),
0
);
e.customName(colorTextComp(getStringFromArg(args)));
e.setCustomNameVisible(true);
if (e instanceof LivingEntity livingEntity) {
// livingEntity.getEquipment().set
ItemStack helmet = itemFrom64(args[11]);
ItemStack chestplate = itemFrom64(args[12]);
ItemStack leggins = itemFrom64(args[13]);
ItemStack boots = itemFrom64(args[14]);
ItemStack mainhand = itemFrom64(args[15]);
ItemStack offhand = itemFrom64(args[14]);
EntityEquipment equip = livingEntity.getEquipment();
equip.setHelmet(helmet);
equip.setChestplate(chestplate);
equip.setLeggings(leggins);
equip.setBoots(boots);
equip.setItemInMainHand(mainhand);
equip.setItemInOffHand(offhand);
}
System.out.println(e.getName());
} catch (IllegalArgumentException e) {
error("Something happened near the SpawnEntity command.");
throw new RuntimeException(e);
} catch (IOException e) {
error(
"Could not deserialize item from the command EntitySpawn (command launched by " +
sender.getName() +
")"
);
throw new RuntimeException(e);
}
}
for (String arg : args) {
log(arg);
}
Player player = (Player) sender;
if (!player.hasPermission("raxen.entityspawn.cmd")) {
player.sendMessage(noPerms());
return false;
}
try { // /entityspawn ZOMBIE "&cHello folks" x:0 y:0 z:0 level health defense speed strength itemStackBinary64: helmet, chestplate, leggings, boots, main-hand, off-hand
if (validateArgs(args, 16)) {
args = setNullInArgs(args);
} else {
log(
colorTextComp(
"<red>Please use null if you don't want some parameters in the command.</red>"
)
);
log(
colorTextComp(
"<red>Follow this command: /entityspawn TYPE \"name\" x y z level health defense speed strength " +
"helmet(itemStackBinary64) chestplate(itemStackBinary64) leggings(itemStackBinary64) boots(itemStackBinary64) main-hand(itemStackBinary64) off-hand(itemStackBinary64)</red>"
)
);
return false;
}
EntityType types = EntityType.valueOf(args[0]);
Location loc = new Location(
Bukkit.getWorld("world"),
Double.parseDouble(args[2]),
Double.parseDouble(args[3]),
Double.parseDouble(args[4])
);
Entity e = loc.getWorld().spawnEntity(loc, types, false);
setNameSpacedKeys(
e,
getStringFromArg(args),
Integer.parseInt(args[6]),
Integer.parseInt(args[7]),
0,
Integer.parseInt(args[8]),
0,
Integer.parseInt(args[9]),
0,
Integer.parseInt(args[10]),
0
);
e.customName(colorTextComp(getStringFromArg(args)));
e.setCustomNameVisible(true);
if (e instanceof LivingEntity livingEntity) {
// livingEntity.getEquipment().set
ItemStack helmet = itemFrom64(args[11]);
ItemStack chestplate = itemFrom64(args[12]);
ItemStack leggins = itemFrom64(args[13]);
ItemStack boots = itemFrom64(args[14]);
ItemStack mainhand = itemFrom64(args[15]);
ItemStack offhand = itemFrom64(args[14]);
EntityEquipment equip = livingEntity.getEquipment();
equip.setHelmet(helmet);
equip.setChestplate(chestplate);
equip.setLeggings(leggins);
equip.setBoots(boots);
equip.setItemInMainHand(mainhand);
equip.setItemInOffHand(offhand);
}
System.out.println(e.getName());
} catch (IllegalArgumentException e) {
error("Something happened near the SpawnEntity command.");
throw new RuntimeException(e);
} catch (IOException e) {
error(
"Could not deserialize item from the command EntitySpawn (command launched by " +
sender.getName() +
")"
);
throw new RuntimeException(e);
}
EntityType types = EntityType.valueOf(args[0]);
Location loc = new Location(
Bukkit.getWorld("world"),
Double.parseDouble(args[2]),
Double.parseDouble(args[3]),
Double.parseDouble(args[4])
);
Entity e = loc.getWorld().spawnEntity(loc, types, false);
setNameSpacedKeys(
e,
getStringFromArg(args),
Integer.parseInt(args[6]),
Integer.parseInt(args[7]),
0,
Integer.parseInt(args[8]),
0,
Integer.parseInt(args[9]),
0,
Integer.parseInt(args[10]),
0
);
e.customName(colorTextComp(getStringFromArg(args)));
e.setCustomNameVisible(true);
if (e instanceof LivingEntity livingEntity) {
// livingEntity.getEquipment().set
ItemStack helmet = itemFrom64(args[11]);
ItemStack chestplate = itemFrom64(args[12]);
ItemStack leggins = itemFrom64(args[13]);
ItemStack boots = itemFrom64(args[14]);
ItemStack mainhand = itemFrom64(args[15]);
ItemStack offhand = itemFrom64(args[14]);
EntityEquipment equip = livingEntity.getEquipment();
equip.setHelmet(helmet);
equip.setChestplate(chestplate);
equip.setLeggings(leggins);
equip.setBoots(boots);
equip.setItemInMainHand(mainhand);
equip.setItemInOffHand(offhand);
}
System.out.println(e.getName());
} catch (IllegalArgumentException e) {
error("Something happened near the SpawnEntity command.");
throw new RuntimeException(e);
} catch (IOException e) {
error(
"Could not deserialize item from the command EntitySpawn (command launched by " +
sender.getName() +
")"
);
throw new RuntimeException(e);
}
}
for (String arg : args) {
log(arg);
}
Player player = (Player) sender;
if (!player.hasPermission("raxen.entityspawn.cmd")) {
player.sendMessage(noPerms());
return false;
}
try { // /entityspawn ZOMBIE "&cHello folks" x:0 y:0 z:0 level health defense speed strength itemStackBinary64: helmet, chestplate, leggings, boots, main-hand, off-hand
if (validateArgs(args, 16)) {
args = setNullInArgs(args);
} else {
log(
colorTextComp(
"<red>Please use null if you don't want some parameters in the command.</red>"
)
);
log(
colorTextComp(
"<red>Follow this command: /entityspawn TYPE \"name\" x y z level health defense speed strength " +
"helmet(itemStackBinary64) chestplate(itemStackBinary64) leggings(itemStackBinary64) boots(itemStackBinary64) main-hand(itemStackBinary64) off-hand(itemStackBinary64)</red>"
)
);
return false;
}
EntityType types = EntityType.valueOf(args[0]);
Location loc = new Location(
Bukkit.getWorld("world"),
Double.parseDouble(args[2]),
Double.parseDouble(args[3]),
Double.parseDouble(args[4])
);
Entity e = loc.getWorld().spawnEntity(loc, types, false);
setNameSpacedKeys(
e,
getStringFromArg(args),
Integer.parseInt(args[6]),
Integer.parseInt(args[7]),
0,
Integer.parseInt(args[8]),
0,
Integer.parseInt(args[9]),
0,
Integer.parseInt(args[10]),
0
);
e.customName(colorTextComp(getStringFromArg(args)));
e.setCustomNameVisible(true);
if (e instanceof LivingEntity livingEntity) {
// livingEntity.getEquipment().set
ItemStack helmet = itemFrom64(args[11]);
ItemStack chestplate = itemFrom64(args[12]);
ItemStack leggins = itemFrom64(args[13]);
ItemStack boots = itemFrom64(args[14]);
ItemStack mainhand = itemFrom64(args[15]);
ItemStack offhand = itemFrom64(args[14]);
EntityEquipment equip = livingEntity.getEquipment();
equip.setHelmet(helmet);
equip.setChestplate(chestplate);
equip.setLeggings(leggins);
equip.setBoots(boots);
equip.setItemInMainHand(mainhand);
equip.setItemInOffHand(offhand);
}
System.out.println(e.getName());
} catch (IllegalArgumentException e) {
error("Something happened near the SpawnEntity command.");
throw new RuntimeException(e);
} catch (IOException e) {
error(
"Could not deserialize item from the command EntitySpawn (command launched by " +
sender.getName() +
")"
);
throw new RuntimeException(e);
}
return false;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
List<String> list = new ArrayList<>();
for (EntityType types : EntityType.values()) {
list.add(types.name());
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
List<String> list = new ArrayList<>();
for (EntityType types : EntityType.values()) {
list.add(types.name());
}
return list;
}
return list;
}
}

56
src/main/java/me/unurled/raxen/commands/admin/TestGuiCommand.java
View file

@ -14,34 +14,34 @@ import org.jetbrains.annotations.Nullable;
public class TestGuiCommand implements TabExecutor {
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (player.hasPermission("raxen.test.gui.cmd")) {
player.openInventory(
Bukkit.createInventory(null, 54, colorTextComp(args[0]))
);
}
} else {
log("The console can't execute this Command!");
return true;
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (player.hasPermission("raxen.test.gui.cmd")) {
player.openInventory(
Bukkit.createInventory(null, 54, colorTextComp(args[0]))
);
}
} else {
log("The console can't execute this Command!");
return true;
}
return false;
}
return false;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}

149
src/main/java/me/unurled/raxen/commands/admin/TutorialManagerCommand.java Normal file
View file

@ -0,0 +1,149 @@
package me.unurled.raxen.commands.admin;
import static me.unurled.raxen.utils.Utils.colorTextComp;
import static me.unurled.raxen.utils.Utils.msgPlayer;
import static me.unurled.raxen.utils.Utils.noPerms;
import java.util.ArrayList;
import java.util.List;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.tutorial.Tutorial;
import me.unurled.raxen.manager.server.TutorialManager;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class TutorialManagerCommand implements TabExecutor {
Raxen main;
List<String> complete = new ArrayList<>();
public TutorialManagerCommand(Raxen main) {
this.main = main;
}
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command,
@NotNull String label, @NotNull String[] args) {
if (!sender.hasPermission("raxen.tutorial.cmd")) {
sender.sendMessage(noPerms());
return true;
}
if (args.length == 0) {
// help
return true;
} else {
TutorialManager tutorialManager = main.getManager().getTutorialManager();
if (args.length == 1) {
if (args[0].equalsIgnoreCase("start")) {
// start tutorial for sender (if sender is a player)
if (sender instanceof Player player) {
Location loc = tutorialManager
.generateTutorial(player);
tutorialManager.getTutorial(player.getUniqueId())
.startTutorial(player, loc);
return true;
}
} else if (sender instanceof Player player) {
if (args[0].equalsIgnoreCase("stop")) {
// stop tutorial for sender
tutorialManager.getTutorial(player.getUniqueId())
.stopTutorial();
tutorialManager.removeTutorial(player.getUniqueId());
return true;
} else if (args[0].equalsIgnoreCase("next")) {
// next step for sender
tutorialManager.getTutorial(player.getUniqueId())
.nextStep();
return true;
} else if (args[0].equalsIgnoreCase("prev")) {
// prev step for sender
tutorialManager.getTutorial(player.getUniqueId())
.previousStep();
return true;
} else if (args[0].equalsIgnoreCase("status")) {
// status of tutorial for sender
Tutorial tutorial = tutorialManager.getTutorial(player.getUniqueId());
msgPlayer(player, colorTextComp(
"<gray>Tutorial status for player " + player.getName() + ": <reset>"
+ tutorial.getStep()));
return true;
}
}
} else if (args.length == 2) {
Player player = Bukkit.getPlayer(args[1]);
if (player != null) {
if (player.isOnline()) {
if (args[0].equalsIgnoreCase("start")) {
// start tutorial for player
Location loc = tutorialManager
.generateTutorial(player);
tutorialManager.getTutorial(player.getUniqueId())
.startTutorial(player, loc);
} else if (args[0].equalsIgnoreCase("stop")) {
// stop tutorial for sender
tutorialManager.getTutorial(player.getUniqueId())
.stopTutorial();
tutorialManager.removeTutorial(player.getUniqueId());
return true;
} else if (args[0].equalsIgnoreCase("next")) {
// next step for sender
tutorialManager.getTutorial(player.getUniqueId())
.nextStep();
return true;
} else if (args[0].equalsIgnoreCase("prev")) {
// prev step for sender
tutorialManager.getTutorial(player.getUniqueId())
.previousStep();
return true;
} else if (args[0].equalsIgnoreCase("status")) {
// status of tutorial for sender
Tutorial tutorial = tutorialManager.getTutorial(player.getUniqueId());
msgPlayer(player, colorTextComp(
"<gray>Tutorial status for player " + player.getName() + ": <reset>"
+ tutorial.getStep()));
return true;
}
return true;
}
}
}
}
return false;
}
@Override
public @Nullable List<String> onTabComplete(@NotNull CommandSender sender,
@NotNull Command command, @NotNull String label, @NotNull String[] args) {
if (complete.isEmpty()) {
complete.add("start");
complete.add("stop");
complete.add("next");
complete.add("prev");
complete.add("status");
}
List<String> result = new ArrayList<>();
if (args.length == 1) {
for (String s : complete) {
if (s.toLowerCase().startsWith(args[0].toLowerCase())) {
result.add(s);
}
}
return result;
} else if (args.length == 2) {
for (Player p : Bukkit.getOnlinePlayers()) {
if (p.getName().toLowerCase().startsWith(args[1].toLowerCase())) {
result.add(p.getName());
}
}
return result;
}
return null;
}
}

108
src/main/java/me/unurled/raxen/commands/player/ClassCommand.java
View file

@ -19,64 +19,64 @@ import org.jetbrains.annotations.Nullable;
public class ClassCommand implements TabExecutor {
private Raxen main;
private Raxen main;
/**
* the Command to choose the class
* @param main
*/
public ClassCommand(Raxen main) {
this.main = main;
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
error(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),
"The console can't execute this Command!"
);
return true;
/**
* the Command to choose the class
* @param main
*/
public ClassCommand(Raxen main) {
this.main = main;
}
Player player = (Player) sender;
Inventory inv = Bukkit.createInventory(
null,
9,
colorTextComp("<grey>Choose your class</grey>")
);
HashMap<String, Class> classes = main
.getManager()
.getPlayerManager()
.getClasses();
if (classes.size() > 10) {
if (classes.size() > 55) {
inv =
Bukkit.createInventory(
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
error(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),
"The console can't execute this Command!"
);
return true;
}
Player player = (Player) sender;
Inventory inv = Bukkit.createInventory(
null,
classes.size(),
9,
colorTextComp("<grey>Choose your class</grey>")
);
}
);
HashMap<String, Class> classes = main
.getManager()
.getPlayerManager()
.getClasses();
if (classes.size() > 10) {
if (classes.size() > 55) {
inv =
Bukkit.createInventory(
null,
classes.size(),
colorTextComp("<grey>Choose your class</grey>")
);
}
}
for (Class clas : classes.values()) {
ItemStack item = clas.getPlaceHolder();
inv.addItem(item);
}
return false;
}
for (Class clas : classes.values()) {
ItemStack item = clas.getPlaceHolder();
inv.addItem(item);
}
return false;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}

100
src/main/java/me/unurled/raxen/commands/player/MainGuiCommand.java
View file

@ -16,57 +16,57 @@ import org.jetbrains.annotations.Nullable;
public class MainGuiCommand implements TabExecutor {
private Raxen main;
private Raxen main;
public MainGuiCommand(Raxen main) {
this.main = main;
}
/**
* @param sender Source of the command
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args Passed command arguments
* @return
*/
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
errorConsoleSender(sender);
return true;
public MainGuiCommand(Raxen main) {
this.main = main;
}
Player p = (Player) sender;
if (!(p.hasPermission("raxen.maingui.cmd"))) {
sender.sendMessage(noPerms());
return true;
}
Inventory inv = MainGui.build(p);
p.openInventory(inv);
return true;
}
/**
* @param sender Source of the command. For players tab-completing a
* command inside of a command block, this will be the player, not
* the command block.
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args The arguments passed to the command, including final
* partial argument to be completed
* @return
*/
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
return null;
}
/**
* @param sender Source of the command
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args Passed command arguments
* @return
*/
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
errorConsoleSender(sender);
return true;
}
Player p = (Player) sender;
if (!(p.hasPermission("raxen.maingui.cmd"))) {
sender.sendMessage(noPerms());
return true;
}
Inventory inv = MainGui.build(p);
p.openInventory(inv);
return true;
}
/**
* @param sender Source of the command. For players tab-completing a
* command inside of a command block, this will be the player, not
* the command block.
* @param command Command which was executed
* @param label Alias of the command which was used
* @param args The arguments passed to the command, including final
* partial argument to be completed
* @return
*/
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
return null;
}
}

224
src/main/java/me/unurled/raxen/commands/player/PartyCommand.java Normal file
View file

@ -0,0 +1,224 @@
package me.unurled.raxen.commands.player;
import java.util.ArrayList;
import java.util.List;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.player.RaxenPlayer;
import me.unurled.raxen.utils.Utils;
import org.bukkit.Bukkit;
import org.bukkit.Sound;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class PartyCommand implements TabExecutor {
Raxen main;
List<String> complete = new ArrayList<>();
public PartyCommand(Raxen main) {
this.main = main;
}
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command,
@NotNull String label, @NotNull String[] args) {
if (!(sender instanceof Player)) {
Utils.errorConsoleSender(sender);
return true;
}
Player player = (Player) sender;
if (player.getWorld().getName().equalsIgnoreCase("tutorial")) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>Sorry, you can't use this command in the tutorial!"));
player.sendMessage(Utils.colorComp(
"<grey>> <green>Please finish the tutorial first. Feel free to ask for help!"));
return true;
}
RaxenPlayer rx = main.getManager().getPlayerManager()
.getRaxenPlayer(player);
if (args.length == 0) {
player.sendMessage(
Utils.colorComp("<reset><yellow>/party help to view all infos on party"));
return true;
}
if (args[0].equalsIgnoreCase("help")) {
player.sendMessage(
Utils.colorComp("<reset><yellow>/party help to view all infos on party"));
player.sendMessage(Utils.colorComp("<reset><yellow>/party create to create a party"));
player.sendMessage(Utils.colorComp(
"<reset><yellow>/party invite <player> to invite a player to your party"));
player.sendMessage(Utils.colorComp("<reset><yellow>/party leave to leave your party"));
player.sendMessage(Utils.colorComp(
"<reset><yellow>/party kick <player> to kick a player from your party"));
player.sendMessage(
Utils.colorComp("<reset><yellow>/party disband to disband your party"));
player.sendMessage(
Utils.colorComp("<reset><yellow>/party accept to accept a party invite"));
player.sendMessage(
Utils.colorComp("<reset><yellow>/party decline to deny a party invite"));
player.sendMessage(
Utils.colorComp("<reset><yellow>/party list to list all members of your party"));
player.sendMessage(
Utils.colorComp("<reset><yellow>\\ before every message to send it to your party"));
return true;
} else if (args[0].equalsIgnoreCase("create")) {
main.getManager().getPartyManager().createParty(player, rx);
return true;
} else if (args[0].equalsIgnoreCase("invite")) {
if (rx.getParty() != null) {
if (args.length != 2) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>Usage: /party invite <player>"));
return true;
} else {
String name = args[1];
Player target = main.getServer().getPlayer(name);
RaxenPlayer rx2 = main.getManager().getPlayerManager()
.getRaxenPlayer(target);
if (rx2 == null || target == null || !target.isOnline()) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>Player not found!"));
return true;
}
if (rx.getParty().isFull()) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>Your party is full!"));
return true;
} else {
rx.getParty().sendInvite(target, rx2, player);
}
}
} else {
player.sendMessage(Utils.colorComp(
"<grey>> <green>You are not in a party!"));
return true;
}
} else if (args[0].equalsIgnoreCase("accept")) {
if (rx.getInvitedParty() == null) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>You have no pending party invites!"));
return true;
} else {
rx.getInvitedParty().addPlayer(player);
rx.setParty(rx.getInvitedParty());
rx.setInvitedParty(null);
return true;
}
} else if (args[0].equalsIgnoreCase("decline")) {
if (rx.getInvitedParty() != null) {
rx.getInvitedParty().sendMessage(Utils.colorComp(
"<grey>> <green>" + player.getName() + " has declined the party invite!"));
}
rx.setInvitedParty(null);
player.sendMessage(Utils.colorComp(
"<grey>> <green>You have declined the party invite!"));
} else if (args[0].equalsIgnoreCase("leave")) {
if (rx.getParty() == null) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>You are not in a party!"));
return true;
} else {
rx.getParty().leavePlayer(player.getUniqueId(), player.getName());
rx.setParty(null);
return true;
}
} else if (args[0].equalsIgnoreCase("kick")) {
if (rx.getParty() == null) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>You are not in a party!"));
return true;
} else {
if (!rx.getParty().isLeader(player)) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>You are not the party leader!"));
return true;
} else {
if (args.length != 2) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>Usage: /party kick <player>"));
return true;
} else {
String name = args[1];
Player target = main.getServer().getPlayer(name);
RaxenPlayer rx2 = main.getManager().getPlayerManager()
.getRaxenPlayer(target);
if (rx2 == null || target == null || !target.isOnline()) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>Player not found!"));
return true;
}
if (!rx2.getParty().equals(rx.getParty())) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>This player is not in your party!"));
return true;
}
if (target.equals(player) || rx.equals(rx2)) {
player.sendMessage(Utils.colorComp(
"<grey>> <green>You can't kick yourself!"));
return true;
}
target.playSound(target.getLocation(), Sound.ENTITY_EXPERIENCE_ORB_PICKUP,
1, 1);
rx.getParty().leavePlayer(target.getUniqueId(), target.getName());
return true;
}
}
}
} else {
if (rx.getParty() != null) {
StringBuilder sb = new StringBuilder();
for (String s : args) {
sb.append(s).append(" ");
}
String message = sb.toString().trim();
rx.getParty().sendMessage(player, Utils.colorComp(
"<reset>" + message));
} else {
player.sendMessage(Utils.colorComp(
"<grey>> <green>Not valid command!"));
player.sendMessage(Utils.colorComp(
"<grey>> <green>/party help to view all infos on party"));
return true;
}
}
return true;
}
@Override
public @Nullable List<String> onTabComplete(@NotNull CommandSender sender,
@NotNull Command command, @NotNull String label, @NotNull String[] args) {
if (complete.isEmpty()) {
complete.add("create");
complete.add("invite");
complete.add("accept");
complete.add("decline");
complete.add("leave");
complete.add("kick");
complete.add("help");
}
List<String> result = new ArrayList<>();
if (args.length == 1) {
for (String s : complete) {
if (s.toLowerCase().startsWith(args[0].toLowerCase())) {
result.add(s);
}
}
return result;
} else if (args.length == 2) {
for (Player p : Bukkit.getOnlinePlayers()) {
if (p.getName().toLowerCase().startsWith(args[1].toLowerCase())) {
result.add(p.getName());
}
}
return result;
}
return null;
}
}

145
src/main/java/me/unurled/raxen/commands/player/SkillsCommand.java
View file

@ -18,76 +18,87 @@ import org.jetbrains.annotations.Nullable;
public class SkillsCommand implements TabExecutor {
private Raxen main;
private Raxen main;
public SkillsCommand(Raxen main) {
this.main = main;
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String msg,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
error(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),
"The console can't execute this Command!"
);
return true;
public SkillsCommand(Raxen main) {
this.main = main;
}
Player player = (Player) sender;
Attributes attributes = new Attributes(main);
switch (args.length) {
case 0:
//open gui
player.sendMessage(
colorTextComp("<red>GUI not implemented yet..")
.append(colorTextComp("<red>Try /skill help."))
);
break;
case 1:
case 2:
player.sendMessage(
colorTextComp("<white>Use the command like: ")
.append(
colorTextComp(
"<white>/skill <dark_aqua>{health|defense|speed|strength} {add|set|remove} {amount}"
)
)
);
break;
case 3:
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
for (String s : pm.getAttribute().keySet()) {
if (s.equalsIgnoreCase(args[0])) switch (args[1]) {
case "add":
pm.getAttribute().get(s).add(player, Integer.parseInt(args[2]));
case "remove":
pm
.getAttribute()
.get(s)
.remove(player, Integer.parseInt(args[2]));
case "set":
pm.getAttribute().get(s).set(player, Integer.parseInt(args[2]));
}
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String msg,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
error(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),
"The console can't execute this Command!"
);
return true;
}
PlayerUtils.updateSkills(main, player);
Player player = (Player) sender;
Attributes attributes = new Attributes(main);
switch (args.length) {
case 0:
//open gui
player.sendMessage(
colorTextComp("<red>GUI not implemented yet..")
.append(colorTextComp("<red>Try /skill help."))
);
break;
case 1:
case 2:
player.sendMessage(
colorTextComp("<white>Use the command like: ")
.append(
colorTextComp(
"<white>/skill <dark_aqua>{health|defense|speed|strength} {add|set|remove} {amount}"
)
)
);
break;
case 3:
PlayerManager pm =
(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen")
).getManager()
.getPlayerManager();
for (String s : pm.getAttribute().keySet()) {
if (s.equalsIgnoreCase(args[0])) switch (args[1]) {
case "add":
pm
.getAttribute()
.get(s)
.add(player, Integer.parseInt(args[2]));
break;
case "remove":
pm
.getAttribute()
.get(s)
.remove(player, Integer.parseInt(args[2]));
break;
case "set":
pm
.getAttribute()
.get(s)
.set(player, Integer.parseInt(args[2]));
break;
}
}
PlayerUtils.updateSkills(main, player);
}
return false;
}
return false;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}

123
src/main/java/me/unurled/raxen/commands/player/StorageCommand.java
View file

@ -16,65 +16,76 @@ import org.jetbrains.annotations.Nullable;
public class StorageCommand implements TabExecutor {
private PlayerManager playerManager;
private PlayerManager playerManager;
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
error(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),
"The console can't execute this Command!"
);
return true;
}
Player player = (Player) sender;
Inventory inv;
playerManager =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
switch (args.length) {
case 0:
if (playerManager.getRaxenPlayer(player).getStorage() == null) {
inv =
playerManager
.getRaxenPlayer(player)
.createStorage()
.getEc()
.getEc();
} else {
inv =
playerManager.getRaxenPlayer(player).getStorage().getEc().getEc();
@Override
public boolean onCommand(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String label,
@NotNull String[] args
) {
if (!(sender instanceof Player)) {
error(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),
"The console can't execute this Command!"
);
return true;
}
player.openInventory(inv);
break;
case 1:
Player p = Bukkit.getPlayer(args[0]);
if (p == null) {
msgPlayer(
player,
colorString("<red>You can't open the Storage of an unknown Player.")
);
return true;
Player player = (Player) sender;
Inventory inv;
playerManager =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
switch (args.length) {
case 0:
if (playerManager.getRaxenPlayer(player).getStorage() == null) {
inv =
playerManager
.getRaxenPlayer(player)
.createStorage()
.getEc()
.getEc();
} else {
inv =
playerManager
.getRaxenPlayer(player)
.getStorage()
.getEc()
.getEc();
}
player.openInventory(inv);
break;
case 1:
Player p = Bukkit.getPlayer(args[0]);
if (p == null) {
msgPlayer(
player,
colorString(
"<red>You can't open the Storage of an unknown Player."
)
);
return true;
}
inv =
playerManager
.getRaxenPlayer(player)
.getStorage()
.getEc()
.getEc();
player.openInventory(inv);
break;
}
inv = playerManager.getRaxenPlayer(player).getStorage().getEc().getEc();
player.openInventory(inv);
break;
return true;
}
return true;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
@Override
public @Nullable List<String> onTabComplete(
@NotNull CommandSender sender,
@NotNull Command command,
@NotNull String alias,
@NotNull String[] args
) {
return null;
}
}

106
src/main/java/me/unurled/raxen/components/dungeons/Dungeon.java
View file

@ -12,67 +12,67 @@ import org.bukkit.Location;
public class Dungeon {
@Getter
private String name;
@Getter
private String name;
@Getter
private Rank rank;
@Getter
private Rank rank;
@Getter
private Gate gate;
@Getter
private Gate gate;
//String, RaxenEntity
@Getter
private HashMap<String, RaxenEntity> monster = new HashMap<>();
//String, RaxenEntity
@Getter
private HashMap<String, RaxenEntity> monster = new HashMap<>();
/**
* The Type of the Dungeon
*/
@Getter
private Types types;
/**
* The Type of the Dungeon
*/
@Getter
private Types types;
/**
* Monster Types
*/
@Getter
private MonsterType monsterType;
/**
* Monster Types
*/
@Getter
private MonsterType monsterType;
@Getter
private Location location;
@Getter
private Location location;
@Getter
private Integer radius;
@Getter
private Integer radius;
public Dungeon(String name, Rank rank, Types types, MonsterType mType) {
this.name = name;
this.rank = rank;
this.types = types;
this.monsterType = mType;
generateGate();
}
public Dungeon(String name, Rank rank, Types types, MonsterType mType) {
this.name = name;
this.rank = rank;
this.types = types;
this.monsterType = mType;
generateGate();
}
/**
* Generate the Gate and make it available to players in the world.
* //TODO: Place the gate at a random place.
*/
public void generateGate() {
// -281.50 36.00 187.50
Location loc = new Location(
Bukkit.getWorld("Liberty_City"),
-284.0,
45.00,
187.50
);
Integer radius = getRadiusFromRank(this.rank);
this.gate = new Gate(name, loc, radius);
}
/**
* Generate the Gate and make it available to players in the world.
* //TODO: Place the gate at a random place.
*/
public void generateGate() {
// -281.50 36.00 187.50
Location loc = new Location(
Bukkit.getWorld("Liberty_City"),
-284.0,
45.00,
187.50
);
Integer radius = getRadiusFromRank(this.rank);
this.gate = new Gate(name, loc, radius);
}
/**
* //TODO: Terrain Generation of the inside of the Dungeons
*/
public void generate() {
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
main.getManager().getWorldManager().loadWorld(name);
monsterType.genMonster(Bukkit.getWorld(name), rank);
}
/**
* //TODO: Terrain Generation of the inside of the Dungeons
*/
public void generate() {
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
main.getManager().getWorldManager().loadWorld(name);
monsterType.genMonster(Bukkit.getWorld(name), rank);
}
}

78
src/main/java/me/unurled/raxen/components/dungeons/Gate.java
View file

@ -6,39 +6,39 @@ import org.bukkit.Material;
public class Gate {
private String name;
private String name;
private Location loc;
private Integer portalRadius;
private Location loc;
private Integer portalRadius;
public Gate(String name, Location loc, Integer portalRadius) {
this.loc = loc;
this.portalRadius = portalRadius;
this.name = name;
}
public void teleport() {}
public void genGate() {
// get which side it's gonna expand with radius
Random r = new Random();
Boolean xExpend = false;
if (r.nextInt(2) == 0) {
xExpend = true;
public Gate(String name, Location loc, Integer portalRadius) {
this.loc = loc;
this.portalRadius = portalRadius;
this.name = name;
}
// place blocks
for (double i = 0; i <= Math.PI; i += Math.PI / portalRadius) {
double radius = Math.sin(i);
double y = Math.cos(i);
for (double a = 0; a < Math.PI * 2; a += Math.PI / portalRadius) {
double x = Math.cos(a) * radius;
double z = Math.sin(a) * radius;
Location locc = new Location(loc.getWorld(), x, y, z);
loc.getBlock().setType(Material.NETHER_PORTAL);
}
}
/*
public void teleport() {}
public void genGate() {
// get which side it's gonna expand with radius
Random r = new Random();
Boolean xExpend = false;
if (r.nextInt(2) == 0) {
xExpend = true;
}
// place blocks
for (double i = 0; i <= Math.PI; i += Math.PI / portalRadius) {
double radius = Math.sin(i);
double y = Math.cos(i);
for (double a = 0; a < Math.PI * 2; a += Math.PI / portalRadius) {
double x = Math.cos(a) * radius;
double z = Math.sin(a) * radius;
Location locc = new Location(loc.getWorld(), x, y, z);
loc.getBlock().setType(Material.NETHER_PORTAL);
}
}
/*
for (int n=0; n<portalRadius ; n++) {
Double x = loc.getX();
Double y = loc.getY();
@ -53,17 +53,17 @@ public class Gate {
}
*/
}
}
public Location getLoc() {
return loc;
}
public Location getLoc() {
return loc;
}
public Integer getPortalRadius() {
return portalRadius;
}
public Integer getPortalRadius() {
return portalRadius;
}
public String getName() {
return name;
}
public String getName() {
return name;
}
}

24
src/main/java/me/unurled/raxen/components/dungeons/Rank.java
View file

@ -1,16 +1,16 @@
package me.unurled.raxen.components.dungeons;
public enum Rank {
F,
E,
D,
C,
B,
A,
S,
SS,
SSS,
WORLD,
UNBEATABLE,
NOT_DEFINED,
F,
E,
D,
C,
B,
A,
S,
SS,
SSS,
WORLD,
UNBEATABLE,
NOT_DEFINED
}

8
src/main/java/me/unurled/raxen/components/dungeons/Type.java
View file

@ -7,11 +7,11 @@ import me.unurled.raxen.components.lootchest.loots.LootItem;
public class Type {
public String name;
public String name;
public Map<String, RaxenEntity> monster = new HashMap<>();
public Map<String, RaxenEntity> monster = new HashMap<>();
public Map<String, LootItem> lootItem = new HashMap<>();
// public Map<String, > chest
public Map<String, LootItem> lootItem = new HashMap<>();
// public Map<String, > chest
}

32
src/main/java/me/unurled/raxen/components/dungeons/Types.java
View file

@ -1,20 +1,20 @@
package me.unurled.raxen.components.dungeons;
public enum Types {
JUNGLE,
TROPICAL_JUNGLE,
PLAINS,
GRAVES,
CASTLE,
ABANDONED_CASTLE,
FIELD,
ICE_FOREST,
FOREST,
VOLCANO,
MOUNTAINS,
HIGH_MOUNTAINS,
CAVES,
LABYRINTH,
UNDERGROUND_LABYRINTH,
FOREST_LABYRINTH,
JUNGLE,
TROPICAL_JUNGLE,
PLAINS,
GRAVES,
CASTLE,
ABANDONED_CASTLE,
FIELD,
ICE_FOREST,
FOREST,
VOLCANO,
MOUNTAINS,
HIGH_MOUNTAINS,
CAVES,
LABYRINTH,
UNDERGROUND_LABYRINTH,
FOREST_LABYRINTH
}

164
src/main/java/me/unurled/raxen/components/dungeons/types/MonsterType.java
View file

@ -16,93 +16,93 @@ import org.jetbrains.annotations.Nullable;
public class MonsterType {
public enum type {
;
public enum type {
;
private Double rate;
public String ID;
public Class clazz;
private Double rate;
public String ID;
public Class clazz;
type(Double rate, String ID, Class clazz) {
this.rate = rate;
this.ID = ID;
this.clazz = clazz;
}
public static @Nullable type getTypeById(String ID) {
for (type type : type.values()) {
if (type.ID.equals(ID)) {
return type;
type(Double rate, String ID, Class clazz) {
this.rate = rate;
this.ID = ID;
this.clazz = clazz;
}
}
return null;
}
public Double getRate() {
return rate;
}
public void setRate(Double rate) {
this.rate = rate;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public Class getClazz() {
return clazz;
}
public void getClazz(Class clazz) {
this.clazz = clazz;
}
}
public void genMonster(World world, Rank rank) {
Double x = 0.0;
Double y = 100.0;
Double z = 0.0;
for (type type : type.values()) {
type.name();
Random r = new Random();
int per = r.nextInt(100);
if (per >= type.rate) {
// spawn entity
debug("Spawning Entity " + type.ID);
Entity e = world.spawnEntity(
new Location(world, x, y, z),
EntityType.ARROW
);
// e = ((RaxenEntity) type.getClazz()).createEntity();
e.setInvulnerable(true);
BukkitTask task = new BukkitRunnable() {
@Override
public void run() {
Location loc = new Location(
e.getWorld(),
e.getLocation().getX(),
e.getLocation().getY() - 1,
e.getLocation().getZ()
);
if (loc.getBlock().getType() != Material.AIR) {
e.setInvulnerable(false);
this.cancel();
public static @Nullable type getTypeById(String ID) {
for (type type : type.values()) {
if (type.ID.equals(ID)) {
return type;
}
}
}
return null;
}
public Double getRate() {
return rate;
}
public void setRate(Double rate) {
this.rate = rate;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public Class getClazz() {
return clazz;
}
public void getClazz(Class clazz) {
this.clazz = clazz;
}
}
public void genMonster(World world, Rank rank) {
Double x = 0.0;
Double y = 100.0;
Double z = 0.0;
for (type type : type.values()) {
type.name();
Random r = new Random();
int per = r.nextInt(100);
if (per >= type.rate) {
// spawn entity
debug("Spawning Entity " + type.ID);
Entity e = world.spawnEntity(
new Location(world, x, y, z),
EntityType.ARROW
);
// e = ((RaxenEntity) type.getClazz()).createEntity();
e.setInvulnerable(true);
BukkitTask task = new BukkitRunnable() {
@Override
public void run() {
Location loc = new Location(
e.getWorld(),
e.getLocation().getX(),
e.getLocation().getY() - 1,
e.getLocation().getZ()
);
if (loc.getBlock().getType() != Material.AIR) {
e.setInvulnerable(false);
this.cancel();
}
}
}
.runTaskTimerAsynchronously(
Bukkit.getPluginManager().getPlugin("Raxen"),
0L,
20L
);
}
x = 5.0 + (50.0 - 5.0) * r.nextDouble();
z = 5.0 + (50.0 - 5.0) * r.nextDouble();
}
.runTaskTimerAsynchronously(
Bukkit.getPluginManager().getPlugin("Raxen"),
0L,
20L
);
}
x = 5.0 + (50.0 - 5.0) * r.nextDouble();
z = 5.0 + (50.0 - 5.0) * r.nextDouble();
}
}
}

17
src/main/java/me/unurled/raxen/components/dungeons/types/forest/ForestDungeon.java
View file

@ -7,11 +7,16 @@ import me.unurled.raxen.components.dungeons.types.MonsterType;
public class ForestDungeon extends Dungeon {
public ForestDungeon(String name, Rank rank, Types types, MonsterType mType) {
super(name, rank, types, mType);
}
public ForestDungeon(
String name,
Rank rank,
Types types,
MonsterType mType
) {
super(name, rank, types, mType);
}
public ForestDungeon() {
super("Forest", Rank.E, Types.FOREST, new ForestMonster());
}
public ForestDungeon() {
super("Forest", Rank.E, Types.FOREST, new ForestMonster());
}
}

24
src/main/java/me/unurled/raxen/components/dungeons/types/forest/ForestMonster.java
View file

@ -7,19 +7,19 @@ import me.unurled.raxen.components.entity.other.custom.dungeon.forest.Wolf;
public class ForestMonster extends MonsterType {
@Getter
enum type {
ELF(50.0, "ELF", Elf.class),
WOLF(50.0, "WOLF", Wolf.class);
@Getter
enum type {
ELF(50.0, "ELF", Elf.class),
WOLF(50.0, "WOLF", Wolf.class);
private Double rate;
public String ID;
public Class clazz;
private Double rate;
public String ID;
public Class clazz;
type(Double rate, String ID, Class clazz) {
this.rate = rate;
this.ID = ID;
this.clazz = clazz;
type(Double rate, String ID, Class clazz) {
this.rate = rate;
this.ID = ID;
this.clazz = clazz;
}
}
}
}

5
src/main/java/me/unurled/raxen/components/effect/EffectBuilder.java Normal file
View file

@ -0,0 +1,5 @@
package me.unurled.raxen.components.effect;
public class EffectBuilder {
}

146
src/main/java/me/unurled/raxen/components/enchantments/EnchantmentWarpper.java
View file

@ -14,94 +14,94 @@ import org.jetbrains.annotations.NotNull;
public class EnchantmentWarpper extends Enchantment {
private final int maxLevel;
private final int maxLevel;
public EnchantmentWarpper(String nameSpace, String name, int lvl) {
super(NamespacedKey.minecraft(nameSpace));
this.maxLevel = lvl;
}
public EnchantmentWarpper(String nameSpace, String name, int lvl) {
super(NamespacedKey.minecraft(nameSpace));
this.maxLevel = lvl;
}
@Override
@Deprecated
public @NotNull String getName() {
return null;
}
@Override
@Deprecated
public @NotNull String getName() {
return null;
}
@Override
public int getMaxLevel() {
return maxLevel;
}
@Override
public int getMaxLevel() {
return maxLevel;
}
@Override
public int getStartLevel() {
return 0;
}
@Override
public int getStartLevel() {
return 0;
}
@Override
public @NotNull EnchantmentTarget getItemTarget() {
return null;
}
@Override
public @NotNull EnchantmentTarget getItemTarget() {
return null;
}
@Override
public boolean isTreasure() {
return false;
}
@Override
public boolean isTreasure() {
return false;
}
@Override
public boolean isCursed() {
return false;
}
@Override
public boolean isCursed() {
return false;
}
@Override
public boolean conflictsWith(@NotNull Enchantment other) {
return false;
}
@Override
public boolean conflictsWith(@NotNull Enchantment other) {
return false;
}
@Override
public boolean canEnchantItem(@NotNull ItemStack item) {
return false;
}
@Override
public boolean canEnchantItem(@NotNull ItemStack item) {
return false;
}
@Override
public @NotNull Component displayName(int level) {
return null;
}
@Override
public @NotNull Component displayName(int level) {
return null;
}
@Override
public boolean isTradeable() {
return false;
}
@Override
public boolean isTradeable() {
return false;
}
@Override
public boolean isDiscoverable() {
return false;
}
@Override
public boolean isDiscoverable() {
return false;
}
@Override
public @NotNull EnchantmentRarity getRarity() {
return null;
}
@Override
public @NotNull EnchantmentRarity getRarity() {
return null;
}
@Override
public float getDamageIncrease(
int level,
@NotNull EntityCategory entityCategory
) {
return 0;
}
@Override
public float getDamageIncrease(
int level,
@NotNull EntityCategory entityCategory
) {
return 0;
}
@Override
public @NotNull Set<EquipmentSlot> getActiveSlots() {
return null;
}
@Override
public @NotNull Set<EquipmentSlot> getActiveSlots() {
return null;
}
@Override
public @NotNull String translationKey() {
return null;
}
@Override
public @NotNull String translationKey() {
return null;
}
@Override
public @NotNull Key key() {
return super.key();
}
@Override
public @NotNull Key key() {
return super.key();
}
}

10
src/main/java/me/unurled/raxen/components/enchantments/player/Telekinesis.java
View file

@ -6,9 +6,9 @@ import org.bukkit.event.Listener;
public class Telekinesis implements Listener {
public static final Enchantment TELEKINESIS = new EnchantmentWarpper(
"telekinesis",
"telekinesis",
1
);
public static final Enchantment TELEKINESIS = new EnchantmentWarpper(
"telekinesis",
"telekinesis",
1
);
}

292
src/main/java/me/unurled/raxen/components/entity/Attributes/Attribute.java
View file

@ -1,6 +1,7 @@
package me.unurled.raxen.components.entity.Attributes;
import static me.unurled.raxen.utils.Utils.debug;
import static me.unurled.raxen.utils.Utils.log;
import de.tr7zw.nbtapi.NBTItem;
import org.bukkit.Material;
@ -14,158 +15,161 @@ import org.jetbrains.annotations.NotNull;
public class Attribute {
/**
* The NamespaceKey register for the PersistentDataContainer.
* static NamespacedKey namespacekey = namespacedKey.TYPE;
*/
public NamespacedKey namespacekey;
/**
* The NamespaceKey register for the PersistentDataContainer.
* static NamespacedKey namespacekey = namespacedKey.TYPE;
*/
public NamespacedKey namespacekey;
/**
* The name of the attribute
* static String name = "null";
*/
public String name;
/**
* The name of the attribute
* static String name = "null";
*/
public String name;
public Attribute(NamespacedKey namespacekey, String name) {
this.namespacekey = namespacekey;
this.name = name;
}
public Attribute(NamespacedKey namespacekey, String name) {
this.namespacekey = namespacekey;
this.name = name;
}
/**
* gives the name uppercased
* @return the name in uppercase
*/
public String nameUppercase() {
return name.toUpperCase();
}
/**
* gives the name uppercased
* @return the name in uppercase
*/
public String nameUppercase() {
return name.toUpperCase();
}
/**
* get how many the Entity has Attributed
* @param entity a living entity
* @return the amount of attribute
*/
public Integer get(@NotNull Entity entity) {
if (
entity
.getPersistentDataContainer()
.has(namespacekey, PersistentDataType.INTEGER)
) {
debug(
" attribute gett" +
/**
* get how many the Entity has Attributed
* @param entity a living entity
* @return the amount of attribute
*/
public Integer get(@NotNull Entity entity) {
if (
entity
.getPersistentDataContainer()
.has(namespacekey, PersistentDataType.INTEGER)
) {
debug(
" attribute gett" +
entity
.getPersistentDataContainer()
.get(namespacekey, PersistentDataType.INTEGER)
);
return entity
.getPersistentDataContainer()
.get(namespacekey, PersistentDataType.INTEGER);
}
debug(
name +
" not found in Entity: " +
entity.getType().toString() +
" " +
entity.getName() +
" " +
entity.getUniqueId().toString()
);
set(entity, 0);
return 0;
}
/**
* get how many the Entity has Attributed
* @param it an ItemStack
* @return the amount of attribute
*/
public Integer get(@NotNull ItemStack it) {
NBTItem nbti = new NBTItem(it);
if (nbti.hasTag(name)) {
return nbti.getInteger(name);
}
return 0;
}
/**
* Get the amount of attribute on the item
* @param e a LivingEntity
* @return an amount of attribute on the item
*/
public Integer getItem(@NotNull LivingEntity e) {
EntityEquipment equi = e.getEquipment();
Integer attribute = 0;
if (equi != null) {
if (
equi.getItemInMainHand().getType() != Material.AIR &&
equi.getHelmet() != null
) {
ItemStack item = equi.getItemInMainHand();
attribute = attribute + get(item);
}
if (
equi.getHelmet().getType() != Material.AIR &&
equi.getHelmet() != null
) {
ItemStack item = equi.getHelmet();
attribute = attribute + get(item);
}
if (
equi.getChestplate().getType() != Material.AIR &&
equi.getChestplate() != null
) {
ItemStack item = equi.getChestplate();
attribute = attribute + get(item);
}
if (
equi.getChestplate().getType() != Material.AIR &&
equi.getChestplate() != null
) {
ItemStack item = equi.getChestplate();
attribute = attribute + get(item);
}
if (
equi.getLeggings().getType() != Material.AIR &&
equi.getLeggings() != null
) {
ItemStack item = equi.getLeggings();
attribute = attribute + get(item);
}
if (
equi.getBoots().getType() != Material.AIR &&
equi.getBoots() != null
) {
ItemStack item = equi.getBoots();
attribute = attribute + get(item);
}
}
return attribute;
}
/**
* set amount to the entity's attribute
* @param entity a living entity
* @param amount the amount you want to set
*/
public void set(@NotNull Entity entity, @NotNull Integer amount) {
entity
.getPersistentDataContainer()
.get(namespacekey, PersistentDataType.INTEGER)
);
return entity
.getPersistentDataContainer()
.get(namespacekey, PersistentDataType.INTEGER);
.getPersistentDataContainer()
.set(namespacekey, PersistentDataType.INTEGER, amount);
debug("set " + name + " " + amount);
}
debug(
name +
" not found in Entity: " +
entity.getType().toString() +
" " +
entity.getName() +
" " +
entity.getUniqueId().toString()
);
set(entity, 0);
return 0;
}
/**
* get how many the Entity has Attributed
* @param it an ItemStack
* @return the amount of attribute
*/
public Integer get(@NotNull ItemStack it) {
NBTItem nbti = new NBTItem(it);
if (nbti.hasTag(name)) {
return nbti.getInteger(name);
/**
* add amount to the entity's attribute
* @param entity a living entity
* @param amount the amount you want to set
*/
public void add(@NotNull Entity entity, @NotNull Integer amount) {
log(get(entity) + " " + amount);
set(entity, get(entity) + amount);
}
return 0;
}
/**
* Get the amount of attribute on the item
* @param e a LivingEntity
* @return an amount of attribute on the item
*/
public Integer getItem(@NotNull LivingEntity e) {
EntityEquipment equi = e.getEquipment();
Integer attribute = 0;
if (equi != null) {
if (
equi.getItemInMainHand().getType() != Material.AIR &&
equi.getHelmet() != null
) {
ItemStack item = equi.getItemInMainHand();
attribute = attribute + get(item);
}
if (
equi.getHelmet().getType() != Material.AIR && equi.getHelmet() != null
) {
ItemStack item = equi.getHelmet();
attribute = attribute + get(item);
}
if (
equi.getChestplate().getType() != Material.AIR &&
equi.getChestplate() != null
) {
ItemStack item = equi.getChestplate();
attribute = attribute + get(item);
}
if (
equi.getChestplate().getType() != Material.AIR &&
equi.getChestplate() != null
) {
ItemStack item = equi.getChestplate();
attribute = attribute + get(item);
}
if (
equi.getLeggings().getType() != Material.AIR &&
equi.getLeggings() != null
) {
ItemStack item = equi.getLeggings();
attribute = attribute + get(item);
}
if (
equi.getBoots().getType() != Material.AIR && equi.getBoots() != null
) {
ItemStack item = equi.getBoots();
attribute = attribute + get(item);
}
/**
* remove amount to the entity's attribute
* @param entity a living entity
* @param amount the amount you want to set
*/
public void remove(@NotNull Entity entity, @NotNull Integer amount) {
set(entity, get(entity) - amount);
}
return attribute;
}
/**
* set amount to the entity's attribute
* @param entity a living entity
* @param amount the amount you want to set
*/
public void set(@NotNull Entity entity, @NotNull Integer amount) {
entity
.getPersistentDataContainer()
.set(namespacekey, PersistentDataType.INTEGER, amount);
debug("set " + name + " " + amount);
}
/**
* add amount to the entity's attribute
* @param entity a living entity
* @param amount the amount you want to set
*/
public void add(@NotNull Entity entity, @NotNull Integer amount) {
set(entity, get(entity) + amount);
}
/**
* remove amount to the entity's attribute
* @param entity a living entity
* @param amount the amount you want to set
*/
public void remove(@NotNull Entity entity, @NotNull Integer amount) {
set(entity, get(entity) - amount);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/Defense.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class Defense extends Attribute {
public Defense(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public Defense(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/Health.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class Health extends Attribute {
public Health(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public Health(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/ItemDefense.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class ItemDefense extends Attribute {
public ItemDefense(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public ItemDefense(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/ItemHealth.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class ItemHealth extends Attribute {
public ItemHealth(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public ItemHealth(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/ItemLuck.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class ItemLuck extends Attribute {
public ItemLuck(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public ItemLuck(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/ItemMana.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class ItemMana extends Attribute {
public ItemMana(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public ItemMana(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/ItemSpeed.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class ItemSpeed extends Attribute {
public ItemSpeed(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public ItemSpeed(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/ItemStrength.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class ItemStrength extends Attribute {
public ItemStrength(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public ItemStrength(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/Luck.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class Luck extends Attribute {
public Luck(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public Luck(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/Mana.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class Mana extends Attribute {
public Mana(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public Mana(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/MaxHealth.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class MaxHealth extends Attribute {
public MaxHealth(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public MaxHealth(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/MaxMana.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class MaxMana extends Attribute {
public MaxMana(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public MaxMana(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

26
src/main/java/me/unurled/raxen/components/entity/Attributes/MaxManaBuilder.java
View file

@ -4,20 +4,20 @@ import org.bukkit.NamespacedKey;
public class MaxManaBuilder {
private NamespacedKey namespacekey;
private String name;
private NamespacedKey namespacekey;
private String name;
public MaxManaBuilder setNamespacekey(NamespacedKey namespacekey) {
this.namespacekey = namespacekey;
return this;
}
public MaxManaBuilder setNamespacekey(NamespacedKey namespacekey) {
this.namespacekey = namespacekey;
return this;
}
public MaxManaBuilder setName(String name) {
this.name = name;
return this;
}
public MaxManaBuilder setName(String name) {
this.name = name;
return this;
}
public MaxMana createMaxMana() {
return new MaxMana(namespacekey, name);
}
public MaxMana createMaxMana() {
return new MaxMana(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/Speed.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class Speed extends Attribute {
public Speed(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public Speed(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

6
src/main/java/me/unurled/raxen/components/entity/Attributes/Strength.java
View file

@ -4,7 +4,7 @@ import org.bukkit.NamespacedKey;
public class Strength extends Attribute {
public Strength(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
public Strength(NamespacedKey namespacekey, String name) {
super(namespacekey, name);
}
}

10
src/main/java/me/unurled/raxen/components/entity/DamageType.java Normal file
View file

@ -0,0 +1,10 @@
package me.unurled.raxen.components.entity;
public enum DamageType {
NORMAL,
NORMAL_SPELL,
ENVIRONMENTAL_LAVA,
ENVIRONMENTAL_DROWNING,
ENVIRONMENTAL_FALL,
ENVIRONMENTAL_INSTANT;
}

76
src/main/java/me/unurled/raxen/components/entity/other/EntityNamespacedKey.java
View file

@ -5,43 +5,43 @@ import org.bukkit.NamespacedKey;
public class EntityNamespacedKey {
public EntityNamespacedKey(Raxen main) {
name = new NamespacedKey(main, "NAME");
level = new NamespacedKey(main, "LEVEL");
maxHealth = new NamespacedKey(main, "MAX_HEALTH");
health = new NamespacedKey(main, "HEALTH");
itemHealth = new NamespacedKey(main, "ITEM_HEALTH");
speed = new NamespacedKey(main, "SPEED");
itemSpeed = new NamespacedKey(main, "ITEM_SPEED");
defense = new NamespacedKey(main, "DEFENSE");
itemDefense = new NamespacedKey(main, "ITEM_DEFENSE");
strength = new NamespacedKey(main, "STRENGTH");
itemStrength = new NamespacedKey(main, "ITEM_STRENGTH");
maxMana = new NamespacedKey(main, "MAX_MANA");
mana = new NamespacedKey(main, "MANA");
itemMana = new NamespacedKey(main, "ITEM_MANA");
luck = new NamespacedKey(main, "LUCK");
itemLuck = new NamespacedKey(main, "ITEM_LUCK");
inventory = new NamespacedKey(main, "INVENTORY");
storage = new NamespacedKey(main, "STORAGE");
}
public EntityNamespacedKey(Raxen main) {
name = new NamespacedKey(main, "NAME");
level = new NamespacedKey(main, "LEVEL");
maxHealth = new NamespacedKey(main, "MAX_HEALTH");
health = new NamespacedKey(main, "HEALTH");
itemHealth = new NamespacedKey(main, "ITEM_HEALTH");
speed = new NamespacedKey(main, "SPEED");
itemSpeed = new NamespacedKey(main, "ITEM_SPEED");
defense = new NamespacedKey(main, "DEFENSE");
itemDefense = new NamespacedKey(main, "ITEM_DEFENSE");
strength = new NamespacedKey(main, "STRENGTH");
itemStrength = new NamespacedKey(main, "ITEM_STRENGTH");
maxMana = new NamespacedKey(main, "MAX_MANA");
mana = new NamespacedKey(main, "MANA");
itemMana = new NamespacedKey(main, "ITEM_MANA");
luck = new NamespacedKey(main, "LUCK");
itemLuck = new NamespacedKey(main, "ITEM_LUCK");
inventory = new NamespacedKey(main, "INVENTORY");
storage = new NamespacedKey(main, "STORAGE");
}
public final NamespacedKey name;
public final NamespacedKey level;
public final NamespacedKey maxHealth;
public final NamespacedKey health;
public final NamespacedKey itemHealth;
public final NamespacedKey speed;
public final NamespacedKey itemSpeed;
public final NamespacedKey defense;
public final NamespacedKey itemDefense;
public final NamespacedKey strength;
public final NamespacedKey itemStrength;
public final NamespacedKey maxMana;
public final NamespacedKey mana;
public final NamespacedKey itemMana;
public final NamespacedKey luck;
public final NamespacedKey itemLuck;
public final NamespacedKey inventory;
public final NamespacedKey storage;
public final NamespacedKey name;
public final NamespacedKey level;
public final NamespacedKey maxHealth;
public final NamespacedKey health;
public final NamespacedKey itemHealth;
public final NamespacedKey speed;
public final NamespacedKey itemSpeed;
public final NamespacedKey defense;
public final NamespacedKey itemDefense;
public final NamespacedKey strength;
public final NamespacedKey itemStrength;
public final NamespacedKey maxMana;
public final NamespacedKey mana;
public final NamespacedKey itemMana;
public final NamespacedKey luck;
public final NamespacedKey itemLuck;
public final NamespacedKey inventory;
public final NamespacedKey storage;
}

192
src/main/java/me/unurled/raxen/components/entity/other/EntityUtils.java
View file

@ -12,94 +12,114 @@ import org.jetbrains.annotations.NotNull;
public class EntityUtils {
private static Raxen main;
private static EntityNamespacedKey namespacedKey;
private static Raxen main;
private static EntityNamespacedKey namespacedKey;
public EntityUtils(Raxen main) {
this.main = main;
namespacedKey = new EntityNamespacedKey(main);
}
public static void setNameSpacedKeys(
org.bukkit.entity.@NotNull Entity e,
String name,
Integer level,
int health,
int itemHealth,
int defense,
int itemDefense,
int speed,
int itemSpeed,
int strength,
int itemDmg
) {
PersistentDataContainer data = e.getPersistentDataContainer();
data.set(namespacedKey.health, PersistentDataType.INTEGER, health);
data.set(namespacedKey.itemHealth, PersistentDataType.INTEGER, itemHealth);
data.set(namespacedKey.speed, PersistentDataType.INTEGER, speed);
data.set(namespacedKey.itemSpeed, PersistentDataType.INTEGER, itemSpeed);
data.set(namespacedKey.defense, PersistentDataType.INTEGER, defense);
data.set(
namespacedKey.itemDefense,
PersistentDataType.INTEGER,
itemDefense
);
data.set(namespacedKey.strength, PersistentDataType.INTEGER, strength);
data.set(namespacedKey.itemStrength, PersistentDataType.INTEGER, itemDmg);
data.set(namespacedKey.name, PersistentDataType.STRING, name);
data.set(namespacedKey.level, PersistentDataType.INTEGER, level);
}
public static void updateSkills(@NotNull LivingEntity livingEntity) {
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
defense = pm.getDefense().get(livingEntity);
maxMana = pm.getMaxMana().get(livingEntity);
itemDefense = pm.getItemDefense().get(livingEntity);
health = pm.getHealth().get(livingEntity);
itemHealth = pm.getItemHealth().get(livingEntity);
mana = pm.getMana().get(livingEntity);
speed = pm.getSpeed().get(livingEntity);
itemLuck = pm.getItemLuck().get(livingEntity);
strength = pm.getStrength().get(livingEntity);
luck = pm.getLuck().get(livingEntity);
maxHealth = pm.getMaxHealth().get(livingEntity);
itemStrength = pm.getItemStrength().get(livingEntity);
itemSpeed = pm.getItemSpeed().get(livingEntity);
itemMana = pm.getItemMana().get(livingEntity);
if (
livingEntity.getAttribute(
org.bukkit.attribute.Attribute.GENERIC_FLYING_SPEED
) !=
null
) {
livingEntity
.getAttribute(org.bukkit.attribute.Attribute.GENERIC_FLYING_SPEED)
.setBaseValue((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
public EntityUtils(Raxen main) {
this.main = main;
namespacedKey = new EntityNamespacedKey(main);
}
if (
livingEntity.getAttribute(
org.bukkit.attribute.Attribute.GENERIC_MOVEMENT_SPEED
) !=
null
public static void setNameSpacedKeys(
org.bukkit.entity.@NotNull Entity e,
String name,
Integer level,
int health,
int itemHealth,
int defense,
int itemDefense,
int speed,
int itemSpeed,
int strength,
int itemDmg
) {
livingEntity
.getAttribute(org.bukkit.attribute.Attribute.GENERIC_MOVEMENT_SPEED)
.setBaseValue((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
PersistentDataContainer data = e.getPersistentDataContainer();
data.set(namespacedKey.health, PersistentDataType.INTEGER, health);
data.set(
namespacedKey.itemHealth,
PersistentDataType.INTEGER,
itemHealth
);
data.set(namespacedKey.speed, PersistentDataType.INTEGER, speed);
data.set(
namespacedKey.itemSpeed,
PersistentDataType.INTEGER,
itemSpeed
);
data.set(namespacedKey.defense, PersistentDataType.INTEGER, defense);
data.set(
namespacedKey.itemDefense,
PersistentDataType.INTEGER,
itemDefense
);
data.set(namespacedKey.strength, PersistentDataType.INTEGER, strength);
data.set(
namespacedKey.itemStrength,
PersistentDataType.INTEGER,
itemDmg
);
data.set(namespacedKey.name, PersistentDataType.STRING, name);
data.set(namespacedKey.level, PersistentDataType.INTEGER, level);
}
public static void updateSkills(@NotNull LivingEntity livingEntity) {
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
defense = pm.getDefense().get(livingEntity);
maxMana = pm.getMaxMana().get(livingEntity);
itemDefense = pm.getItemDefense().get(livingEntity);
health = pm.getHealth().get(livingEntity);
itemHealth = pm.getItemHealth().get(livingEntity);
mana = pm.getMana().get(livingEntity);
speed = pm.getSpeed().get(livingEntity);
itemLuck = pm.getItemLuck().get(livingEntity);
strength = pm.getStrength().get(livingEntity);
luck = pm.getLuck().get(livingEntity);
maxHealth = pm.getMaxHealth().get(livingEntity);
itemStrength = pm.getItemStrength().get(livingEntity);
itemSpeed = pm.getItemSpeed().get(livingEntity);
itemMana = pm.getItemMana().get(livingEntity);
if (
livingEntity.getAttribute(
org.bukkit.attribute.Attribute.GENERIC_FLYING_SPEED
) !=
null
) {
livingEntity
.getAttribute(
org.bukkit.attribute.Attribute.GENERIC_FLYING_SPEED
)
.setBaseValue(
(float) (0.0 + ((speed + itemSpeed) / 100) * 0.2)
);
}
if (
livingEntity.getAttribute(
org.bukkit.attribute.Attribute.GENERIC_MOVEMENT_SPEED
) !=
null
) {
livingEntity
.getAttribute(
org.bukkit.attribute.Attribute.GENERIC_MOVEMENT_SPEED
)
.setBaseValue(
(float) (0.0 + ((speed + itemSpeed) / 100) * 0.2)
);
}
livingEntity
.getAttribute(org.bukkit.attribute.Attribute.GENERIC_MAX_HEALTH)
.setBaseValue(20D + (health + itemHealth) / 100);
debug(
"Entity " + livingEntity.getType().name(),
"Speed " + (speed + itemSpeed),
"Health " + (health + itemHealth) + " Max Health " + maxHealth,
"Defense " + (defense + itemDefense),
"Strength " + (strength + itemStrength),
"Luck " + (luck + itemLuck),
"Mana " + (mana + itemMana) + " Max Mana " + maxMana
);
}
livingEntity
.getAttribute(org.bukkit.attribute.Attribute.GENERIC_MAX_HEALTH)
.setBaseValue(20D + (health + itemHealth) / 100);
debug(
"Entity " + livingEntity.getType().name(),
"Speed " + (speed + itemSpeed),
"Health " + (health + itemHealth) + " Max Health " + maxHealth,
"Defense " + (defense + itemDefense),
"Strength " + (strength + itemStrength),
"Luck " + (luck + itemLuck),
"Mana " + (mana + itemMana) + " Max Mana " + maxMana
);
}
}

352
src/main/java/me/unurled/raxen/components/entity/other/MobData.java Normal file
View file

@ -0,0 +1,352 @@
package me.unurled.raxen.components.entity.other;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.UUID;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.Attributes.Attribute;
import me.unurled.raxen.components.entity.Attributes.Health;
import me.unurled.raxen.components.entity.DamageType;
import me.unurled.raxen.components.entity.player.RaxenPlayer;
import me.unurled.raxen.manager.entity.EntityManager;
import me.unurled.raxen.utils.EntityUtils;
import me.unurled.raxen.utils.Tags;
import me.unurled.raxen.utils.Utils;
import net.kyori.adventure.text.Component;
import net.minecraft.world.entity.Entity;
import org.bukkit.Bukkit;
import org.bukkit.EntityEffect;
import org.bukkit.Location;
import org.bukkit.Sound;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
public class MobData {
public Raxen main;
private static int MOB_ID = 0;
public int id = MOB_ID++;
public boolean dead = false;
public LivingEntity entity;
public LivingEntity mount = null;
String nameWithoutLevel;
String fullName;
public MobType mobType;
public Attribute attributes;
public HashMap<UUID, Long> lastAttackedByTimes;
public HashMap<UUID, Long> damageDealt;
public long lastDamaged = 0;
public long lastKnockback = 0;
public boolean despawned = false;
public long invuln = 0; // cannot attack or damage
private Runnable lastScheduledRevertHP = null;
// TODO: public ArrayList<MobAttributes> attributes;
// TODO: mob ai
// TODO: mob spawn
public MobData() {
lastAttackedByTimes = new HashMap<>();
damageDealt = new HashMap<>();
}
public void mount(Class<? extends Entity> mountClass) {
if (entity == null || dead) {
return;
}
mount = EntityUtils.createLivingEntity(mountClass, entity.getLocation());
mount.addPassenger(entity);
}
public void die() {
die(true);
}
public void die(boolean drop) {
if (dead) {
return;
}
dead = true;
Location deathLoc = entity.getLocation();
entity.customName(Component.text(fullName));
Tags.makeFloatingText("<gold>+" + mobType.xp + " XP", deathLoc, 1.3, 1.0, 1.5, 1);
if (mount != null) {
try {
mount.eject();
entity.leaveVehicle();
} catch (Exception e) {
e.printStackTrace();
}
mount.damage(1000000000);
}
entity.damage(1000000000);
new BukkitRunnable() {
@Override
public void run() {
despawn();
}
}.runTaskLater(main, 20);
int totalLevel = 0;
int pdCount = 0;
ArrayList<RaxenPlayer> raxenPlayers = new ArrayList<>();
double damageSum = 0;
RaxenPlayer rx = null;
for (Entry<UUID, Long> entry : damageDealt.entrySet()) {
if ((rx = main.getManager().getPlayerManager().getRaxenPlayer(entry.getKey()))
!= null) {
raxenPlayers.add(rx);
damageSum += entry.getValue();
totalLevel += rx.getLevel();
pdCount++;
}
}
if (pdCount < 1) {
totalLevel = 1;
pdCount = 1;
}
double avgLv = totalLevel / (double) pdCount;
for (RaxenPlayer tx : raxenPlayers) {
if (damageDealt.containsKey(tx.getPlayer().getUniqueId())) {
tx.incrementMobCounter(mobType.identifier);
double precentage =
damageDealt.get(tx.getPlayer().getUniqueId()) / (double) damageSum;
if (precentage >= 0.1) {
tx.addMobKills();
}
long amt = (long) Math.ceil(mobType.xp * precentage);
if (!(mobType.level >= 80 && tx.getLevel() >= 80) && Math.abs(
tx.getLevel() - mobType.level) >= 10) {
double penalty = 0.7;
penalty -= (Math.abs(tx.getLevel() - mobType.level) - 10) * 0.06;
if (penalty < 0.1) {
penalty = 0.1;
}
tx.gainXp((long) Math.ceil(amt * penalty), true);
} else {
tx.gainXp(amt);
}
}
}
long mostDealt = 0;
UUID priority = null;
RaxenPlayer topDamage = null;
for (Entry<UUID, Long> entry : damageDealt.entrySet()) {
Player p = Bukkit.getPlayer(entry.getKey());
if (p == null) {
continue;
}
if (me.unurled.raxen.utils.Math.flatDistance(p.getLocation(), deathLoc) < 50) {
if (entry.getValue() >= mostDealt) {
if (entry.getValue() == mostDealt && Math.random() > 0.5) {
continue;
}
if (main.getManager().getPlayerManager().getRaxenPlayer(entry.getKey())
== null) {
continue;
}
mostDealt = entry.getValue();
priority = entry.getKey();
topDamage = main.getManager().getPlayerManager().getRaxenPlayer(priority);
}
}
}
EntityManager manager = main.getManager().getEntityManager();
if (drop || manager.getHealth().get(entity) < manager.getMaxMana().get(entity)) {
// TODO: mobdrop
}
// TODO: respawn
}
public void despawn() {
if (despawned) {
return;
}
// TODO: respawn
despawned = true;
dead = true;
EntityManager manager = main.getManager().getEntityManager();
if (entity == null) {
manager.spawnedMob.remove(entity.getUniqueId());
manager.spawnedMobsOnlyMain.remove(entity.getUniqueId());
entity.remove();
}
entity = null;
if (mount != null) {
manager.spawnedMob.remove(mount.getUniqueId());
manager.spawnedMobsOnlyMain.remove(mount.getUniqueId());
mount.remove();
}
mount = null;
// TODO: ai
if (damageDealt != null) {
damageDealt = null;
}
attributes = null;
lastAttackedByTimes = null;
}
public boolean attack(RaxenPlayer rx) {
return attack(rx, 0.5, -1, false);
}
public boolean attack(RaxenPlayer pd, int rpgDamage) {
return attack(pd, 0.5, rpgDamage, false);
}
public boolean attack(RaxenPlayer pd, int rpgDamage, boolean projectile) {
return attack(pd, 0.5, rpgDamage, projectile);
}
public int getDamage() {
return main.getManager().getEntityManager().getStrength()
.get(entity); // TODO: get damage properly
}
public boolean attack(RaxenPlayer pd, double knockback, int rpgDamage, boolean projectile) {
if (System.currentTimeMillis() < invuln) {
return false;
}
boolean success = false;
success = pd.damage(rpgDamage > -1 ? rpgDamage : getDamage(), entity,
DamageType.NORMAL);
if (success && !projectile) {
pd.knockback(entity, knockback);
}
return success;
}
public void knockback(LivingEntity attacker, double knockBackMultiplier) {
return;
}
public boolean damage(int damageAmount, org.bukkit.entity.Entity damager,
DamageType damageType) {
return damage(damageAmount, damager, damageType, false);
}
public boolean damage(int damageAmount, org.bukkit.entity.Entity damager, DamageType damageType,
boolean crit) {
if (System.currentTimeMillis() < invuln) {
return false;
}
if (dead) {
return false;
}
if (damager != null && damager instanceof Player player) {
if (!player.isOnline()
|| main.getManager().getPlayerManager().getRaxenPlayer(player) == null) {
return false;
}
}
Health health = main.getManager().getEntityManager().getHealth();
if (damageAmount > health.get(entity)) {
damageAmount = health.get(entity);
}
if (damager != null && damager instanceof Player player) {
if (damageDealt.containsKey(damager.getUniqueId())) {
damageDealt.put(damager.getUniqueId(),
damageDealt.get(damager.getUniqueId()) + damageAmount);
} else {
damageDealt.put(damager.getUniqueId(), (long) damageAmount);
}
// TODO: AI stuff
}
if (damager != null) {
lastAttackedByTimes.put(damager.getUniqueId(), System.currentTimeMillis());
}
if (damageAmount < 1) {
damageAmount = 1;
}
health.set(entity,
health.get(entity) - damageAmount);
if (health.get(entity) <= 0) {
health.set(entity, 0);
}
if (damager != null && damager instanceof Player player) {
RaxenPlayer rx = main.getManager().getPlayerManager().getRaxenPlayer(player);
player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_HURT, 0.65f, 0.75f);
}
if (health.get(entity) < 1) {
die();
} else {
entity.playEffect(EntityEffect.HURT);
if (mount != null) {
mount.playEffect(EntityEffect.HURT);
}
displayCurrentHP();
}
lastDamaged = System.currentTimeMillis();
return true;
}
public void displayCurrentHP() {
entity.customName(getHPDisplay());
Bukkit.getScheduler().scheduleSyncDelayedTask(main, lastScheduledRevertHP = new Runnable() {
public void run() {
if (!dead && entity != null && entity.isValid() && !entity.isDead()) {
if (lastScheduledRevertHP == this) {
entity.customName(Utils.colorComp(fullName));
}
}
}
}, 60L);
}
public Component getHPDisplay() {
EntityManager manager = main.getManager().getEntityManager();
int health = manager.getHealth().get(entity);
int maxHealth = manager.getMaxHealth().get(entity);
double percent = ((double) health) / ((double) maxHealth);
int green = (int) Math.floor(percent / 0.05);
if (green > 20) {
green = 20;
} else if (green < 1) {
green = 1;
}
StringBuilder sb = new StringBuilder();
sb.append("<gray>");
sb.append('[');
int firstHalf = green - 10;
if (firstHalf < 0) {
firstHalf = 0;
}
sb.append("<dark_red>");
for (int i = 0; i < 10 - firstHalf; i++) {
sb.append('|');
}
sb.append("<green>");
for (int i = 0; i < firstHalf; i++) {
sb.append('|');
}
sb.append("<gold>"); // TODO: tier color
sb.append(' ');
sb.append(health);
sb.append(' ');
int secondHalf = green - firstHalf;
sb.append("<dark_red>");
for (int i = 0; i < 10 - secondHalf; i++) {
sb.append('|');
}
sb.append("<green>");
for (int i = 0; i < secondHalf; i++) {
sb.append('|');
}
sb.append("<gray>");
sb.append(']');
return Utils.colorComp(sb.toString());
}
}

35
src/main/java/me/unurled/raxen/components/entity/other/MobType.java Normal file
View file

@ -0,0 +1,35 @@
package me.unurled.raxen.components.entity.other;
import java.util.ArrayList;
import net.minecraft.world.entity.Entity;
import org.bukkit.inventory.ItemStack;
public class MobType {
public String identifier;
public String name;
public Class<? extends Entity> entityClass;
public int level;
public ArrayList<String> prefixes;
public ArrayList<String> suffix;
public long xp;
public ArrayList<ItemStack> equips;
// TODO: public ArrayList<MobAttributes> attributes;
public boolean hasSkull = false;
public ItemStack offHand;
public int getTier() {
if (level >= 80) {
return 5;
} else if (level >= 60) {
return 4;
} else if (level >= 40) {
return 3;
} else if (level >= 20) {
return 2;
} else {
return 1;
}
}
}

263
src/main/java/me/unurled/raxen/components/entity/other/RaxenEntity.java
View file

@ -1,70 +1,245 @@
package me.unurled.raxen.components.entity.other;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.UUID;
import lombok.Getter;
import lombok.Setter;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.DamageType;
import me.unurled.raxen.components.entity.player.RaxenPlayer;
import me.unurled.raxen.utils.Tags;
import net.kyori.adventure.text.Component;
import org.bukkit.Location;
import org.bukkit.NamespacedKey;
import org.bukkit.Sound;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.persistence.PersistentDataType;
public abstract class RaxenEntity {
private final Raxen main;
private final Raxen main;
@Getter
private final String name;
@Getter
private final String name;
@Getter
private Integer level;
@Getter
private final String ID;
@Getter
@Setter
private Double health;
public Component fullName;
@Getter
@Setter
private Double strength;
@Getter
private Integer level;
@Getter
@Setter
Boolean isAlive = false;
@Getter
@Setter
private Double health;
public RaxenEntity(
Raxen main,
String name,
Integer level,
Double health,
Double strength
) {
this.main = main;
this.name = name;
this.level = level;
this.health = health;
this.strength = strength;
}
@Getter
@Setter
private Double strength;
public Entity createEntity(EntityType types, String name, Location location) {
Entity e = location.getWorld().spawnEntity(location, types);
e.setCustomNameVisible(true);
e.customName(Component.text(name));
@Getter
@Setter
Boolean isAlive = false;
return e;
}
boolean despawned = false;
public void register(Entity e) {
PersistentDataContainer data = e.getPersistentDataContainer();
data.set(new NamespacedKey(main, "NAME"), PersistentDataType.STRING, name);
}
me.unurled.raxen.components.entity.other.custom.Entity entity;
public HashMap<UUID, Long> lastAttackedByTimes;
public java.util.HashMap<UUID, Long> damageDealt;
public Double getMaxHealth(Entity e) {
PersistentDataContainer data = e.getPersistentDataContainer();
EntityNamespacedKey key = new EntityNamespacedKey(main);
return data.get(key.maxHealth, PersistentDataType.DOUBLE);
}
public RaxenEntity(
Raxen main,
String name,
String id,
Integer level,
Double health,
Double strength
) {
this.main = main;
this.name = name;
ID = id;
this.level = level;
this.health = health;
this.strength = strength;
}
public abstract Entity createEntity(Location location);
/*public Entity createEntity(
me.unurled.raxen.components.entity.other.custom.Entity ent,
String name,
Location location
) {
me.unurled.raxen.components.entity.other.custom.Entity e = (me.unurled.raxen.components.entity.other.custom.Entity) location.getWorld()
// .spawnEntity(location, ent);
e.setCustomNameVisible(true);
e.customName(Component.text(name));
entity = e;
return e;
}*/
public void register(Entity e) {
PersistentDataContainer data = e.getPersistentDataContainer();
data.set(
new NamespacedKey(main, "NAME"),
PersistentDataType.STRING,
name
);
}
public Double getMaxHealth(Entity e) {
PersistentDataContainer data = e.getPersistentDataContainer();
EntityNamespacedKey key = new EntityNamespacedKey(main);
return data.get(key.maxHealth, PersistentDataType.DOUBLE);
}
public abstract Entity createEntity(Location location);
public void die() {
die(true);
}
public void die(boolean drop) {
if (!isAlive) {
return;
}
isAlive = false;
// set mob ai false
Location deathLoc = entity.getLocation();
entity.customName(fullName);
Tags.makeFloatingText("<gold>+ EXP", deathLoc, 1.3, 1.0, 1.5, 1);
// TODO: damge entity method damage
// TODO: desawn
// TODO: xp
// xp
int totalLevel = 0;
int pdCount = 0;
ArrayList<RaxenPlayer> players = new ArrayList<>();
double damageSum = 0;
RaxenPlayer player = null;
for (Entry<UUID, Long> entry : damageDealt.entrySet()) {
if ((player = main.getManager().getPlayerManager().getRaxenPlayer(entry.getKey()))
!= null) {
damageSum += entry.getValue();
totalLevel += player.getLevel();
pdCount++;
players.add(main.getManager().getPlayerManager().getRaxenPlayer(entry.getKey()));
}
}
if (pdCount < 1) {
totalLevel = 1;
pdCount = 1;
}
double avgLv = totalLevel / (double) pdCount;
for (RaxenPlayer pd : players) {
if (damageDealt.containsKey(pd.getPlayer().getUniqueId())) {
pd.incrementMobCounter(ID);
double percentage =
damageDealt.get(pd.getPlayer().getUniqueId()) / (double) damageSum;
if (percentage >= 0.10) {
pd.addMobKills();
// IDEA: is boss add to counter
}
long amt = (long) Math.ceil(entity.getXp() * percentage);
if (!(level >= 80 && pd.getLevel() >= 80)
&& Math.abs(pd.getLevel() - level) >= 10) {
double penalty = 0.70;
penalty -= (Math.abs(pd.getLevel() - level) - 10) * 0.06;
if (penalty < 0.10) {
penalty = 0.10;
}
pd.gainXp((long) Math.ceil(amt * penalty), true);
} else {
pd.gainXp(amt);
}
}
}
}
public void despawn() {
if (despawned) {
return;
}
despawned = true;
if (entity != null) {
entity.remove();
}
entity = null;
// TODO: bosses, respawn etc
}
public boolean attack(RaxenPlayer pd) {
return attack(pd, 0.5, -1, false);
}
public boolean attack(RaxenPlayer pd, int rpgDamage) {
return attack(pd, 0.5, rpgDamage, false);
}
public boolean attack(RaxenPlayer pd, int rpgDamage, boolean projectile) {
return attack(pd, 0.5, rpgDamage, projectile);
}
public boolean attack(RaxenPlayer pd, double knockback, int rDamage, boolean projectile) {
boolean sucess = false;
sucess = pd.damage(rDamage > -1 ? rDamage : (int) entity.getDamage(), entity,
DamageType.NORMAL);
if (sucess && !projectile) {
// pd.knockback(entity, knockback);
// TODO: knockback
}
return sucess;
}
public boolean damage(int damageAmount, Entity damager, DamageType damageType) {
return damage(damageAmount, damager, damageType, false);
}
public boolean damage(int damage, Entity damager, DamageType damageType, boolean crit) {
if (!isAlive) {
return false;
}
if (damager != null && damager instanceof Player player) {
if (!player.isOnline()
|| main.getManager().getPlayerManager().getRaxenPlayer(player) == null) {
return false;
}
}
if (damage > entity.getHealth()) {
damage = entity.getHealth().intValue();
}
if (damager != null && damager instanceof Player player) {
RaxenPlayer pd = main.getManager().getPlayerManager().getRaxenPlayer(player);
if (damageDealt.containsKey(damager.getUniqueId())) {
damageDealt.put(damager.getUniqueId(),
damageDealt.get(damager.getUniqueId()) + damage);
} else {
damageDealt.put(damager.getUniqueId(), (long) damage);
}
}
if (damager != null) {
lastAttackedByTimes.put(damager.getUniqueId(), System.currentTimeMillis());
}
if (damage < 1) {
damage = 1;
}
health -= damage;
if (health < 0) {
health = 0.0;
}
if (damager != null && damager instanceof Player player) {
player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_HURT, 0.65f, 0.75f);
}
if (health <= 0) {
die();
} else {
}
return true;
}
}

167
src/main/java/me/unurled/raxen/components/entity/other/custom/Entity.java
View file

@ -7,97 +7,108 @@ import lombok.Getter;
import lombok.Setter;
import me.unurled.raxen.Raxen;
public class Entity {
public abstract class Entity implements org.bukkit.entity.Entity {
private java.util.UUID uuid;
private java.util.UUID uuid;
private final String name;
private final String name;
@Getter
private Integer level;
@Getter
private Integer level;
@Setter
private Double health;
@Setter
private Double health;
@Getter
@Setter
private Double strength;
@Getter
@Setter
private Double strength;
@Getter
@Setter
private Double defense;
@Getter
@Setter
private Double defense;
@Getter
@Setter
private Double speed;
@Getter
@Setter
private Double speed;
@Getter
@Setter
private Double maxHealth;
@Getter
@Setter
private Double maxHealth;
@Getter
@Setter
private boolean isHostile;
@Getter
@Setter
private boolean isHostile;
public Entity(
String name,
Integer level,
Double maxHealth,
Double strength,
Double defense,
Double speed,
boolean isHostile
) {
this.name = name;
this.level = level;
this.health = maxHealth;
this.strength = strength;
this.defense = defense;
this.speed = speed;
this.maxHealth = maxHealth;
this.isHostile = isHostile;
this.uuid = UUID.randomUUID();
}
@Getter
@Setter
private double xp;
public void register(Raxen main) {
main.getManager().getEntityManager().entities.put(name, this);
}
public String getName() {
return "<white>" + name;
}
public String getFullName(Entity e) {
if (isHostile) {
return colorString(
getColorLevel() +
"<white>⚔️" +
getName() +
"<red>" +
health +
"<white>/<white/>" +
maxHealth
);
} else {
return colorString(
getColorLevel() +
"<white>❤️" +
getName() +
"<red>" +
health +
"<white>/<white/>" +
maxHealth
);
public Entity(
String name,
Integer level,
Double maxHealth,
Double strength,
Double defense,
Double speed,
boolean isHostile,
double xp
) {
this.name = name;
this.level = level;
this.health = maxHealth;
this.strength = strength;
this.defense = defense;
this.speed = speed;
this.maxHealth = maxHealth;
this.isHostile = isHostile;
this.uuid = UUID.randomUUID();
this.xp = xp;
}
}
public String getColorLevel() {
return level.toString();
}
public void register(Raxen main) {
main.getManager().getEntityManager().entities.put(name, this);
}
public Double getHealth() {
Double health = 0.0;
public String getName() {
return "<white>" + name;
}
return health;
}
public String getFullName(Entity e) {
if (isHostile) {
return colorString(
getColorLevel() +
"<white>⚔️" +
getName() +
"<red>" +
health +
"<white>/<white/>" +
maxHealth
);
} else {
return colorString(
getColorLevel() +
"<white>❤️" +
getName() +
"<red>" +
health +
"<white>/<white/>" +
maxHealth
);
}
}
public String getColorLevel() {
return level.toString();
}
public Double getHealth() {
Double health = 0.0;
return health;
}
public double getDamage() {
// TODO: calculate properly the damage
return strength;
}
}

683
src/main/java/me/unurled/raxen/components/entity/other/custom/Humanoid.java
View file

@ -1,25 +1,674 @@
package me.unurled.raxen.components.entity.other.custom;
import io.papermc.paper.entity.TeleportFlag;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import net.kyori.adventure.text.Component;
import org.bukkit.EntityEffect;
import org.bukkit.Location;
import org.bukkit.Server;
import org.bukkit.Sound;
import org.bukkit.World;
import org.bukkit.block.BlockFace;
import org.bukkit.block.PistonMoveReaction;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.Pose;
import org.bukkit.entity.SpawnCategory;
import org.bukkit.event.entity.CreatureSpawnEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.metadata.MetadataValue;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionAttachment;
import org.bukkit.permissions.PermissionAttachmentInfo;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.plugin.Plugin;
import org.bukkit.util.BoundingBox;
import org.bukkit.util.Vector;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class Humanoid extends Entity {
private String skin; // used to get the path to the skin
private UUID skinUuid; // used to get the player skin (if i do it this way...
private String skin; // used to get the path to the skin
private UUID skinUuid; // used to get the player skin (if i do it this way...
public Humanoid(
String name,
Integer level,
Double maxHealth,
Double strength,
Double defense,
Double speed,
boolean isHostile,
String skin,
UUID skinUuid
) {
super(name, level, maxHealth, strength, defense, speed, isHostile);
this.skin = skin;
this.skinUuid = skinUuid;
}
public Humanoid(String name, Integer level, Double maxHealth, Double strength, Double defense,
Double speed, boolean isHostile, double xp) {
super(name, level, maxHealth, strength, defense, speed, isHostile, xp);
}
@Override
public @NotNull Location getLocation() {
return null;
}
@Override
public @Nullable Location getLocation(@Nullable Location loc) {
return null;
}
@Override
public void setVelocity(@NotNull Vector velocity) {
}
@Override
public @NotNull Vector getVelocity() {
return null;
}
@Override
public double getHeight() {
return 0;
}
@Override
public double getWidth() {
return 0;
}
@Override
public @NotNull BoundingBox getBoundingBox() {
return null;
}
@Override
public boolean isOnGround() {
return false;
}
@Override
public boolean isInWater() {
return false;
}
@Override
public @NotNull World getWorld() {
return null;
}
@Override
public void setRotation(float yaw, float pitch) {
}
@Override
public boolean teleport(@NotNull Location location,
@NotNull PlayerTeleportEvent.TeleportCause cause,
@NotNull TeleportFlag @NotNull ... teleportFlags) {
return false;
}
@Override
public boolean teleport(@NotNull Location location) {
return false;
}
@Override
public boolean teleport(@NotNull Location location,
@NotNull PlayerTeleportEvent.TeleportCause cause) {
return false;
}
@Override
public boolean teleport(org.bukkit.entity.@NotNull Entity destination) {
return false;
}
@Override
public boolean teleport(org.bukkit.entity.@NotNull Entity destination,
@NotNull PlayerTeleportEvent.TeleportCause cause) {
return false;
}
@Override
public @NotNull List<org.bukkit.entity.Entity> getNearbyEntities(double x, double y, double z) {
return null;
}
@Override
public int getEntityId() {
return 0;
}
@Override
public int getFireTicks() {
return 0;
}
@Override
public int getMaxFireTicks() {
return 0;
}
@Override
public void setFireTicks(int ticks) {
}
@Override
public void setVisualFire(boolean fire) {
}
@Override
public boolean isVisualFire() {
return false;
}
@Override
public int getFreezeTicks() {
return 0;
}
@Override
public int getMaxFreezeTicks() {
return 0;
}
@Override
public void setFreezeTicks(int ticks) {
}
@Override
public boolean isFrozen() {
return false;
}
@Override
public boolean isFreezeTickingLocked() {
return false;
}
@Override
public void lockFreezeTicks(boolean locked) {
}
@Override
public void remove() {
}
@Override
public boolean isDead() {
return false;
}
@Override
public boolean isValid() {
return false;
}
@Override
public void sendMessage(@NotNull String message) {
}
@Override
public void sendMessage(@NotNull String... messages) {
}
@Override
public void sendMessage(@Nullable UUID sender, @NotNull String message) {
}
@Override
public void sendMessage(@Nullable UUID sender, @NotNull String... messages) {
}
@Override
public @NotNull Server getServer() {
return null;
}
@Override
public boolean isPersistent() {
return false;
}
@Override
public void setPersistent(boolean persistent) {
}
@Override
public org.bukkit.entity.@Nullable Entity getPassenger() {
return null;
}
@Override
public boolean setPassenger(org.bukkit.entity.@NotNull Entity passenger) {
return false;
}
@Override
public @NotNull List<org.bukkit.entity.Entity> getPassengers() {
return null;
}
@Override
public boolean addPassenger(org.bukkit.entity.@NotNull Entity passenger) {
return false;
}
@Override
public boolean removePassenger(org.bukkit.entity.@NotNull Entity passenger) {
return false;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean eject() {
return false;
}
@Override
public float getFallDistance() {
return 0;
}
@Override
public void setFallDistance(float distance) {
}
@Override
public void setLastDamageCause(@Nullable EntityDamageEvent event) {
}
@Override
public @Nullable EntityDamageEvent getLastDamageCause() {
return null;
}
@Override
public @NotNull UUID getUniqueId() {
return null;
}
@Override
public int getTicksLived() {
return 0;
}
@Override
public void setTicksLived(int value) {
}
@Override
public void playEffect(@NotNull EntityEffect type) {
}
@Override
public @NotNull EntityType getType() {
return null;
}
@Override
public @NotNull Sound getSwimSound() {
return null;
}
@Override
public @NotNull Sound getSwimSplashSound() {
return null;
}
@Override
public @NotNull Sound getSwimHighSpeedSplashSound() {
return null;
}
@Override
public boolean isInsideVehicle() {
return false;
}
@Override
public boolean leaveVehicle() {
return false;
}
@Override
public org.bukkit.entity.@Nullable Entity getVehicle() {
return null;
}
@Override
public void setCustomNameVisible(boolean flag) {
}
@Override
public boolean isCustomNameVisible() {
return false;
}
@Override
public void setVisibleByDefault(boolean visible) {
}
@Override
public boolean isVisibleByDefault() {
return false;
}
@Override
public void setGlowing(boolean flag) {
}
@Override
public boolean isGlowing() {
return false;
}
@Override
public void setInvulnerable(boolean flag) {
}
@Override
public boolean isInvulnerable() {
return false;
}
@Override
public boolean isSilent() {
return false;
}
@Override
public void setSilent(boolean flag) {
}
@Override
public boolean hasGravity() {
return false;
}
@Override
public void setGravity(boolean gravity) {
}
@Override
public int getPortalCooldown() {
return 0;
}
@Override
public void setPortalCooldown(int cooldown) {
}
@Override
public @NotNull Set<String> getScoreboardTags() {
return null;
}
@Override
public boolean addScoreboardTag(@NotNull String tag) {
return false;
}
@Override
public boolean removeScoreboardTag(@NotNull String tag) {
return false;
}
@Override
public @NotNull PistonMoveReaction getPistonMoveReaction() {
return null;
}
@Override
public @NotNull BlockFace getFacing() {
return null;
}
@Override
public @NotNull Pose getPose() {
return null;
}
@Override
public boolean isSneaking() {
return false;
}
@Override
public void setSneaking(boolean sneak) {
}
@Override
public @NotNull SpawnCategory getSpawnCategory() {
return null;
}
@Override
public @NotNull Spigot spigot() {
return null;
}
@Override
public @NotNull Component name() {
return null;
}
@Override
public @NotNull Component teamDisplayName() {
return null;
}
@Override
public @Nullable Location getOrigin() {
return null;
}
@Override
public boolean fromMobSpawner() {
return false;
}
@Override
public @NotNull CreatureSpawnEvent.SpawnReason getEntitySpawnReason() {
return null;
}
@Override
public boolean isUnderWater() {
return false;
}
@Override
public boolean isInRain() {
return false;
}
@Override
public boolean isInBubbleColumn() {
return false;
}
@Override
public boolean isInWaterOrRain() {
return false;
}
@Override
public boolean isInWaterOrBubbleColumn() {
return false;
}
@Override
public boolean isInWaterOrRainOrBubbleColumn() {
return false;
}
@Override
public boolean isInLava() {
return false;
}
@Override
public boolean isTicking() {
return false;
}
@Override
public @NotNull Set<Player> getTrackedPlayers() {
return null;
}
@Override
public boolean spawnAt(@NotNull Location location,
@NotNull CreatureSpawnEvent.SpawnReason reason) {
return false;
}
@Override
public boolean isInPowderedSnow() {
return false;
}
@Override
public boolean collidesAt(@NotNull Location location) {
return false;
}
@Override
public boolean wouldCollideUsing(@NotNull BoundingBox boundingBox) {
return false;
}
@Override
public @Nullable Component customName() {
return null;
}
@Override
public void customName(@Nullable Component customName) {
}
@Override
public @Nullable String getCustomName() {
return null;
}
@Override
public void setCustomName(@Nullable String name) {
}
@Override
public void setMetadata(@NotNull String metadataKey, @NotNull MetadataValue newMetadataValue) {
}
@Override
public @NotNull List<MetadataValue> getMetadata(@NotNull String metadataKey) {
return null;
}
@Override
public boolean hasMetadata(@NotNull String metadataKey) {
return false;
}
@Override
public void removeMetadata(@NotNull String metadataKey, @NotNull Plugin owningPlugin) {
}
@Override
public boolean isPermissionSet(@NotNull String name) {
return false;
}
@Override
public boolean isPermissionSet(@NotNull Permission perm) {
return false;
}
@Override
public boolean hasPermission(@NotNull String name) {
return false;
}
@Override
public boolean hasPermission(@NotNull Permission perm) {
return false;
}
@Override
public @NotNull PermissionAttachment addAttachment(@NotNull Plugin plugin, @NotNull String name,
boolean value) {
return null;
}
@Override
public @NotNull PermissionAttachment addAttachment(@NotNull Plugin plugin) {
return null;
}
@Override
public @Nullable PermissionAttachment addAttachment(@NotNull Plugin plugin,
@NotNull String name, boolean value, int ticks) {
return null;
}
@Override
public @Nullable PermissionAttachment addAttachment(@NotNull Plugin plugin, int ticks) {
return null;
}
@Override
public void removeAttachment(@NotNull PermissionAttachment attachment) {
}
@Override
public void recalculatePermissions() {
}
@Override
public @NotNull Set<PermissionAttachmentInfo> getEffectivePermissions() {
return null;
}
@Override
public boolean isOp() {
return false;
}
@Override
public void setOp(boolean value) {
}
@Override
public @NotNull PersistentDataContainer getPersistentDataContainer() {
return null;
}
}

53
src/main/java/me/unurled/raxen/components/entity/other/custom/dungeon/forest/Elf.java
View file

@ -5,36 +5,37 @@ import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.other.RaxenEntity;
import org.bukkit.Location;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
public class Elf extends RaxenEntity {
@Getter
private final String name;
@Getter
private final String name;
private final String id = "elf";
public Elf(
Raxen main,
String name,
Integer level,
Double health,
Double strength
) {
super(main, name, level, health, strength);
this.name = name;
}
public Elf(
Raxen main,
String name,
Integer level,
Double health,
Double strength
) {
super(main, name, "elf", level, health, strength);
this.name = name;
}
@Override
public Entity createEntity(Location location) {
return super.createEntity(EntityType.PLAYER, name, location);
}
/**
* Elf Default values
*
* @param main the main instance
* @param name
*/
public Elf(Raxen main, String name) {
super(main, "Elf", "elf", 10, 120.0, 25.0);
this.name = name;
}
/**
* Elf Default values
* @param main the main instance
* @param name
*/
public Elf(Raxen main, String name) {
super(main, "Elf", 10, 120.0, 25.0);
this.name = name;
}
@Override
public Entity createEntity(Location location) {
return null;
}
}

41
src/main/java/me/unurled/raxen/components/entity/other/custom/dungeon/forest/Wolf.java
View file

@ -5,31 +5,30 @@ import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.other.RaxenEntity;
import org.bukkit.Location;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
public class Wolf extends RaxenEntity {
@Getter
private final String name;
@Getter
private final String name;
public Wolf(
Raxen main,
String name,
Integer level,
Double health,
Double strength
) {
super(main, name, level, health, strength);
this.name = name;
}
public Wolf(
Raxen main,
String name,
Integer level,
Double health,
Double strength
) {
super(main, name, "elf", level, health, strength);
this.name = name;
}
public Wolf(Raxen main) {
super(main, "Wolf", 5, 100.0, 20.0);
this.name = "Wolf";
}
public Wolf(Raxen main) {
super(main, "Wolf", "elf", 5, 100.0, 20.0);
this.name = "Wolf";
}
@Override
public Entity createEntity(Location location) {
return super.createEntity(EntityType.WOLF, name, location);
}
@Override
public Entity createEntity(Location location) {
return null;
}
}

716
src/main/java/me/unurled/raxen/components/entity/other/custom/hostile/low/Goblin.java
View file

@ -1,39 +1,705 @@
package me.unurled.raxen.components.entity.other.custom.hostile.low;
import io.papermc.paper.entity.TeleportFlag;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.other.RaxenEntity;
import me.unurled.raxen.components.entity.other.custom.Entity;
import net.kyori.adventure.text.Component;
import org.bukkit.EntityEffect;
import org.bukkit.Location;
import org.bukkit.Server;
import org.bukkit.Sound;
import org.bukkit.World;
import org.bukkit.block.BlockFace;
import org.bukkit.block.PistonMoveReaction;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.Pose;
import org.bukkit.entity.SpawnCategory;
import org.bukkit.event.entity.CreatureSpawnEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.metadata.MetadataValue;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionAttachment;
import org.bukkit.permissions.PermissionAttachmentInfo;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.plugin.Plugin;
import org.bukkit.util.BoundingBox;
import org.bukkit.util.Vector;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class Goblin extends Entity {
RaxenEntity goblin;
RaxenEntity goblin;
public Goblin(Raxen main) {
super("Goblin", 1, 100.0, 10.0, 0.0, 50.0, true);
this.goblin =
new RaxenEntity(main, "Goblin", 1, 100.0, 10.0) {
@Override
public org.bukkit.entity.Entity createEntity(Location location) {
return super.createEntity(EntityType.PLAYER, "Goblin", location);
}
};
register(main);
}
public Goblin(Raxen main) {
super("Goblin", 1, 100.0, 10.0, 0.0, 50.0, true, 100);
this.goblin =
new RaxenEntity(main, "Goblin", "goblin", 1, 100.0, 10.0) {
@Override
public org.bukkit.entity.Entity createEntity(
Location location
) {
return null;
/* return super.createEntity(
EntityType.PLAYER,
"Goblin",
location
);*/
}
};
register(main);
}
public String getName() {
return "<white>" + goblin.getName();
}
public String getName() {
return "<white>" + goblin.getName();
}
public String getFullName(Entity e) {
return (
"<white>⚔️" +
getName() +
"<red>" +
getHealth() +
"<white>/<white/>" +
getMaxHealth()
);
}
public String getFullName(Entity e) {
return (
"<white>⚔️" +
getName() +
"<red>" +
getHealth() +
"<white>/<white/>" +
getMaxHealth()
);
}
@Override
public @NotNull Location getLocation() {
return null;
}
@Override
public @Nullable Location getLocation(@Nullable Location loc) {
return null;
}
@Override
public void setVelocity(@NotNull Vector velocity) {
}
@Override
public @NotNull Vector getVelocity() {
return null;
}
@Override
public double getHeight() {
return 0;
}
@Override
public double getWidth() {
return 0;
}
@Override
public @NotNull BoundingBox getBoundingBox() {
return null;
}
@Override
public boolean isOnGround() {
return false;
}
@Override
public boolean isInWater() {
return false;
}
@Override
public @NotNull World getWorld() {
return null;
}
@Override
public void setRotation(float yaw, float pitch) {
}
@Override
public boolean teleport(@NotNull Location location,
@NotNull PlayerTeleportEvent.TeleportCause cause,
@NotNull TeleportFlag @NotNull ... teleportFlags) {
return false;
}
@Override
public boolean teleport(@NotNull Location location) {
return false;
}
@Override
public boolean teleport(@NotNull Location location,
@NotNull PlayerTeleportEvent.TeleportCause cause) {
return false;
}
@Override
public boolean teleport(org.bukkit.entity.@NotNull Entity destination) {
return false;
}
@Override
public boolean teleport(org.bukkit.entity.@NotNull Entity destination,
@NotNull PlayerTeleportEvent.TeleportCause cause) {
return false;
}
@Override
public @NotNull List<org.bukkit.entity.Entity> getNearbyEntities(double x, double y, double z) {
return null;
}
@Override
public int getEntityId() {
return 0;
}
@Override
public int getFireTicks() {
return 0;
}
@Override
public int getMaxFireTicks() {
return 0;
}
@Override
public void setFireTicks(int ticks) {
}
@Override
public void setVisualFire(boolean fire) {
}
@Override
public boolean isVisualFire() {
return false;
}
@Override
public int getFreezeTicks() {
return 0;
}
@Override
public int getMaxFreezeTicks() {
return 0;
}
@Override
public void setFreezeTicks(int ticks) {
}
@Override
public boolean isFrozen() {
return false;
}
@Override
public boolean isFreezeTickingLocked() {
return false;
}
@Override
public void lockFreezeTicks(boolean locked) {
}
@Override
public void remove() {
}
@Override
public boolean isDead() {
return false;
}
@Override
public boolean isValid() {
return false;
}
@Override
public void sendMessage(@NotNull String message) {
}
@Override
public void sendMessage(@NotNull String... messages) {
}
@Override
public void sendMessage(@Nullable UUID sender, @NotNull String message) {
}
@Override
public void sendMessage(@Nullable UUID sender, @NotNull String... messages) {
}
@Override
public @NotNull Server getServer() {
return null;
}
@Override
public boolean isPersistent() {
return false;
}
@Override
public void setPersistent(boolean persistent) {
}
@Override
public org.bukkit.entity.@Nullable Entity getPassenger() {
return null;
}
@Override
public boolean setPassenger(org.bukkit.entity.@NotNull Entity passenger) {
return false;
}
@Override
public @NotNull List<org.bukkit.entity.Entity> getPassengers() {
return null;
}
@Override
public boolean addPassenger(org.bukkit.entity.@NotNull Entity passenger) {
return false;
}
@Override
public boolean removePassenger(org.bukkit.entity.@NotNull Entity passenger) {
return false;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean eject() {
return false;
}
@Override
public float getFallDistance() {
return 0;
}
@Override
public void setFallDistance(float distance) {
}
@Override
public void setLastDamageCause(@Nullable EntityDamageEvent event) {
}
@Override
public @Nullable EntityDamageEvent getLastDamageCause() {
return null;
}
@Override
public @NotNull UUID getUniqueId() {
return null;
}
@Override
public int getTicksLived() {
return 0;
}
@Override
public void setTicksLived(int value) {
}
@Override
public void playEffect(@NotNull EntityEffect type) {
}
@Override
public @NotNull EntityType getType() {
return null;
}
@Override
public @NotNull Sound getSwimSound() {
return null;
}
@Override
public @NotNull Sound getSwimSplashSound() {
return null;
}
@Override
public @NotNull Sound getSwimHighSpeedSplashSound() {
return null;
}
@Override
public boolean isInsideVehicle() {
return false;
}
@Override
public boolean leaveVehicle() {
return false;
}
@Override
public org.bukkit.entity.@Nullable Entity getVehicle() {
return null;
}
@Override
public void setCustomNameVisible(boolean flag) {
}
@Override
public boolean isCustomNameVisible() {
return false;
}
@Override
public void setVisibleByDefault(boolean visible) {
}
@Override
public boolean isVisibleByDefault() {
return false;
}
@Override
public void setGlowing(boolean flag) {
}
@Override
public boolean isGlowing() {
return false;
}
@Override
public void setInvulnerable(boolean flag) {
}
@Override
public boolean isInvulnerable() {
return false;
}
@Override
public boolean isSilent() {
return false;
}
@Override
public void setSilent(boolean flag) {
}
@Override
public boolean hasGravity() {
return false;
}
@Override
public void setGravity(boolean gravity) {
}
@Override
public int getPortalCooldown() {
return 0;
}
@Override
public void setPortalCooldown(int cooldown) {
}
@Override
public @NotNull Set<String> getScoreboardTags() {
return null;
}
@Override
public boolean addScoreboardTag(@NotNull String tag) {
return false;
}
@Override
public boolean removeScoreboardTag(@NotNull String tag) {
return false;
}
@Override
public @NotNull PistonMoveReaction getPistonMoveReaction() {
return null;
}
@Override
public @NotNull BlockFace getFacing() {
return null;
}
@Override
public @NotNull Pose getPose() {
return null;
}
@Override
public boolean isSneaking() {
return false;
}
@Override
public void setSneaking(boolean sneak) {
}
@Override
public @NotNull SpawnCategory getSpawnCategory() {
return null;
}
@Override
public @NotNull Spigot spigot() {
return null;
}
@Override
public @NotNull Component name() {
return null;
}
@Override
public @NotNull Component teamDisplayName() {
return null;
}
@Override
public @Nullable Location getOrigin() {
return null;
}
@Override
public boolean fromMobSpawner() {
return false;
}
@Override
public @NotNull CreatureSpawnEvent.SpawnReason getEntitySpawnReason() {
return null;
}
@Override
public boolean isUnderWater() {
return false;
}
@Override
public boolean isInRain() {
return false;
}
@Override
public boolean isInBubbleColumn() {
return false;
}
@Override
public boolean isInWaterOrRain() {
return false;
}
@Override
public boolean isInWaterOrBubbleColumn() {
return false;
}
@Override
public boolean isInWaterOrRainOrBubbleColumn() {
return false;
}
@Override
public boolean isInLava() {
return false;
}
@Override
public boolean isTicking() {
return false;
}
@Override
public @NotNull Set<Player> getTrackedPlayers() {
return null;
}
@Override
public boolean spawnAt(@NotNull Location location,
@NotNull CreatureSpawnEvent.SpawnReason reason) {
return false;
}
@Override
public boolean isInPowderedSnow() {
return false;
}
@Override
public boolean collidesAt(@NotNull Location location) {
return false;
}
@Override
public boolean wouldCollideUsing(@NotNull BoundingBox boundingBox) {
return false;
}
@Override
public @Nullable Component customName() {
return null;
}
@Override
public void customName(@Nullable Component customName) {
}
@Override
public @Nullable String getCustomName() {
return null;
}
@Override
public void setCustomName(@Nullable String name) {
}
@Override
public void setMetadata(@NotNull String metadataKey, @NotNull MetadataValue newMetadataValue) {
}
@Override
public @NotNull List<MetadataValue> getMetadata(@NotNull String metadataKey) {
return null;
}
@Override
public boolean hasMetadata(@NotNull String metadataKey) {
return false;
}
@Override
public void removeMetadata(@NotNull String metadataKey, @NotNull Plugin owningPlugin) {
}
@Override
public boolean isPermissionSet(@NotNull String name) {
return false;
}
@Override
public boolean isPermissionSet(@NotNull Permission perm) {
return false;
}
@Override
public boolean hasPermission(@NotNull String name) {
return false;
}
@Override
public boolean hasPermission(@NotNull Permission perm) {
return false;
}
@Override
public @NotNull PermissionAttachment addAttachment(@NotNull Plugin plugin, @NotNull String name,
boolean value) {
return null;
}
@Override
public @NotNull PermissionAttachment addAttachment(@NotNull Plugin plugin) {
return null;
}
@Override
public @Nullable PermissionAttachment addAttachment(@NotNull Plugin plugin,
@NotNull String name, boolean value, int ticks) {
return null;
}
@Override
public @Nullable PermissionAttachment addAttachment(@NotNull Plugin plugin, int ticks) {
return null;
}
@Override
public void removeAttachment(@NotNull PermissionAttachment attachment) {
}
@Override
public void recalculatePermissions() {
}
@Override
public @NotNull Set<PermissionAttachmentInfo> getEffectivePermissions() {
return null;
}
@Override
public boolean isOp() {
return false;
}
@Override
public void setOp(boolean value) {
}
@Override
public @NotNull PersistentDataContainer getPersistentDataContainer() {
return null;
}
}

20
src/main/java/me/unurled/raxen/components/entity/player/Inventories.java
View file

@ -4,17 +4,17 @@ import me.unurled.raxen.components.entity.player.storages.Inventory;
public class Inventories {
private Inventory inv;
private Inventory inv;
public Inventories(Inventory inv) {
this.inv = inv;
}
public Inventories(Inventory inv) {
this.inv = inv;
}
public Inventory getInv() {
return inv;
}
public Inventory getInv() {
return inv;
}
public void setInv(Inventory inv) {
this.inv = inv;
}
public void setInv(Inventory inv) {
this.inv = inv;
}
}

224
src/main/java/me/unurled/raxen/components/entity/player/PlayerStatistics.java Normal file
View file

@ -0,0 +1,224 @@
package me.unurled.raxen.components.entity.player;
public class PlayerStatistics {
public static long getEXPForNextLevel(int level) {
if (level < 1) {
level = 1;
}
long ret = 1;
if (level <= 200) {
ret = PlayerStatistics.EXP_REQUIREMENTS[level - 1][1];
} else {
ret = (int) (Math.pow(1.0548, level - 200) * EXP_REQUIREMENTS[EXP_REQUIREMENTS.length
- 1][1]);
}
if (ret < 0) {
ret = Long.MAX_VALUE;
}
return ret;
}
private static final int[][] EXP_REQUIREMENTS = {
{1, 15},
{2, 34},
{3, 57},
{4, 92},
{5, 135},
{6, 372},
{7, 560},
{8, 840},
{9, 1242},
{10, 1144},
{11, 1573},
{12, 2144},
{13, 2800},
{14, 3640},
{15, 4700},
{16, 5893},
{17, 7360},
{18, 9144},
{19, 11120},
{20, 13477},
{21, 16268},
{22, 19320},
{23, 22880},
{24, 27008},
{25, 31477},
{26, 36600},
{27, 42444},
{28, 48720},
{29, 55813},
{30, 63800},
{31, 86784},
{32, 98208},
{33, 110932},
{34, 124432},
{35, 139372},
{36, 155865},
{37, 173280},
{38, 192400},
{39, 213345},
{40, 235372},
{41, 259392},
{42, 285532},
{43, 312928},
{44, 342624},
{45, 374760},
{46, 408336},
{47, 445544},
{48, 483532},
{49, 524160},
{50, 567772},
{51, 598886},
{52, 631704},
{53, 666321},
{54, 702836},
{55, 741351},
{56, 781976},
{57, 824828},
{58, 870028},
{59, 917625},
{60, 967995},
{61, 1021041},
{62, 1076994},
{63, 1136013},
{64, 1198266},
{65, 1263930},
{66, 1333194},
{67, 1406252},
{68, 1483314},
{69, 1564600},
{70, 1650340},
{71, 1740778},
{72, 1836173},
{73, 1936794},
{74, 2042930},
{75, 2154882},
{76, 2272970},
{77, 2397528},
{78, 2528912},
{79, 2667496},
{80, 2813674},
{81, 2967863},
{82, 3130502},
{83, 3302053},
{84, 3483005},
{85, 3673873},
{86, 3875201},
{87, 4087562},
{88, 4311559},
{89, 4547832},
{90, 4797053},
{91, 5059931},
{92, 5337215},
{93, 5629694},
{94, 5938202},
{95, 6263614},
{96, 6606860},
{97, 6968915},
{98, 7350811},
{99, 7753635},
{100, 8178534},
{101, 8626718},
{102, 9099462},
{103, 9598112},
{104, 10124088},
{105, 10678888},
{106, 11264090},
{107, 11881362},
{108, 12532461},
{109, 13219239},
{110, 13943653},
{111, 14707765},
{112, 15513750},
{113, 16363902},
{114, 17260644},
{115, 18206527},
{116, 19204245},
{117, 20256637},
{118, 21366700},
{119, 22537594},
{120, 23772654},
{121, 25075395},
{122, 26449526},
{123, 27898960},
{124, 29427822},
{125, 31040466},
{126, 32741483},
{127, 34535716},
{128, 36428273},
{129, 38424542},
{130, 40530206},
{131, 42751262},
{132, 45094030},
{133, 47565183},
{134, 50171755},
{135, 52921167},
{136, 55821246},
{137, 58880250},
{138, 62106888},
{139, 65510344},
{140, 69100311},
{141, 72887008},
{142, 76881216},
{143, 81094306},
{144, 85594273},
{145, 90225770},
{146, 95170142},
{147, 100385466},
{148, 105886589},
{149, 111689174},
{150, 117809740},
{151, 124265714},
{152, 131075474},
{153, 138258410},
{154, 145834970},
{155, 153826726},
{156, 162256430},
{157, 171148082},
{158, 180526997},
{159, 190419876},
{160, 200854885},
{161, 211861732},
{162, 223471711},
{163, 223471711},
{164, 248635353},
{165, 262260570},
{166, 276632449},
{167, 291791906},
{168, 307782102},
{169, 324648562},
{170, 342439302},
{171, 361204976},
{172, 380999008},
{173, 401877754},
{174, 423900654},
{175, 447130410},
{176, 471633156},
{177, 497478653},
{178, 524740482},
{179, 553496261},
{180, 583827855},
{181, 615821622},
{182, 649568646},
{183, 685165008},
{184, 722712050},
{185, 762316670},
{186, 804091623},
{187, 848155844},
{188, 894634784},
{189, 943660770},
{190, 995373379},
{191, 1049919840},
{192, 1107455447},
{193, 1168144006},
{194, 1232158297},
{195, 1299680571},
{196, 1370903066},
{197, 1446028554},
{198, 1525246918},
{199, 1608855764},
{200, 1697021059},
};
}

121
src/main/java/me/unurled/raxen/components/entity/player/PlayerUtils.java
View file

@ -1,47 +1,98 @@
package me.unurled.raxen.components.entity.player;
import static me.unurled.raxen.utils.Utils.debug;
import static me.unurled.raxen.utils.Utils.*;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.manager.entity.PlayerManager;
import org.bukkit.Bukkit;
import org.bukkit.attribute.Attribute;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitTask;
public class PlayerUtils {
public static void updateSkills(Raxen main, Player player) {
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
defense = pm.getDefense().get(player);
maxMana = pm.getMaxMana().get(player);
itemDefense = pm.getItemDefense().get(player);
health = pm.getHealth().get(player);
itemHealth = pm.getItemHealth().get(player);
mana = pm.getMana().get(player);
speed = pm.getSpeed().get(player);
itemLuck = pm.getItemLuck().get(player);
strength = pm.getStrength().get(player);
luck = pm.getLuck().get(player);
maxHealth = pm.getMaxHealth().get(player);
itemStrength = pm.getItemStrength().get(player);
itemSpeed = pm.getItemSpeed().get(player);
itemMana = pm.getItemMana().get(player);
player
.getAttribute(Attribute.GENERIC_MAX_HEALTH)
.setBaseValue(20D + (health + itemHealth) / 100);
player.setWalkSpeed((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
player.setFlySpeed((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
debug(
"Player " + player.getName(),
"Speed " + (speed + itemSpeed),
"Health " + (health + itemHealth) + " Max Health " + maxHealth,
"Defense " + (defense + itemDefense),
"Strength " + (strength + itemStrength),
"Luck " + (luck + itemLuck),
"Mana " + (mana + itemMana) + " Max Mana " + maxMana
);
}
public static void updateSkills(Raxen main, Player player) {
PlayerManager pm = main.getManager().getPlayerManager();
int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
defense = pm.getDefense().get(player);
maxMana = pm.getMaxMana().get(player);
itemDefense = pm.getItemDefense().get(player);
health = pm.getHealth().get(player);
itemHealth = pm.getItemHealth().get(player);
mana = pm.getMana().get(player);
speed = pm.getSpeed().get(player);
itemLuck = pm.getItemLuck().get(player);
strength = pm.getStrength().get(player);
luck = pm.getLuck().get(player);
maxHealth = pm.getMaxHealth().get(player);
itemStrength = pm.getItemStrength().get(player);
itemSpeed = pm.getItemSpeed().get(player);
itemMana = pm.getItemMana().get(player);
double hearts = maxHealth + itemHealth;
double heart = 10;
if (hearts > 125 && hearts < 165) {
heart = 11;
} else if (hearts > 165 && hearts <= 230) {
heart = 12;
} else if (hearts > 230 && hearts <= 300) {
heart = 13;
} else if (hearts > 300 && hearts <= 400) {
heart = 14;
} else if (hearts > 400 && hearts <= 500) {
heart = 15;
} else if (hearts > 500 && hearts <= 650) {
heart = 16;
} else if (hearts > 650 && hearts <= 800) {
heart = 17;
} else if (hearts > 800 && hearts <= 1000) {
heart = 18;
} else if (hearts > 1000 && hearts <= 1250) {
heart = 19;
} else if (hearts > 1250) {
heart = 20;
}
log(heart + " " + hearts);
player
.getAttribute(Attribute.GENERIC_MAX_HEALTH)
.setBaseValue(heart * 2);
player.setWalkSpeed((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
player.setFlySpeed((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
debug(
"Player " + player.getName(),
"Speed " + (speed + itemSpeed),
"Health " + (health + itemHealth) + " Max Health " + maxHealth,
"Defense " + (defense + itemDefense),
"Strength " + (strength + itemStrength),
"Luck " + (luck + itemLuck),
"Mana " + (mana + itemMana) + " Max Mana " + maxMana
);
pm.updateActionBar(player);
}
public static BukkitTask actionBarPlayer(
Raxen main,
PlayerManager pm,
Player player
) {
return new BukkitRunnable() {
@Override
public void run() {
player.sendActionBar(
colorComp(
"<red>" +
pm.getHealth().get(player) +
"/" +
pm.getMaxHealth().get(player) +
"❤</red> <aqua>" +
pm.getMana().get(player) +
"/" +
pm.getMaxMana().get(player) +
"</aqua>"
)
);
}
}
.runTaskTimerAsynchronously(main, 10, 20);
}
}

689
src/main/java/me/unurled/raxen/components/entity/player/RaxenPlayer.java
View file

@ -2,19 +2,37 @@ package me.unurled.raxen.components.entity.player;
import static me.unurled.raxen.utils.Items.setItemsToInventory;
import static me.unurled.raxen.utils.Utils.debug;
import static me.unurled.raxen.utils.Utils.log;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import lombok.Getter;
import lombok.Setter;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.DamageType;
import me.unurled.raxen.components.entity.other.EntityNamespacedKey;
import me.unurled.raxen.components.entity.other.MobData;
import me.unurled.raxen.components.entity.player.attributes.Attribute;
import me.unurled.raxen.components.entity.player.storages.EnderChest;
import me.unurled.raxen.components.entity.player.storages.Inventory;
import me.unurled.raxen.components.party.Party;
import me.unurled.raxen.manager.entity.PlayerManager;
import me.unurled.raxen.manager.entity.SpellManager.CastState;
import me.unurled.raxen.utils.EntityAttributes;
import me.unurled.raxen.utils.Items;
import me.unurled.raxen.utils.Math;
import me.unurled.raxen.utils.Utils;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.EntityEffect;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.boss.BarColor;
import org.bukkit.boss.BarStyle;
import org.bukkit.boss.BossBar;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.inventory.ItemStack;
@ -24,151 +42,562 @@ import org.bukkit.persistence.PersistentDataType;
public class RaxenPlayer {
private final Raxen main;
private final Player player;
private final EntityNamespacedKey namespacedKey;
private final Raxen main;
@Getter
private final Player player;
private final EntityNamespacedKey namespacedKey;
private Boolean isRaxenPlayer;
double crit_chance = 0.05;
public double critDamage = 1.50;
public boolean dead = false;
private Attribute attribute;
private DamageType lastDamageCause = DamageType.NORMAL;
private Storage storages;
private Inventories inventory;
private long lastEnvironmentalDamaged = 0;
private long lastDamagedNonEnvironmental = 0;
private long lastDamaged = 0;
public RaxenPlayer(Raxen main, Player player) {
this.main = main;
this.player = player;
this.namespacedKey = new EntityNamespacedKey(main);
this.isRaxenPlayer = true;
}
private Boolean isRaxenPlayer;
public Attribute createNewAttribute() {
debug(main, "Created new Attribute");
EntityAttributes.setAttributes(
player,
100,
100,
0,
50,
0,
100,
0,
100,
0,
100,
100,
0,
10,
0
);
return new Attribute(
100,
100,
0,
50,
0,
100,
0,
100,
0,
100,
100,
0,
10,
0
);
}
private Attribute attribute;
public void setStorages(
org.bukkit.inventory.Inventory inv,
org.bukkit.inventory.Inventory ec
) {
setStorage(ec);
setInventory(inv);
}
private Storage storages;
private Inventories inventory;
public Storage getStorage() {
PersistentDataContainer data = player.getPersistentDataContainer();
String store = data.get(namespacedKey.storage, PersistentDataType.STRING);
org.bukkit.inventory.Inventory ec = Bukkit.createInventory(
null,
54,
Component.text("Ender Chest")
);
ec = setItemsToInventory(Items.mapItemStackDeserialize(store), ec);
EnderChest ecc = new EnderChest(ec);
Storage storage = new Storage(ecc);
return storage;
}
private boolean inTutorial;
public Inventories getInventory() {
PersistentDataContainer data = player.getPersistentDataContainer();
String inv = data.get(namespacedKey.inventory, PersistentDataType.STRING);
org.bukkit.inventory.Inventory invv = Bukkit.createInventory(
player,
InventoryType.PLAYER
);
invv =
setItemsToInventory(
Items.listItemStackDeserialize(inv),
(PlayerInventory) invv
);
Inventory invvv = new Inventory(invv);
Inventories invvvv = new Inventories(invvv);
return invvvv;
}
private HashMap<String, HashMap<String, Integer>> mobCounter = new HashMap<String, HashMap<String, Integer>>();
public void setInventory(org.bukkit.inventory.Inventory inv) {
PersistentDataContainer data = player.getPersistentDataContainer();
List<String> listInv = new ArrayList<String>();
Integer reverse = 0;
for (ItemStack it : inv) {
reverse = reverse + 1;
if (it != null && it.getType() != Material.AIR) {
String s = Items.itemStackSerialize(it, reverse);
listInv.add(s);
}
private int mobKills, playerKills, deaths, bossKills;
public long xp;
@Getter
private int level;
@Getter
@Setter
private Party party = null;
@Getter
@Setter
private Party invitedParty = null;
BossBar bossBar;
public RaxenPlayer(Raxen main, Player player) {
this.main = main;
this.player = player;
this.namespacedKey = new EntityNamespacedKey(main);
this.isRaxenPlayer = true;
}
String invv = Items.listItemStackSerialize(listInv);
this.inventory = new Inventories(new Inventory(inv));
data.set(namespacedKey.inventory, PersistentDataType.STRING, invv);
}
public void setStorage(org.bukkit.inventory.Inventory ec) {
PersistentDataContainer data = player.getPersistentDataContainer();
List<String> list = new ArrayList<String>();
int reverse = 0;
for (ItemStack it : ec) {
if (it != null) {
String s = Items.itemStackSerialize(it, reverse);
list.add(s);
}
reverse += 1;
public Attribute createNewAttribute() {
debug(main, "Created new Attribute");
EntityAttributes.setAttributes(
player,
100,
100,
0,
50,
0,
100,
0,
100,
0,
100,
100,
0,
10,
0
);
return new Attribute(
100,
100,
0,
50,
0,
100,
0,
100,
0,
100,
100,
0,
10,
0
);
}
String store = Items.listItemStackSerialize(list);
this.storages = new Storage(new EnderChest(ec));
data.set(namespacedKey.storage, PersistentDataType.STRING, store);
}
public Storage createStorage() {
setStorage(Bukkit.createInventory(null, 54, Component.text("Ender Chest")));
return getStorage();
}
public void setStorages(
org.bukkit.inventory.Inventory inv,
org.bukkit.inventory.Inventory ec
) {
setStorage(ec);
setInventory(inv);
}
public Inventories createInventory() {
setInventory(Bukkit.createInventory(null, InventoryType.PLAYER));
return getInventory();
}
public Storage getStorage() {
PersistentDataContainer data = player.getPersistentDataContainer();
String store = data.get(
namespacedKey.storage,
PersistentDataType.STRING
);
org.bukkit.inventory.Inventory ec = Bukkit.createInventory(
null,
54,
Component.text("Ender Chest")
);
ec = setItemsToInventory(Items.mapItemStackDeserialize(store), ec);
EnderChest ecc = new EnderChest(ec);
Storage storage = new Storage(ecc);
return storage;
}
public Boolean isRaxenPlayer() {
return isRaxenPlayer;
}
public Inventories getInventory() {
PersistentDataContainer data = player.getPersistentDataContainer();
String inv = data.get(
namespacedKey.inventory,
PersistentDataType.STRING
);
org.bukkit.inventory.Inventory invv = Bukkit.createInventory(
player,
InventoryType.PLAYER
);
invv =
setItemsToInventory(
Items.listItemStackDeserialize(inv),
(PlayerInventory) invv
);
Inventory invvv = new Inventory(invv);
Inventories invvvv = new Inventories(invvv);
return invvvv;
}
public void isRaxenPlayer(boolean player) {
isRaxenPlayer = player;
}
public void setInventory(org.bukkit.inventory.Inventory inv) {
PersistentDataContainer data = player.getPersistentDataContainer();
List<String> listInv = new ArrayList<String>();
int reverse = 0;
for (ItemStack it : inv) {
reverse = reverse + 1;
if (it != null && it.getType() != Material.AIR) {
String s = Items.itemStackSerialize(it, reverse);
listInv.add(s);
}
}
String invv = Items.listItemStackSerialize(listInv);
this.inventory = new Inventories(new Inventory(inv));
data.set(namespacedKey.inventory, PersistentDataType.STRING, invv);
}
public Attribute getAttribute() {
return attribute;
}
public void setStorage(org.bukkit.inventory.Inventory ec) {
PersistentDataContainer data = player.getPersistentDataContainer();
List<String> list = new ArrayList<String>();
int reverse = 0;
for (ItemStack it : ec) {
if (it != null) {
String s = Items.itemStackSerialize(it, reverse);
list.add(s);
}
reverse += 1;
}
String store = Items.listItemStackSerialize(list);
this.storages = new Storage(new EnderChest(ec));
data.set(namespacedKey.storage, PersistentDataType.STRING, store);
}
public Storage createStorage() {
setStorage(
Bukkit.createInventory(null, 54, Component.text("Ender Chest"))
);
return getStorage();
}
public Inventories createInventory() {
org.bukkit.inventory.Inventory inv = Bukkit.createInventory(null, InventoryType.PLAYER);
setInventory(inv);
return new Inventories(new Inventory(inv));
}
public Boolean isRaxenPlayer() {
return isRaxenPlayer;
}
public void isRaxenPlayer(boolean player) {
isRaxenPlayer = player;
}
public Attribute getAttribute() {
return attribute;
}
public boolean isInTutorial() {
return inTutorial;
}
public void setInTutorial(boolean inTutorial) {
this.inTutorial = inTutorial;
}
public int getDamage() {
return 0;
}
public boolean attackPlayer(RaxenPlayer player) {
return attackPlayer(player, -1, false, 0.5);
}
public boolean attackPlayer(RaxenPlayer player, int damage) {
return attackPlayer(player, damage, false, 0.5);
}
public boolean attackPlayer(RaxenPlayer player, int damage, boolean projectile) {
return attackPlayer(player, damage, projectile, 0.5);
}
public boolean attackPlayer(RaxenPlayer player, int damage, boolean projectile,
double knockback) {
if (player == null) {
return false;
}
if (player == null) {
return false;
}
int eDamage;
if (damage > 0) {
eDamage = damage;
} else {
eDamage = getDamage();
}
boolean crit = false;
if (java.lang.Math.random() < crit_chance) {
crit = true;
eDamage = (int) (eDamage * 1.5);
}
boolean sucess = false;
// TODO: calculate with classes... later
sucess = player.damage(eDamage, this.player, DamageType.NORMAL, crit);
return sucess;
}
public boolean attackMob(MobData other) {
return attackMob(other, 0.5, -1, false);
}
public boolean attackMob(MobData other, int rpgDamage) {
return attackMob(other, 0.5, rpgDamage, false);
}
public boolean attackMob(MobData other, int rpgDamage, boolean projectile) {
return attackMob(other, 0.5, rpgDamage, projectile);
}
public boolean attackMob(MobData other, double knockback, int rpgDamage,
boolean projectil) {
Player p = getPlayer();
if (p == null || other == null) {
return false;
}
int damage;
if (rpgDamage > 0) {
damage = rpgDamage;
} else {
damage = getDamage();
}
boolean crit = false;
double critChanceTemp = crit_chance;
if (java.lang.Math.random() < critChanceTemp) {
crit = true;
damage *= critDamage;
}
boolean sucess = false;
sucess = other.damage(damage, p, DamageType.NORMAL, crit);
if (sucess && !projectil) {
// TODO: other.knockback(p, knockback);
}
return sucess;
}
public boolean damage(int damage, Entity damager, DamageType damageType) {
return damage(damage, damager, damageType, false);
}
public boolean damage(int damage, Entity damager, DamageType damageType, boolean crit) {
if (dead) {
return false;
}
if (System.currentTimeMillis() - lastEnvironmentalDamaged < 600 && (
damageType == DamageType.ENVIRONMENTAL_LAVA
|| damageType == DamageType.ENVIRONMENTAL_DROWNING
|| damageType == DamageType.ENVIRONMENTAL_FALL)) {
return false;
}
if (player == null) {
return false;
}
if (damager != null) {
if (damager instanceof Player) {
RaxenPlayer damagerRX = main.getManager().getPlayerManager()
.getRaxenPlayer((Player) damager);
if (!((Player) damager).isOnline() || damagerRX == null) {
return false;
}
// TODO: check if same party later not now
}
}
switch (lastDamageCause = damageType) {
case NORMAL:
case NORMAL_SPELL:
damage -= Math.randInt(0, getAttribute().getDefense());
lastDamagedNonEnvironmental = System.currentTimeMillis();
break;
case ENVIRONMENTAL_FALL:
if (damage >= getAttribute().getHealth()) {
damage = getAttribute().getHealth() - 1;
}
break;
}
if (damageType == DamageType.ENVIRONMENTAL_LAVA
|| damageType == DamageType.ENVIRONMENTAL_DROWNING
|| damageType == DamageType.ENVIRONMENTAL_FALL) {
lastEnvironmentalDamaged = System.currentTimeMillis();
} else if (damageType == DamageType.NORMAL) {
lastDamaged = System.currentTimeMillis();
}
if (damager != null && damager != player && damager instanceof Player) {
damage *= 0.8; // pvp nerf
}
if (damage < 1) {
damage = 1;
}
if (damageType == DamageType.NORMAL_SPELL || damageType == DamageType.NORMAL) {
if (damage > getAttribute().getHealth() * 0.5) {
player.leaveVehicle();
}
}
getAttribute().setHealth(getAttribute().getHealth() - damage);
if (getAttribute().getHealth() < 0) {
getAttribute().setHealth(0);
}
if (damager != null && damager != player) {
if (damager instanceof Player) {
RaxenPlayer damagerRX = main.getManager().getPlayerManager()
.getRaxenPlayer((Player) damager);
if (damagerRX != null) {
Player p2 = damagerRX.getPlayer();
if (p2 != null && p2.isValid()) {
p2.playSound(p2.getLocation(), Sound.ENTITY_PLAYER_HURT, 0.65f, 0.75f);
}
}
}
}
player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_HURT, 0.85f, 0.85f);
if (System.currentTimeMillis() - lastDamaged < 1000) {
player.playEffect(EntityEffect.HURT);
}
if (getAttribute().getHealth() <= 0) {
die();
} else {
// TODO: update health display on action bar
}
return true;
}
public void die() {
log("player " + player.displayName() + " died");
}
public void incrementMobCounter(String mob) {
if (mobCounter.containsKey(mob)) {
mobCounter.get(mob).replaceAll((k, v) -> v + 1);
// TODO: mob quest tracker ?
}
}
public int getMobKills() {
return mobKills;
}
public int getPlayerKills() {
return playerKills;
}
public int getDeaths() {
return deaths;
}
public int getBossKills() {
return bossKills;
}
public void setMobKills(int mobKills) {
this.mobKills = mobKills;
}
public void setPlayerKills(int playerKills) {
this.playerKills = playerKills;
}
public void setDeaths(int deaths) {
this.deaths = deaths;
}
public void setBossKills(int bossKills) {
this.bossKills = bossKills;
}
public void addMobKills(int mobKills) {
this.mobKills += mobKills;
}
public void addMobKills() {
this.mobKills += 1;
}
public void addPlayerKills(int playerKills) {
this.playerKills += playerKills;
}
public void addPlayerKills() {
this.playerKills += 1;
}
public void addDeaths(int deaths) {
this.deaths += deaths;
}
public void addDeaths() {
this.deaths += 1;
}
public void addBossKills(int bossKills) {
this.bossKills += bossKills;
}
public void addBossKills() {
this.bossKills += 1;
}
public void gainXp(long amt) {
gainXp(amt, false);
}
public void gainXp(long amt, boolean penalty) {
xp += amt;
Player p = getPlayer();
if (p == null || !p.isValid()) {
return;
}
int bonus = 0;
// IDEA: per class xp bonus
// IDEA: party xp multiplier
long tXp = amt;
if (bonus > 0) {
tXp += bonus;
xp += bonus;
}
if (xp >= getXpForNextLevel()) {
long extra = xp - getXpForNextLevel();
xp = 0;
level++;
xp = extra < getXpForNextLevel() ? extra : getXpForNextLevel() - 1;
// TODO: take care of stats level up
// TODO: update health and mana display;
}
}
private int lastLevel = -1;
private long cachedXp = -1;
public long getXpForNextLevel() {
long ret = 1;
if (lastLevel == level && cachedXp > 0) {
return cachedXp;
}
ret = PlayerStatistics.getEXPForNextLevel(level);
if (ret < 0) {
ret = Long.MAX_VALUE;
}
lastLevel = level;
cachedXp = ret;
return ret;
}
public void knockback(LivingEntity attacker, double knockBackMultiplier) {
return;
}
public void updateHealthManaDisplay() {
Player p = getPlayer();
PlayerManager manager = main.getManager().getPlayerManager();
if (p != null) {
int health = manager.getHealth().get(p);
int maxHealth = manager.getMaxHealth().get(p);
int mana = manager.getMana().get(p);
int maxMana = manager.getMaxMana().get(p);
if (health > maxHealth) {
manager.getHealth().set(p, maxHealth);
health = manager.getHealth().get(p);
}
if (health < 0) {
manager.getHealth().set(p, 0);
health = manager.getHealth().get(p);
}
if (mana > maxMana) {
manager.getMana().set(p, maxMana);
mana = manager.getMana().get(p);
}
if (dead) {
return;
}
double percent = ((double) health) / ((double) maxHealth);
StringBuilder sb = new StringBuilder();
BarColor color = BarColor.GREEN;
if (percent > 0.5) {
sb.append("<green>");
sb.append(health);
sb.append(" <aqua><bold>HP");
} else if (percent > 0.20) {
sb.append("<yellow>");
sb.append(health);
sb.append(" <aqua><bold>HP");
color = BarColor.YELLOW;
} else {
sb.append("<dark_red><bold>DANGER - <reset><red>");
sb.append(health);
sb.append(" <dark_red><bold> - DANGER");
color = BarColor.RED;
}
sb.append("<reset>");
// TODO: status poison, burn, bleed
if (percent > 1) {
percent = 1;
} else if (percent < 0.01) {
percent = 0.01;
}
if (bossBar == null) {
bossBar = Bukkit.createBossBar(Utils.coloredString(sb.toString()), BarColor.GREEN,
BarStyle.SOLID);
bossBar.addPlayer(p);
}
bossBar.setTitle(Utils.coloredString(sb.toString().trim()));
bossBar.setProgress(percent);
bossBar.setColor(color);
if (!p.isGliding() && main.getManager().getSpellManager().casters.containsKey(
p.getUniqueId())) {
CastState cs = main.getManager().getSpellManager().casters.get(
p.getUniqueId()).state;
if (cs != CastState.NONE) {
StringBuilder sb2 = new StringBuilder();
sb2.append("<gold><bold> ");
sb2.append(cs.toString());
p.sendActionBar(Utils.colorComp(sb2.toString()));
}
}
// p.setFoodLevel(mana * 2);
p.setLevel(level);
p.setExp((float) (((double) xp) / ((double) getXpForNextLevel())));
}
}
}

124
src/main/java/me/unurled/raxen/components/entity/player/Scoreboard.java
View file

@ -10,66 +10,70 @@ import org.bukkit.scoreboard.*;
public class Scoreboard {
private Raxen main;
private Vault vault;
private Raxen main;
private Vault vault;
public Scoreboard(Raxen main) {
this.main = main;
this.vault = main.getManager().getLibsManager().getVault();
}
public void createScorebord(Player player) {
ScoreboardManager manager = Bukkit.getScoreboardManager();
org.bukkit.scoreboard.Scoreboard board = manager.getNewScoreboard();
Objective obj = board.registerNewObjective(
"Raxen",
Criteria.DUMMY,
colorTextComp("<red>Elixium")
);
obj.setDisplaySlot(DisplaySlot.SIDEBAR);
Score score = obj.getScore(
textCompToString(colorTextComp("<gold>-------------"))
);
score.setScore(4);
Score score1 = obj.getScore(
textCompToString(colorTextComp("<aqua>Name:" + player.getName()))
);
score1.setScore(3);
Score score2 = obj.getScore(
textCompToString(colorTextComp("<white>Location"))
);
score2.setScore(2);
Score score3 = obj.getScore(
textCompToString(
colorTextComp("<gold>Coins: <gold>" + vault.getBalanceString(player))
)
);
score3.setScore(1);
Score score4 = obj.getScore(
textCompToString(colorTextComp("<yellow>unurled.me"))
);
score4.setScore(0);
player.setScoreboard(board);
}
public void updateScoreboardTransaction(Player player) {
if (player != null) {
Objective objective = player
.getScoreboard()
.getObjective(DisplaySlot.SIDEBAR);
player.getScoreboard().getObjective(DisplaySlot.SIDEBAR);
debug(main, String.valueOf(player.getScoreboard().getEntries()));
for (String str : player.getScoreboard().getEntries()) {
if (str.contains(player.getName())) {}
}
player.getScoreboard().resetScores("Coins");
assert objective != null;
Score score = objective.getScore(
textCompToString(
colorTextComp("<gold>Coins: <gold>" + vault.getBalanceString(player))
)
);
score.setScore(1);
public Scoreboard(Raxen main) {
this.main = main;
this.vault = main.getManager().getLibsManager().getVault();
}
public void createScorebord(Player player) {
ScoreboardManager manager = Bukkit.getScoreboardManager();
org.bukkit.scoreboard.Scoreboard board = manager.getNewScoreboard();
Objective obj = board.registerNewObjective(
"Raxen",
Criteria.DUMMY,
colorTextComp("<red>Elixium")
);
obj.setDisplaySlot(DisplaySlot.SIDEBAR);
Score score = obj.getScore(
textCompToString(colorTextComp("<gold>-------------"))
);
score.setScore(4);
Score score1 = obj.getScore(
textCompToString(colorTextComp("<aqua>Name:" + player.getName()))
);
score1.setScore(3);
Score score2 = obj.getScore(
textCompToString(colorTextComp("<white>Location"))
);
score2.setScore(2);
Score score3 = obj.getScore(
textCompToString(
colorTextComp(
"<gold>Coins: <gold>" + vault.getBalanceString(player)
)
)
);
score3.setScore(1);
Score score4 = obj.getScore(
textCompToString(colorTextComp("<yellow>unurled.me"))
);
score4.setScore(0);
player.setScoreboard(board);
}
public void updateScoreboardTransaction(Player player) {
if (player != null) {
Objective objective = player
.getScoreboard()
.getObjective(DisplaySlot.SIDEBAR);
player.getScoreboard().getObjective(DisplaySlot.SIDEBAR);
debug(main, String.valueOf(player.getScoreboard().getEntries()));
for (String str : player.getScoreboard().getEntries()) {
if (str.contains(player.getName())) {}
}
player.getScoreboard().resetScores("Coins");
assert objective != null;
Score score = objective.getScore(
textCompToString(
colorTextComp(
"<gold>Coins: <gold>" + vault.getBalanceString(player)
)
)
);
score.setScore(1);
}
}
}
}

20
src/main/java/me/unurled/raxen/components/entity/player/Storage.java
View file

@ -4,17 +4,17 @@ import me.unurled.raxen.components.entity.player.storages.EnderChest;
public class Storage {
private EnderChest ec;
private EnderChest ec;
public Storage(EnderChest ec) {
this.ec = ec;
}
public Storage(EnderChest ec) {
this.ec = ec;
}
public EnderChest getEc() {
return ec;
}
public EnderChest getEc() {
return ec;
}
public void setEc(EnderChest ec) {
this.ec = ec;
}
public void setEc(EnderChest ec) {
this.ec = ec;
}
}

68
src/main/java/me/unurled/raxen/components/entity/player/attributes/Attribute.java
View file

@ -5,39 +5,39 @@ import lombok.Setter;
public class Attribute {
@Getter
@Setter
private int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
@Getter
@Setter
private int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
public Attribute(
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
) {
this.maxHealth = maxHealth;
this.health = health;
this.itemHealth = itemHealth;
this.defense = defense;
this.itemDefense = itemDefense;
this.speed = speed;
this.itemSpeed = itemSpeed;
this.strength = strength;
this.itemStrength = itemStrength;
this.maxHealth = maxMana;
this.mana = mana;
this.itemMana = itemMana;
this.luck = luck;
this.itemLuck = itemLuck;
}
public Attribute(
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
) {
this.maxHealth = maxHealth;
this.health = health;
this.itemHealth = itemHealth;
this.defense = defense;
this.itemDefense = itemDefense;
this.speed = speed;
this.itemSpeed = itemSpeed;
this.strength = strength;
this.itemStrength = itemStrength;
this.maxHealth = maxMana;
this.mana = mana;
this.itemMana = itemMana;
this.luck = luck;
this.itemLuck = itemLuck;
}
}

176
src/main/java/me/unurled/raxen/components/entity/player/attributes/Attributes.java
View file

@ -11,96 +11,96 @@ import org.jetbrains.annotations.NotNull;
public class Attributes {
private static EntityNamespacedKey namespacedKey;
private static EntityNamespacedKey namespacedKey;
public Attributes(Raxen main) {
namespacedKey = new EntityNamespacedKey(main);
}
public Attributes(Raxen main) {
namespacedKey = new EntityNamespacedKey(main);
}
@Contract("_ -> new")
public static @NotNull Attribute getAttribute(Player player) {
int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
Entity e = player;
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
);
}
@Contract("_ -> new")
public static @NotNull Attribute getAttribute(Player player) {
int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
Entity e = player;
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
);
}
public static void setAttributes(
Player player,
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) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
Entity e = player;
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);
}
public static void setAttributes(
Player player,
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) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
Entity e = player;
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);
}
public static String[] getNameList() {
return new String[] {
"Defense",
"Health",
"Luck",
"Mana",
"Speed",
"Strength",
};
}
public static String[] getNameList() {
return new String[] {
"Defense",
"Health",
"Luck",
"Mana",
"Speed",
"Strength"
};
}
}

72
src/main/java/me/unurled/raxen/components/entity/player/classes/Class.java
View file

@ -8,46 +8,46 @@ import org.bukkit.inventory.ItemStack;
public class Class {
@Getter
String name;
@Getter
String name;
@Getter
String colorName;
@Getter
String colorName;
@Getter
String ID;
@Getter
String ID;
@Getter
ItemStack placeHolder;
@Getter
ItemStack placeHolder;
@Getter
Integer max_level;
@Getter
Integer max_level;
public Class(
String name,
String colorName,
String ID,
String itemPlaceHolder,
Integer max_level
) {
this.name = name;
this.ID = ID;
this.placeHolder = new ItemStack(Material.getMaterial(itemPlaceHolder));
this.placeHolder.getItemMeta().displayName(colorTextComp(colorName));
this.max_level = max_level;
}
public Class(
String name,
String colorName,
String ID,
String itemPlaceHolder,
Integer max_level
) {
this.name = name;
this.ID = ID;
this.placeHolder = new ItemStack(Material.getMaterial(itemPlaceHolder));
this.placeHolder.getItemMeta().displayName(colorTextComp(colorName));
this.max_level = max_level;
}
public Class(
String name,
String colorName,
String ID,
ItemStack itemPlaceHolder,
Integer max_level
) {
this.name = name;
this.ID = ID;
this.placeHolder = itemPlaceHolder;
this.placeHolder.getItemMeta().displayName(colorTextComp(colorName));
this.max_level = max_level;
}
public Class(
String name,
String colorName,
String ID,
ItemStack itemPlaceHolder,
Integer max_level
) {
this.name = name;
this.ID = ID;
this.placeHolder = itemPlaceHolder;
this.placeHolder.getItemMeta().displayName(colorTextComp(colorName));
this.max_level = max_level;
}
}

56
src/main/java/me/unurled/raxen/components/entity/player/classes/Classes.java
View file

@ -9,35 +9,35 @@ import me.unurled.raxen.components.entity.player.classes.list.Assassin;
public class Classes {
private final Raxen main;
private final Raxen main;
public Classes(Raxen main) {
this.main = main;
register();
}
public void register() {
registerClass(new Assassin());
}
public class resultClass {
@Getter
@Setter
public Class clas;
@Getter
@Setter
public String id;
public resultClass(Class clas, String id) {
this.clas = clas;
this.id = id;
public Classes(Raxen main) {
this.main = main;
register();
}
}
public void registerClass(Class clas) {
debug(clas.getID());
main.getManager().getPlayerManager().addClasses(clas, clas.getID());
}
public void register() {
registerClass(new Assassin());
}
public class resultClass {
@Getter
@Setter
public Class clas;
@Getter
@Setter
public String id;
public resultClass(Class clas, String id) {
this.clas = clas;
this.id = id;
}
}
public void registerClass(Class clas) {
debug(clas.getID());
main.getManager().getPlayerManager().addClasses(clas, clas.getID());
}
}

52
src/main/java/me/unurled/raxen/components/entity/player/classes/list/Assassin.java
View file

@ -7,33 +7,33 @@ import org.bukkit.inventory.ItemStack;
public class Assassin extends Class {
String ID = "ASSASSIN";
String name = "Assassin";
String colorName = "<red>Assassin";
Integer max_level = 100;
String ID = "ASSASSIN";
String name = "Assassin";
String colorName = "<red>Assassin";
Integer max_level = 100;
ItemStack placeHolder;
ItemStack placeHolder;
public Assassin() {
super(
"Assassin",
"<red>Assassin",
"ASSASSIN",
new ItemStack(Material.AIR),
100
);
Dagger dagger = new Dagger();
dagger.buildItem();
placeHolder = dagger.getItem();
}
public Assassin() {
super(
"Assassin",
"<red>Assassin",
"ASSASSIN",
new ItemStack(Material.AIR),
100
);
Dagger dagger = new Dagger();
dagger.buildItem();
placeHolder = dagger.getItem();
}
public Assassin(
String name,
String colorName,
String ID,
String itemPlaceHolder,
Integer max_level
) {
super(name, colorName, ID, itemPlaceHolder, max_level);
}
public Assassin(
String name,
String colorName,
String ID,
String itemPlaceHolder,
Integer max_level
) {
super(name, colorName, ID, itemPlaceHolder, max_level);
}
}

20
src/main/java/me/unurled/raxen/components/entity/player/storages/EnderChest.java
View file

@ -8,15 +8,15 @@ import org.bukkit.inventory.Inventory;
public class EnderChest {
@Getter
@Setter
public Inventory ec = Bukkit.createInventory(
null,
54,
Component.text("Ender Chest")
);
@Getter
@Setter
public Inventory ec = Bukkit.createInventory(
null,
54,
Component.text("Ender Chest")
);
public EnderChest(Inventory ec) {
this.ec = ec;
}
public EnderChest(Inventory ec) {
this.ec = ec;
}
}

18
src/main/java/me/unurled/raxen/components/entity/player/storages/Inventory.java
View file

@ -7,14 +7,14 @@ import org.bukkit.event.inventory.InventoryType;
public class Inventory {
@Getter
@Setter
public org.bukkit.inventory.Inventory inv = Bukkit.createInventory(
null,
InventoryType.PLAYER
);
@Getter
@Setter
public org.bukkit.inventory.Inventory inv = Bukkit.createInventory(
null,
InventoryType.PLAYER
);
public Inventory(org.bukkit.inventory.Inventory inv) {
this.inv = inv;
}
public Inventory(org.bukkit.inventory.Inventory inv) {
this.inv = inv;
}
}

340
src/main/java/me/unurled/raxen/components/gui/ItemListGui.java
View file

@ -1,21 +1,15 @@
package me.unurled.raxen.components.gui;
import static me.unurled.raxen.utils.Items.*;
import static me.unurled.raxen.utils.Utils.*;
import static me.unurled.raxen.utils.Utils.fillGreyPane;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import lombok.Getter;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.player.PlayerUtils;
import me.unurled.raxen.utils.Utils;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextComponent;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
@ -25,293 +19,61 @@ import org.bukkit.inventory.ItemStack;
public class ItemListGui implements Listener {
private Raxen main;
private Raxen main;
@Getter
private Inventory inv = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
@Getter
private Inventory inv = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private Inventory inv2 = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private Inventory inv3 = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private Inventory inv4 = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private Inventory inv5 = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private Inventory inv6 = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private Inventory inv7 = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private Inventory inv8 = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private Inventory inv9 = Bukkit.createInventory(
null,
54,
Component.text("Item List")
);
private HashMap<String, ItemStack> itlist;
private HashMap<String, ItemStack> itlist;
public ItemListGui(Raxen main) {
this.main = main;
this.itlist = this.main.getManager().getItemManager().getList();
this.inv = getInventories();
}
private ItemStack PREVIOUS = createItem(
Material.ARROW,
1,
true,
false,
"Previous page"
);
private ItemStack NEXT = createItem(
Material.ARROW,
1,
true,
false,
"Next page"
);
private ItemStack PAGE = createItem(Material.PAPER, 1, true, false, "Page");
private ItemStack CLOSE = closeItem();
private ItemStack GREY_PANE = greyPane();
public Inventory getInventories() {
Integer page = 1;
Integer item = -1;
for (Map.Entry<String, ItemStack> entry : itlist.entrySet()) {
ItemStack it = entry.getValue();
item++;
if (item > 44 && item < 91) {
inv2.addItem(it);
inv2.setItem(48, PREVIOUS);
inv2.setItem(
49,
editItem(PAGE, "page" + page, 1, new ArrayList<Component>())
);
inv2.setItem(53, CLOSE);
inv2 = fillGreyPane(inv2);
}
if (item > 90 && item < 136) {
inv3.setItem(48, PREVIOUS);
inv3.setItem(
49,
editItem(PAGE, "page" + page, 1, new ArrayList<Component>())
);
inv3.setItem(53, CLOSE);
inv3 = fillGreyPane(inv3);
}
if (item > 135 && item < 181) {
inv4.addItem(it);
inv4.setItem(48, PREVIOUS);
inv4.setItem(
49,
editItem(PAGE, "page" + page, 1, new ArrayList<Component>())
);
inv4.setItem(53, CLOSE);
inv4 = fillGreyPane(inv4);
}
if (item > 180 && item < 226) {
inv5.addItem(it);
inv5.setItem(48, PREVIOUS);
inv5.setItem(
49,
editItem(PAGE, "page" + page, 1, new ArrayList<Component>())
);
inv5.setItem(53, CLOSE);
inv5 = fillGreyPane(inv5);
}
if (item > 225 && item < 271) {
inv6.addItem(it);
inv6.setItem(48, PREVIOUS);
inv6.setItem(
49,
editItem(PAGE, "page" + page, 1, new ArrayList<Component>())
);
inv6.setItem(53, CLOSE);
inv6 = fillGreyPane(inv6);
}
if (item > 270 && item < 316) {
inv7.addItem(it);
inv7.setItem(48, PREVIOUS);
inv7.setItem(
49,
editItem(PAGE, "page" + page, 1, new ArrayList<Component>())
);
inv7.setItem(53, CLOSE);
inv7 = fillGreyPane(inv7);
}
if (item > 315 && item < 361) {
inv8.addItem(it);
inv8.setItem(48, PREVIOUS);
inv8.setItem(
49,
editItem(PAGE, "page" + page, 1, new ArrayList<Component>())
);
inv8.setItem(53, CLOSE);
inv8 = fillGreyPane(inv8);
}
if (item > 360 && item < 406) {
inv9.addItem(it);
inv9.setItem(48, PREVIOUS);
inv9.setItem(
49,
editItem(PAGE, "page" + page, 1, new ArrayList<Component>())
);
inv9.setItem(53, CLOSE);
inv9 = fillGreyPane(inv9);
}
if (item > 405) {
log("Too many item to render.");
} else {
inv.addItem(it);
inv.setItem(49, PAGE);
inv.setItem(50, NEXT);
}
if (item > 44) {
inv.setItem(50, NEXT);
if (item > 90) {
inv2.setItem(50, NEXT);
if (item > 135) {
inv3.setItem(50, NEXT);
if (item > 180) {
inv4.setItem(50, NEXT);
if (item > 225) {
inv5.setItem(50, NEXT);
if (item > 270) {
inv6.setItem(50, NEXT);
if (item > 315) {
inv7.setItem(50, NEXT);
if (item > 360) {
inv8.setItem(50, NEXT);
}
}
}
}
}
}
}
}
page++;
inv.setItem(53, CLOSE);
inv = fillGreyPane(inv);
public ItemListGui(Raxen main) {
this.main = main;
this.itlist = this.main.getManager().getItemManager().getList();
}
return inv;
}
@EventHandler
public void clickInventory(InventoryClickEvent e) {
Player player = (Player) e.getWhoClicked();
Inventory einv = e.getClickedInventory();
if (
einv == inv ||
einv == inv2 ||
einv == inv3 ||
einv == inv4 ||
einv == inv5 ||
einv == inv6 ||
einv == inv7 ||
einv == inv8 ||
einv == inv9
) {
if (
e.getCurrentItem() != null &&
e.getCurrentItem().getType() != Material.AIR
) {
Integer slot = e.getSlot();
ItemStack clicked;
if (slot == 48) {
//previous
if (e.getCurrentItem() != GREY_PANE) {
ItemStack pagee = einv.getItem(49);
String name = textCompToString(pagee.displayName());
int page = Integer.parseInt(name.replace("page", ""));
switch (page) {
case 2:
player.openInventory(inv);
case 3:
player.openInventory(inv2);
case 4:
player.openInventory(inv3);
case 5:
player.openInventory(inv4);
case 6:
player.openInventory(inv5);
case 7:
player.openInventory(inv6);
case 8:
player.openInventory(inv7);
case 9:
player.openInventory(inv8);
public Inventory getInventories(int page) {
int item = -1;
int number = 54 * (page - 1);
int number_final = number + 54;
for (ItemStack it : itlist.values()) {
item++;
if (item >= number && item < number_final) {
inv.setItem(item - number, it);
}
}
} else if (slot == 49) {
//page
return;
} else if (slot == 50) {
//next
ItemStack pagee = einv.getItem(49);
if (pagee != null) {
String name = textCompToString(pagee.displayName());
name = name.replace("[", "");
name = name.replace("]", "");
log(name);
int page = Integer.parseInt(name.replace("page", ""));
switch (page) {
case 1:
player.openInventory(inv2);
case 2:
player.openInventory(inv3);
case 3:
player.openInventory(inv4);
case 4:
player.openInventory(inv5);
case 5:
player.openInventory(inv6);
case 6:
player.openInventory(inv7);
case 7:
player.openInventory(inv8);
case 8:
player.openInventory(inv9);
}
}
} else if (slot == 53) {
//close
player.closeInventory();
} else {
//if (player.getInventory().firstEmpty() == -1) {
//add to stash
//}
player.getInventory().addItem(e.getCurrentItem());
PlayerUtils.updateSkills(main, player);
}
}
fillGreyPane(inv);
return inv;
}
@EventHandler
public void clickInventory(InventoryClickEvent e) {
Player player = (Player) e.getWhoClicked();
Inventory einv = e.getClickedInventory();
if (einv == inv) {
if (
e.getCurrentItem() != null &&
e.getCurrentItem().getType() != Material.AIR
) {
Integer slot = e.getSlot();
ItemStack clicked;
//if (player.getInventory().firstEmpty() == -1) {
//add to stash
//}
player.getInventory().addItem(e.getCurrentItem());
player.closeInventory();
player.playSound(player, Sound.UI_BUTTON_CLICK, 1, 0);
PlayerUtils.updateSkills(main, player);
}
}
}
public void openInventory(Player player, int page) {
inv = getInventories(page);
player.openInventory(inv);
}
}
}

118
src/main/java/me/unurled/raxen/components/gui/MainGui.java
View file

@ -14,66 +14,66 @@ import org.bukkit.inventory.meta.SkullMeta;
public class MainGui {
public static Inventory build(Player p) {
Inventory inv = Bukkit.createInventory(
null,
54,
colorComp("<dark_grey>Raxen</dark_grey>")
);
String gui =
"0,7,0,0,0,8,9,0,10," +
"0,0,0,0,0,0,0,0,0," +
"0,0,0,0,0,0,0,0,0," +
"0,2,3,0,0,0,0,4,0," +
"0,0,0,0,1,0,0,0,0," +
"0,0,0,0,0,0,0,0,0";
// 1 player Head
ItemStack head = new ItemStack(Material.PLAYER_HEAD);
SkullMeta headm = (SkullMeta) head.getItemMeta();
headm.setOwningPlayer(p.getPlayer());
headm.displayName(colorComp("<green></green>"));
// 2 bank
ItemStack bank = new ItemStack(Material.GOLD_INGOT);
// 3 ah
ItemStack ah = new ItemStack(Material.GOLD_INGOT);
// 4 skill tree
ItemStack sk_tree = new ItemStack(Material.OAK_SAPLING);
// 7 teleport
ItemStack tp = new ItemStack(Material.ENDER_PEARL);
// 8 select character
ItemStack sel_char = new ItemStack(Material.SNOWBALL);
// 9 Settings
ItemStack sett = new ItemStack(Material.MAGMA_CREAM);
// 10 barrier block close
public static Inventory build(Player p) {
Inventory inv = Bukkit.createInventory(
null,
54,
colorComp("<dark_grey>Raxen</dark_grey>")
);
String gui =
"0,7,0,0,0,8,9,0,10," +
"0,0,0,0,0,0,0,0,0," +
"0,0,0,0,0,0,0,0,0," +
"0,2,3,0,0,0,0,4,0," +
"0,0,0,0,1,0,0,0,0," +
"0,0,0,0,0,0,0,0,0";
// 1 player Head
ItemStack head = new ItemStack(Material.PLAYER_HEAD);
SkullMeta headm = (SkullMeta) head.getItemMeta();
headm.setOwningPlayer(p.getPlayer());
headm.displayName(colorComp("<green></green>"));
// 2 bank
ItemStack bank = new ItemStack(Material.GOLD_INGOT);
// 3 ah
ItemStack ah = new ItemStack(Material.GOLD_INGOT);
// 4 skill tree
ItemStack sk_tree = new ItemStack(Material.OAK_SAPLING);
// 7 teleport
ItemStack tp = new ItemStack(Material.ENDER_PEARL);
// 8 select character
ItemStack sel_char = new ItemStack(Material.SNOWBALL);
// 9 Settings
ItemStack sett = new ItemStack(Material.MAGMA_CREAM);
// 10 barrier block close
HashMap<String, ItemStack> list = new HashMap<>();
list.put("1", head);
list.put("2", bank);
list.put("3", ah);
list.put("4", sk_tree);
list.put("7", tp);
list.put("8", sel_char);
list.put("9", sett);
list.put("10", Items.closeItem());
Inventory inventory = stringToGui(inv, gui, list);
inventory = fillGreyPane(inventory);
return inventory;
}
HashMap<String, ItemStack> list = new HashMap<>();
list.put("1", head);
list.put("2", bank);
list.put("3", ah);
list.put("4", sk_tree);
list.put("7", tp);
list.put("8", sel_char);
list.put("9", sett);
list.put("10", Items.closeItem());
Inventory inventory = stringToGui(inv, gui, list);
inventory = fillGreyPane(inventory);
return inventory;
}
public static Inventory stringToGui(
Inventory inv,
String stt,
HashMap<String, ItemStack> it
) {
String[] s = stt.split(",");
if (s.length != inv.getContents().length) {
return inv;
public static Inventory stringToGui(
Inventory inv,
String stt,
HashMap<String, ItemStack> it
) {
String[] s = stt.split(",");
if (s.length != inv.getContents().length) {
return inv;
}
Integer i = 0;
for (String st : s) {
inv.setItem(i, it.get(st));
i++;
}
return inv;
}
Integer i = 0;
for (String st : s) {
inv.setItem(i, it.get(st));
i++;
}
return inv;
}
}

30
src/main/java/me/unurled/raxen/components/items/Attributes.java
View file

@ -4,20 +4,20 @@ import lombok.Getter;
public class Attributes {
@Getter
Integer health, speed, defense, strength;
@Getter
Integer health, speed, defense, strength;
public Attributes(
Integer health,
Integer defense,
Integer speed,
Integer strength,
Integer mana,
Integer luck
) {
this.health = health;
this.defense = defense;
this.speed = speed;
this.strength = strength;
}
public Attributes(
Integer health,
Integer defense,
Integer speed,
Integer strength,
Integer mana,
Integer luck
) {
this.health = health;
this.defense = defense;
this.speed = speed;
this.strength = strength;
}
}

116
src/main/java/me/unurled/raxen/components/items/ItemBuilder.java Normal file
View file

@ -0,0 +1,116 @@
package me.unurled.raxen.components.items;
import com.google.common.collect.Multimap;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import me.unurled.raxen.utils.Utils;
import net.kyori.adventure.text.Component;
import org.bukkit.Color;
import org.bukkit.Material;
import org.bukkit.attribute.Attribute;
import org.bukkit.attribute.AttributeModifier;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.FireworkEffectMeta;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.inventory.meta.LeatherArmorMeta;
import org.bukkit.inventory.meta.MapMeta;
import org.bukkit.inventory.meta.PotionMeta;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.potion.PotionData;
import org.bukkit.potion.PotionEffect;
import org.jetbrains.annotations.NotNull;
public class ItemBuilder {
private final PersistentDataContainer persistentDataContainer;
private ItemStack it;
private Material type;
private Component displayName;
private int amount;
private int customModelData;
private boolean hasCustomModelData;
private Color color;
private @NotNull PotionData potionData;
private List<PotionEffect> potionEffects;
private Set<ItemFlag> itemFlags;
private boolean hasAttributeModifiers;
private Multimap<Attribute, AttributeModifier> attributeModifiers;
private List<String> lore;
private final Map<Enchantment, Integer> enchantments;
public ItemBuilder(ItemStack it) {
this.it = it;
type = it.getType();
amount = it.getAmount();
final ItemMeta itm = it.getItemMeta();
if (itm instanceof LeatherArmorMeta leatherArmorMeta) {
color = leatherArmorMeta.getColor();
}
if (itm instanceof PotionMeta potionMeta) {
color = potionMeta.getColor();
potionData = potionMeta.getBasePotionData();
potionEffects = new ArrayList<>(potionMeta.getCustomEffects());
}
if (itm instanceof MapMeta mapMeta) {
color = mapMeta.getColor();
}
if (itm instanceof FireworkEffectMeta effectMeta) {
color =
effectMeta.hasEffect() ? effectMeta.getEffect().getColors().get(0) : Color.WHITE;
}
if (itm.hasDisplayName()) {
displayName = itm.displayName();
}
if (!itm.getItemFlags().isEmpty()) {
itemFlags = itm.getItemFlags();
}
hasAttributeModifiers = itm.hasAttributeModifiers();
if (hasAttributeModifiers) {
attributeModifiers = itm.getAttributeModifiers();
}
hasCustomModelData = itm.hasCustomModelData();
if (itm.hasCustomModelData()) {
customModelData = itm.getCustomModelData();
}
if (itm.hasLore()) {
lore = itm.getLore();
}
persistentDataContainer = itm.getPersistentDataContainer();
enchantments = new HashMap<>();
}
public ItemBuilder(Material material) {
this(new ItemStack(material));
}
public ItemBuilder displayName(String name) {
this.displayName = Utils.colorComp(name);
return this;
}
public void lore(List<String> lore) {
this.lore = lore;
}
public void color(Color color) {
this.color = color;
}
}

46
src/main/java/me/unurled/raxen/components/items/ItemParser.java Normal file
View file

@ -0,0 +1,46 @@
package me.unurled.raxen.components.items;
import java.util.List;
import me.unurled.raxen.utils.Utils;
import org.bukkit.Material;
import org.bukkit.configuration.ConfigurationSection;
public class ItemParser {
private final ConfigurationSection section;
private Material type;
public ItemParser(ConfigurationSection section) {
this.section = section;
type = Material.getMaterial(section.getString("material", "PAPER"));
if (section.isConfigurationSection("Pack")) {
ConfigurationSection packSection = section.getConfigurationSection("Pack");
// TODO: Parse pack section
}
}
public ItemBuilder buildItem() {
return buildItem(section.contains("name") ? section.getString("name") : null);
}
public ItemBuilder buildItem(String name) {
ItemBuilder item;
item = new ItemBuilder(type);
if (name != null) {
item.displayName(name);
}
return item;
}
private ItemBuilder applyConfig(ItemBuilder item) {
if (section.contains("lore")) {
List<String> lore = section.getStringList("lore");
item.lore(lore);
}
if (section.contains("color")) {
item.color(Utils.color(section.getString("color", "FFFFFF")));
}
return item;
}
}

14
src/main/java/me/unurled/raxen/components/items/NBT.java
View file

@ -1,14 +0,0 @@
package me.unurled.raxen.components.items;
public class NBT {
public static String HEALTH = "HEALTH";
public static String SPEED = "SPEED";
public static String STRENGTH = "STRENGTH";
public static String DEFENSE = "DEFENSE";
public static String LUCK = "LUCK";
public static String MANA = "MANA";
public static String ID = "ID";
public static String CUSTOM_ABILITY = "CUSTOM_ABILITY";
public static String DROP_RATE = "DROP_RATE";
}

16
src/main/java/me/unurled/raxen/components/items/NBTNames.java Normal file
View file

@ -0,0 +1,16 @@
package me.unurled.raxen.components.items;
public class NBTNames {
public static String HEALTH = "HEALTH";
public static String SPEED = "SPEED";
public static String STRENGTH = "STRENGTH";
public static String DEFENSE = "DEFENSE";
public static String LUCK = "LUCK";
public static String MANA = "MANA";
public static String ID = "ID";
public static String CUSTOM_ABILITY = "CUSTOM_ABILITY";
public static String DROP_RATE = "DROP_RATE";
public static String ITEM_CLASS = "ITEM_CLASS";
public static String ITEM_TYPE = "ITEM_TYPE";
}

60
src/main/java/me/unurled/raxen/components/items/abilities/weapon/ThrowingDagger.java
View file

@ -12,40 +12,40 @@ import org.bukkit.util.Vector;
public class ThrowingDagger {
Player player;
ItemStack item;
Location start;
Player player;
ItemStack item;
Location start;
public ThrowingDagger(Player p) {
this.player = p;
this.item = p.getActiveItem();
this.start = p.getLocation();
}
public void throwDagger() {
// ability throw a dagger in the direction the player is looking, max 20 blocks
RayTrace rayTrace = new RayTrace(
player.getEyeLocation().toVector(),
player.getEyeLocation().getDirection()
);
ArrayList<Vector> positions = rayTrace.traverse(10, 0.01);
for (int i = 0; i < positions.size(); i++) {
Location position = positions.get(i).toLocation(player.getWorld());
Block block = player.getWorld().getBlockAt(position);
if (
block != null &&
block.getType() != Material.AIR &&
rayTrace.intersects(BoundingBox.of(block), 10, 0.01)
) {
player.sendMessage(block.getType().toString());
break;
}
public ThrowingDagger(Player p) {
this.player = p;
this.item = p.getActiveItem();
this.start = p.getLocation();
}
/*for (int i = 0 ; i < 20 ; i++) {
public void throwDagger() {
// ability throw a dagger in the direction the player is looking, max 20 blocks
RayTrace rayTrace = new RayTrace(
player.getEyeLocation().toVector(),
player.getEyeLocation().getDirection()
);
ArrayList<Vector> positions = rayTrace.traverse(10, 0.01);
for (int i = 0; i < positions.size(); i++) {
Location position = positions.get(i).toLocation(player.getWorld());
Block block = player.getWorld().getBlockAt(position);
if (
block != null &&
block.getType() != Material.AIR &&
rayTrace.intersects(BoundingBox.of(block), 10, 0.01)
) {
player.sendMessage(block.getType().toString());
break;
}
}
/*for (int i = 0 ; i < 20 ; i++) {
// spawn an item in air
// dispawn the last one
// repeat
}*/
}
}
}

33
src/main/java/me/unurled/raxen/components/items/custom/Item.java
View file

@ -7,25 +7,26 @@ import org.jetbrains.annotations.NotNull;
public abstract class Item {
@Getter
ItemStack item;
@Getter
ItemStack item;
String NAME;
String ID;
String NAME;
String ID;
ItemClass ITEM_CLASS;
ItemTypes ITEM_TYPES;
ItemClass ITEM_CLASS;
ItemTypes ITEM_TYPES;
protected Item() {
this.item = buildItem();
}
protected Item() {
this.item = buildItem();
}
public abstract ItemStack buildItem();
public abstract ItemStack buildItem();
/**
* need item to be set before calling this method.
*/
public void registerItem(@NotNull Raxen main) {
main.getManager().getItemManager().registerItem(item);
}
/**
* need item to be set before calling this method.
*/
public void registerItem(@NotNull Raxen main) {
item = buildItem();
main.getManager().getItemManager().registerItem(item);
}
}

24
src/main/java/me/unurled/raxen/components/items/custom/ItemClass.java
View file

@ -1,16 +1,16 @@
package me.unurled.raxen.components.items.custom;
public enum ItemClass {
F,
E,
D,
C,
B,
A,
S,
SS,
SSS,
MYTHIC,
UNIC,
GOD,
F,
E,
D,
C,
B,
A,
S,
SS,
SSS,
MYTHIC,
UNIC,
GOD
}

14
src/main/java/me/unurled/raxen/components/items/custom/ItemTypes.java
View file

@ -1,11 +1,11 @@
package me.unurled.raxen.components.items.custom;
public enum ItemTypes {
WEAPON,
BOW,
TOOLS,
MEDICINE,
ARMOR,
BLOCKS,
MISCELLANEOUS,
WEAPON,
BOW,
TOOLS,
MEDICINE,
ARMOR,
BLOCKS,
MISCELLANEOUS
}

26
src/main/java/me/unurled/raxen/components/items/custom/List.java
View file

@ -3,23 +3,25 @@ package me.unurled.raxen.components.items.custom;
import java.util.ArrayList;
import lombok.Getter;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.items.custom.weapon.CombatKnife;
import me.unurled.raxen.components.items.custom.weapon.Dagger;
public class List {
private static Raxen main;
private static Raxen main;
@Getter
private java.util.List<Item> items;
@Getter
private java.util.List<Item> items;
public List(Raxen main) {
this.main = main;
this.items = new ArrayList<>();
build();
}
public List(Raxen main) {
this.main = main;
this.items = new ArrayList<>();
build();
}
public void build() {
// weapons
items.add(new Dagger());
}
public void build() {
// weapons
items.add(new Dagger());
items.add(new CombatKnife());
}
}

56
src/main/java/me/unurled/raxen/components/items/custom/weapon/CombatKnife.java Normal file
View file

@ -0,0 +1,56 @@
package me.unurled.raxen.components.items.custom.weapon;
import static me.unurled.raxen.utils.Utils.colorTextComp;
import de.tr7zw.nbtapi.NBT;
import java.util.ArrayList;
import java.util.List;
import lombok.Getter;
import me.unurled.raxen.components.items.NBTNames;
import me.unurled.raxen.components.items.custom.Item;
import me.unurled.raxen.components.items.custom.ItemClass;
import me.unurled.raxen.components.items.custom.ItemTypes;
import net.kyori.adventure.text.Component;
import org.bukkit.Material;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
public class CombatKnife extends Item {
@Getter
ItemStack item;
static final String NAME = "Combat Knife";
static final String ID = "COMBAT_KNIFE";
static final ItemClass ITEM_CLASS = ItemClass.F;
static final ItemTypes ITEM_TYPES = ItemTypes.WEAPON;
public ItemStack buildItem() {
item = new ItemStack(Material.IRON_SWORD);
ItemMeta itm = item.getItemMeta();
itm.displayName(colorTextComp("<aqua>" + NAME));
itm.addItemFlags(ItemFlag.HIDE_ATTRIBUTES);
itm.setUnbreakable(true);
List<Component> lore = new ArrayList<>();
lore.add(
colorTextComp(
"<grey>A simple combat knife with a serrated edge.</grey>"
)
);
itm.setCustomModelData(1);
itm.lore(lore);
item.setItemMeta(itm);
NBT.modify(
item,
nbt -> {
nbt.setString(NBTNames.ID, ID);
nbt.setString(NBTNames.ITEM_TYPE, ITEM_TYPES.toString());
nbt.setString(NBTNames.ITEM_CLASS, ITEM_CLASS.toString());
nbt.setInteger(NBTNames.STRENGTH, 20);
}
);
return item;
}
}

54
src/main/java/me/unurled/raxen/components/items/custom/weapon/Dagger.java
View file

@ -6,7 +6,7 @@ import de.tr7zw.nbtapi.NBTItem;
import java.util.ArrayList;
import java.util.List;
import lombok.Getter;
import me.unurled.raxen.components.items.NBT;
import me.unurled.raxen.components.items.NBTNames;
import me.unurled.raxen.components.items.custom.Item;
import me.unurled.raxen.components.items.custom.ItemClass;
import me.unurled.raxen.components.items.custom.ItemTypes;
@ -19,33 +19,33 @@ import org.bukkit.inventory.meta.ItemMeta;
public class Dagger extends Item {
@Getter
ItemStack item;
@Getter
ItemStack item;
String NAME = "Dager";
String ID = "DAGER";
static final String NAME = "Dager";
static final String ID = "DAGER";
ItemClass ITEM_CLASS = ItemClass.F;
ItemTypes ITEM_TYPES = ItemTypes.WEAPON;
static final ItemClass ITEM_CLASS = ItemClass.F;
static final ItemTypes ITEM_TYPES = ItemTypes.WEAPON;
public ItemStack buildItem() {
item = new ItemStack(Material.IRON_SWORD);
ItemMeta itm = item.getItemMeta();
itm.displayName(colorTextComp("<aqua>" + this.NAME));
itm.addEnchant(Enchantment.PROTECTION_ENVIRONMENTAL, 1, false);
itm.addItemFlags(ItemFlag.HIDE_ATTRIBUTES, ItemFlag.HIDE_ENCHANTS);
itm.setUnbreakable(true);
List<Component> lore = new ArrayList<>();
lore.add(Component.text("hallooo"));
itm.lore(lore);
item.setItemMeta(itm);
NBTItem nbti = new NBTItem(item);
nbti.setString(NBT.ID, ID);
nbti.setInteger(NBT.SPEED, 100);
nbti.setInteger(NBT.STRENGTH, 50);
nbti.setString(NBT.CUSTOM_ABILITY, "throwing_dager");
nbti.setDouble(NBT.DROP_RATE, 50.0);
item = nbti.getItem();
return item;
}
public ItemStack buildItem() {
item = new ItemStack(Material.IRON_SWORD);
ItemMeta itm = item.getItemMeta();
itm.displayName(colorTextComp("<aqua>" + NAME));
itm.addEnchant(Enchantment.PROTECTION_ENVIRONMENTAL, 1, false);
itm.addItemFlags(ItemFlag.HIDE_ATTRIBUTES, ItemFlag.HIDE_ENCHANTS);
itm.setUnbreakable(true);
List<Component> lore = new ArrayList<>();
lore.add(Component.text("hallooo"));
itm.lore(lore);
item.setItemMeta(itm);
NBTItem nbti = new NBTItem(item);
nbti.setString(NBTNames.ID, ID);
nbti.setInteger(NBTNames.SPEED, 100);
nbti.setInteger(NBTNames.STRENGTH, 50);
nbti.setString(NBTNames.CUSTOM_ABILITY, "throwing_dager");
nbti.setDouble(NBTNames.DROP_RATE, 50.0);
item = nbti.getItem();
return item;
}
}

20
src/main/java/me/unurled/raxen/components/lootchest/GUI.java
View file

@ -9,18 +9,18 @@ import org.bukkit.inventory.Inventory;
public class GUI {
@Getter
private static Inventory inv = Bukkit.createInventory(null, 54);
@Getter
private static Inventory inv = Bukkit.createInventory(null, 54);
private static PlayerManager playerManager;
private static PlayerManager playerManager;
public GUI(Raxen main) {
this.playerManager = main.getManager().getPlayerManager();
}
public GUI(Raxen main) {
this.playerManager = main.getManager().getPlayerManager();
}
public static Inventory addItems(Player player) {
Integer luck = playerManager.getLuck().get(player);
public static Inventory addItems(Player player) {
Integer luck = playerManager.getLuck().get(player);
return inv;
}
return inv;
}
}

53
src/main/java/me/unurled/raxen/components/lootchest/loots/CustomLoot.java
View file

@ -3,40 +3,43 @@ package me.unurled.raxen.components.lootchest.loots;
import de.tr7zw.nbtapi.NBTItem;
import java.util.HashMap;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.items.NBT;
import me.unurled.raxen.components.items.NBTNames;
import org.bukkit.Location;
import org.bukkit.inventory.ItemStack;
public class CustomLoot {
private Raxen main;
private Raxen main;
public HashMap<String, ItemStack> itlist;
public HashMap<String, ItemStack> itlist;
public ItemStack item;
public Double drop_rate;
public LootItem lootItem;
public String ID;
public ItemStack item;
public Double drop_rate;
public LootItem lootItem;
public String ID;
public LootItem getLootItem() {
return new LootItem(registerItem(), drop_rate);
}
public ItemStack registerItem() {
return itlist.get(ID);
}
public Double getDrop_rate() {
NBTItem nbti = new NBTItem(item);
if (nbti.hasTag(NBT.DROP_RATE)) {
return nbti.getDouble(NBT.DROP_RATE);
public LootItem getLootItem() {
return new LootItem(registerItem(), drop_rate);
}
return 0.0;
}
public void tryDropLoot(Location location) {
for (LootItem item : main.getManager().getLootManager().getLootTable()) {
item.tryDropItem(location);
public ItemStack registerItem() {
return itlist.get(ID);
}
public Double getDrop_rate() {
NBTItem nbti = new NBTItem(item);
if (nbti.hasTag(NBTNames.DROP_RATE)) {
return nbti.getDouble(NBTNames.DROP_RATE);
}
return 0.0;
}
public void tryDropLoot(Location location) {
for (LootItem item : main
.getManager()
.getLootManager()
.getLootTable()) {
item.tryDropItem(location);
}
}
}
}

32
src/main/java/me/unurled/raxen/components/lootchest/loots/LootItem.java
View file

@ -6,22 +6,22 @@ import org.bukkit.inventory.ItemStack;
public class LootItem {
private ItemStack item;
private int min = 1, max = 1;
private double dropRate;
private static Random randomiser = new Random();
private ItemStack item;
private int min = 1, max = 1;
private double dropRate;
private static Random randomiser = new Random();
public LootItem(ItemStack item, double dropRate) {
this.item = item;
this.dropRate = dropRate;
}
public LootItem(ItemStack item, double dropRate) {
this.item = item;
this.dropRate = dropRate;
}
public void tryDropItem(Location loc) {
if (Math.random() * 101 > dropRate) return;
int amount = randomiser.nextInt(max - min + 1) + min;
if (amount == 0) return;
ItemStack item = this.item.clone();
item.setAmount(amount);
loc.getWorld().dropItemNaturally(loc, item);
}
public void tryDropItem(Location loc) {
if (Math.random() * 101 > dropRate) return;
int amount = randomiser.nextInt(max - min + 1) + min;
if (amount == 0) return;
ItemStack item = this.item.clone();
item.setAmount(amount);
loc.getWorld().dropItemNaturally(loc, item);
}
}

14
src/main/java/me/unurled/raxen/components/lootchest/loots/test/TestSword.java
View file

@ -5,11 +5,11 @@ import me.unurled.raxen.components.lootchest.loots.CustomLoot;
public class TestSword extends CustomLoot {
public TestSword(Raxen main) {
this.itlist = main.getManager().getItemManager().getList();
this.ID = "BEST_NEW_ITEM";
this.drop_rate = getDrop_rate();
this.item = registerItem();
this.lootItem = getLootItem();
}
public TestSword(Raxen main) {
this.itlist = main.getManager().getItemManager().getList();
this.ID = "BEST_NEW_ITEM";
this.drop_rate = getDrop_rate();
this.item = registerItem();
this.lootItem = getLootItem();
}
}

233
src/main/java/me/unurled/raxen/components/party/Party.java Normal file
View file

@ -0,0 +1,233 @@
package me.unurled.raxen.components.party;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.UUID;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.player.RaxenPlayer;
import me.unurled.raxen.manager.entity.PartyManager;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.event.ClickEvent;
import net.kyori.adventure.text.event.ClickEvent.Action;
import net.kyori.adventure.text.format.TextColor;
import org.bukkit.Bukkit;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.scoreboard.Scoreboard;
public class Party {
Raxen main;
private static int ID = 1;
public int id = ID++;
private ArrayList<UUID> uuids = new ArrayList<UUID>();
private UUID leaderUUID;
private String leaderName;
private ArrayList<Player> cachedPlayer = new ArrayList<Player>();
private long lastPlayerUpdate = 0L;
private Scoreboard board;
private boolean lootShare = false;
private HashMap<String, Long> lastInv = new HashMap<String, Long>();
public Party(Raxen main, Player leader) {
this.main = main;
this.leaderUUID = leader.getUniqueId();
this.leaderName = leader.getName();
// IDEA: adds scoreboard
addPlayer(leader);
}
public void sendInvite(Player p, RaxenPlayer rx, Player inviter) {
if (rx.getParty() == this) {
inviter.sendMessage(PartyManager.PREFIX.append(
Component.text(p.getName() + " is already in the party!")));
return;
}
if (lastInv.containsKey(p.getName())) {
if (System.currentTimeMillis() - lastInv.get(p.getName()) < 15000) {
inviter.sendMessage(PartyManager.PREFIX.append(Component.text(p.getName()
+ " was invited to the party in the last 15 seconds. Please wait a bit before inviting them again.")
.color(
TextColor.color(255, 0, 0))));
return;
}
}
lastInv.put(p.getName(), System.currentTimeMillis());
p.playSound(p.getLocation(), Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 10.0F, 1.0F);
p.sendMessage(PartyManager.PREFIX.append(Component.text(
"You have been invited to join " + leaderName
+ "'s party. Type /party join to join the party.").color(
TextColor.color(0, 255, 0))));
p.sendMessage(
Component.text("Or click Here").color(TextColor.color(255, 255, 0)).clickEvent(
ClickEvent.clickEvent(Action.SUGGEST_COMMAND, "/party join")));
p.sendMessage(PartyManager.PREFIX.append(
Component.text("Type /party decline to decline the party invitation.").color(
TextColor.color(0, 255, 0))));
p.sendMessage(
Component.text("Or click Here").color(TextColor.color(255, 255, 0)).clickEvent(
ClickEvent.clickEvent(Action.SUGGEST_COMMAND, "/party decline")));
sendMessage(Component.text(
p.getName() + " has been invited to the party by " + inviter.getName() + "."));
}
public void addPlayer(Player p) {
if (isFull()) {
p.sendMessage(PartyManager.PREFIX.append(Component.text("This party is full!")));
sendMessage(Component.text(p.getName() + " tried to join the party, but it was full."));
return;
}
lastPlayerUpdate = 0;
uuids.add(p.getUniqueId());
RaxenPlayer rx = main.getManager().getPlayerManager()
.getRaxenPlayer(p);
if (rx != null) {
rx.setParty(this);
}
p.sendMessage(Component.text("You have joined " + leaderName + "'s the party."));
Component comp = Component.text("The party is composed of ");
for (Player p2 : getPlayers()) {
comp.append(Component.text(p2.getName() + ", "));
}
p.sendMessage(comp);
sendMessage(Component.text(p.getName() + " has joined the party."));
}
public void leavePlayer(UUID uuid, String name) {
if (uuid != null) {
return;
}
Player player = Bukkit.getPlayer(uuid);
if (leaderUUID != null && leaderUUID == uuid) {
sendMessage(Component.text(name + " has left the party."));
if (player != null && player.isOnline()) {
main.getManager()
.getPlayerManager().getRaxenPlayer(player).setParty(null);
}
uuids.remove(uuid);
lastPlayerUpdate = 0;
if (uuids.size() == 0) {
destroy();
} else {
for (int k = 0; k < uuids.size(); k++) {
UUID nu = uuids.get(k);
Player temp = Bukkit.getPlayer(nu);
if (temp != null && temp.isOnline()) {
sendMessage(Component.text(temp.getName() + " is now the party leader."));
leaderUUID = nu;
leaderName = temp.getName();
break;
}
}
}
} else {
if (player != null && player.isOnline()) {
sendMessage(Component.text(name + " has left the party."));
main.getManager()
.getPlayerManager().getRaxenPlayer(player).setParty(null);
}
uuids.remove(uuid);
lastPlayerUpdate = 0;
if (uuids.size() == 0) {
destroy();
}
}
}
public boolean isFull() {
if (this.uuids == null) {
return true;
}
return uuids.size() >= PartyManager.MAX_SIZE;
}
public double getXpMultiplier() {
int size = uuids.size();
if (size < 0) {
size = 0;
}
return switch (size) {
case 0, 1 -> 0.0;
case 2 -> 0.1;
case 3 -> 0.15;
case 4 -> 0.2;
default -> 0.25;
};
}
public void destroy() {
for (UUID uuid : uuids) {
if (main.getManager().getPlayerManager().getRaxenPlayer(uuid) != null) {
RaxenPlayer rx = main.getManager().getPlayerManager().getRaxenPlayer(uuid);
if (rx.getParty() != null && rx.getParty().equals(this)) {
rx.setParty(null);
}
}
cachedPlayer.clear();
cachedPlayer = null;
uuids.clear();
uuids = null;
leaderUUID = null;
leaderName = null;
board = null;
main.getManager().getPartyManager().getParties().remove(this);
}
}
public ArrayList<Player> getPlayers() {
if (System.currentTimeMillis() - lastPlayerUpdate > 5000) {
lastPlayerUpdate = System.currentTimeMillis();
cachedPlayer.clear();
ArrayList<UUID> toRemove = new ArrayList<UUID>();
for (UUID uuid : uuids) {
Player p = Bukkit.getPlayer(uuid);
if (p != null && p.isOnline()) {
cachedPlayer.add(p);
} else {
toRemove.add(uuid);
}
}
uuids.removeAll(toRemove);
return cachedPlayer;
} else {
for (int k = 0; k < cachedPlayer.size(); k++) {
Player p = cachedPlayer.get(k);
if (p == null || !p.isOnline()) {
cachedPlayer.remove(k);
k--;
if (k < 0) {
k = 0;
}
}
}
return cachedPlayer;
}
}
public void sendMessage(Player sender, Component comp) {
Component msg = PartyManager.PREFIX.append(
Component.text(sender.getName() + "<reset><white>: ")).append(comp);
// TODO: Filter words
for (Player p : getPlayers()) {
p.sendMessage(msg);
}
}
public void sendMessage(Component comp) {
Component msg = PartyManager.PREFIX.append(comp);
for (Player p : getPlayers()) {
p.sendMessage(msg);
p.playSound(p.getLocation(), Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 1, 1);
}
}
public boolean isLeader(Player p) {
return p.getName().equals(leaderName) && p.getUniqueId().equals(leaderUUID);
}
}

44
src/main/java/me/unurled/raxen/components/resourcepack/ResourcePack.java
View file

@ -8,28 +8,28 @@ import org.bukkit.scheduler.BukkitRunnable;
public class ResourcePack {
private Raxen main;
private FileConfiguration config;
private ResourcePackManager resourcePackManager;
private Raxen main;
private FileConfiguration config;
private ResourcePackManager resourcePackManager;
public ResourcePack(Raxen main, ResourcePackManager manager) {
this.main = main;
this.config = main.getConfig();
this.resourcePackManager = manager;
}
public void join(Player player) {
new BukkitRunnable() {
@Override
public void run() {
if (resourcePackManager.isUseRP()) {
player.setResourcePack(
config.getString("ressource_pack_url"),
config.getString("resource_pack_sha1")
);
}
}
public ResourcePack(Raxen main, ResourcePackManager manager) {
this.main = main;
this.config = main.getConfig();
this.resourcePackManager = manager;
}
public void join(Player player) {
new BukkitRunnable() {
@Override
public void run() {
if (resourcePackManager.isUseRP()) {
player.setResourcePack(
config.getString("ressource_pack_url"),
config.getString("resource_pack_sha1")
);
}
}
}
.runTaskLater(main, 2L);
}
.runTaskLater(main, 2L);
}
}

79
src/main/java/me/unurled/raxen/components/tutorial/Tutorial.java Normal file
View file

@ -0,0 +1,79 @@
package me.unurled.raxen.components.tutorial;
import static me.unurled.raxen.utils.Utils.colorTextComp;
import static me.unurled.raxen.utils.Utils.log;
import static me.unurled.raxen.utils.Utils.msgPlayer;
import lombok.Getter;
import me.filoghost.holographicdisplays.api.HolographicDisplaysAPI;
import me.filoghost.holographicdisplays.api.hologram.Hologram;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.player.RaxenPlayer;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
public class Tutorial {
@Getter
private double x;
@Getter
private double y;
@Getter
private double z;
@Getter
private int step = 0;
@Getter
private World world;
public Tutorial() {
this.step = 0;
}
public Tutorial(int step) {
this.step = step;
}
public Tutorial(int step, double x, double y, double z, World world) {
this.x = x;
this.y = y;
this.z = z;
this.step = step;
this.world = world;
}
public void startTutorial(Player player, Location loc) {
x = loc.getX();
y = loc.getY();
z = loc.getZ();
world = loc.getWorld();
Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
RaxenPlayer rxPlayer = main.getManager().getPlayerManager().getRaxenPlayer(player);
rxPlayer.setInTutorial(true);
step = 1;
player.addPotionEffect(PotionEffectType.BLINDNESS.createEffect(100, 10));
player.teleport(
new Location(world, 15.82, 74.00, 117.21, 899.21F, 0.90f));
msgPlayer(player, colorTextComp("<green>Welcome to the tutorial!"));
HolographicDisplaysAPI api = main.getManager().getLibsManager().getHolographicDisplay()
.getApi();
Hologram holo = api.createHologram(new Location(world, 15.5, 76.00, 112.5, 179.21f, 0.90f));
holo.getLines().appendText("Welcome to the tutorial!");
}
public void stopTutorial() {
log("needs to be implemented");
}
public void nextStep() {
log("needs to be implemented");
}
public void previousStep() {
log("needs to be implemented");
}
}

80
src/main/java/me/unurled/raxen/config/Config.java
View file

@ -3,7 +3,12 @@ package me.unurled.raxen.config;
import static me.unurled.raxen.utils.Utils.debug;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.ReadableByteChannel;
import lombok.Getter;
import me.unurled.raxen.Raxen;
import org.bukkit.configuration.InvalidConfigurationException;
@ -12,38 +17,55 @@ import org.bukkit.configuration.file.YamlConfiguration;
public class Config {
private Raxen main;
private Raxen main;
private File configFile;
private File configFile;
@Getter
private FileConfiguration config;
@Getter
private FileConfiguration config;
public Config(Raxen main) {
this.main = main;
this.config = main.getConfig();
this.init();
}
/**
* init method, saves config and everything
*/
public void init() {
FileConfiguration config = main.getConfig();
File configFile = new File(main.getDataFolder() + "/config.yml");
if (!(configFile.exists())) {
main.saveDefaultConfig();
public Config(Raxen main) {
this.main = main;
this.config = main.getConfig();
this.init();
}
FileConfiguration conf = new YamlConfiguration();
debug(main, config.getString("version"));
try {
conf.load(configFile);
} catch (IOException | InvalidConfigurationException e) {
e.printStackTrace();
/**
* init method, saves config and everything
*/
public void init() {
FileConfiguration config = main.getConfig();
File configFile = new File(main.getDataFolder() + "/config.yml");
if (!(configFile.exists())) {
main.saveDefaultConfig();
}
FileConfiguration conf = new YamlConfiguration();
debug(main, config.getString("version"));
try {
conf.load(configFile);
} catch (IOException | InvalidConfigurationException e) {
e.printStackTrace();
}
debug(main, conf.getString("version"));
if (!Raxen.getVersion().equals(config.getString("version"))) {
main.saveResource("config.yml", true);
}
if (new File(main.getDataFolder().toString() + "/schematics/").mkdir()) {
String url = "https://pb.unurled.me/file/otter-panda-cobra/template_tuto.schem";
ReadableByteChannel readableByteChannel = null;
try {
readableByteChannel = Channels.newChannel(new URL(url).openStream());
FileOutputStream fileOutputStream = new FileOutputStream(
main.getDataFolder() + "schematics/template_tuto.schem");
FileChannel fileChannel = fileOutputStream.getChannel();
fileOutputStream.getChannel()
.transferFrom(readableByteChannel, 0, Long.MAX_VALUE);
} catch (IOException e) {
// throw new RuntimeException(e);
}
// main.saveResource("schematics/template_tuto.schem", false);
}
;
}
debug(main, conf.getString("version"));
if (!Raxen.getVersion().equals(config.getString("version"))) {
main.saveResource("config.yml", true);
}
}
}

74
src/main/java/me/unurled/raxen/config/ItemConfig.java Normal file
View file

@ -0,0 +1,74 @@
package me.unurled.raxen.config;
import java.io.File;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.effect.EffectBuilder;
import me.unurled.raxen.components.items.ItemBuilder;
import me.unurled.raxen.components.items.ItemParser;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
public class ItemConfig {
private File itemsFolder;
private Raxen main;
public ItemConfig(Raxen main) {
this.main = main;
}
public boolean validatesConfig() {
itemsFolder = new File(main.getDataFolder(), "items");
if (!itemsFolder.exists()) {
itemsFolder.mkdirs();
}
return true;
}
public Map<File, Map<String, ItemBuilder>> parseItemConfigs() {
Map<File, Map<String, ItemBuilder>> parseMap = new LinkedHashMap<>();
List<File> config = Arrays.stream(getItemsFiles())
.filter(file -> file.getName().endsWith(".yml")).toList();
for (File file : config) {
parseMap.put(file, parseItemConfig(YamlConfiguration.loadConfiguration(file), file));
}
return parseMap;
}
public Map<String, ItemBuilder> parseItemConfig(YamlConfiguration config, File file) {
Map<String, ItemParser> parseMap = new LinkedHashMap<>();
for (String itemSelection : config.getKeys(false)) {
if (!config.isConfigurationSection(itemSelection)) {
continue;
}
ConfigurationSection itemSection = config.getConfigurationSection(itemSelection);
parseMap.put(itemSelection, new ItemParser(itemSection));
}
boolean configUpdated = false;
Map<String, ItemBuilder> map = new LinkedHashMap<>();
for (Map.Entry<String, ItemParser> entry : parseMap.entrySet()) {
ItemParser parser = entry.getValue();
try {
map.put(entry.getKey(), parser.buildItem());
} catch (Exception e) {
e.printStackTrace();
}
}
return map;
}
public Map<File, Map<String, EffectBuilder>> parseEffectConfig() {
// TODO: efffects
}
private File[] getItemsFiles() {
File[] itemConfigs = Arrays.stream(itemsFolder.listFiles()).filter(File::isFile)
.toArray(File[]::new);
Arrays.sort(itemConfigs);
return itemConfigs;
}
}

688
src/main/java/me/unurled/raxen/config/PlayerConfig.java
View file

@ -1,6 +1,8 @@
package me.unurled.raxen.config;
import static me.unurled.raxen.utils.Items.*;
import static me.unurled.raxen.utils.Items.listItemStackDeserialize;
import static me.unurled.raxen.utils.Items.mapItemStackDeserialize;
import static me.unurled.raxen.utils.Items.setItemsToInventory;
import static me.unurled.raxen.utils.Utils.debug;
import com.mongodb.client.MongoCollection;
@ -16,6 +18,7 @@ import me.unurled.raxen.components.entity.player.PlayerUtils;
import me.unurled.raxen.components.entity.player.Storage;
import me.unurled.raxen.components.entity.player.attributes.Attributes;
import me.unurled.raxen.components.entity.player.storages.EnderChest;
import me.unurled.raxen.components.tutorial.Tutorial;
import me.unurled.raxen.manager.entity.PlayerManager;
import me.unurled.raxen.manager.entity.StorageManager;
import me.unurled.raxen.utils.Items;
@ -35,342 +38,371 @@ import org.jetbrains.annotations.NotNull;
public class PlayerConfig {
private static Raxen main;
private MongoDB mongoDB;
private MongoCollection<Document> mongoCollection;
private static PlayerManager playerManager;
private static StorageManager sto;
private Attributes attributes;
private static Raxen main;
private MongoDB mongoDB;
private MongoCollection<Document> mongoCollection;
private static PlayerManager playerManager;
private static StorageManager sto;
private Attributes attributes;
public PlayerConfig(Raxen main) {
this.main = main;
sto = main.getManager().getStorageManager();
this.mongoDB = main.getManager().getLibsManager().getMongoDB();
this.mongoCollection = mongoDB.getMongoCollection();
playerManager = main.getManager().getPlayerManager();
this.attributes = new Attributes(main);
}
/**
* closes mongo connection
*/
public void close() {
mongoDB.close();
}
/**
* save players stuff to mongo db
* @param player
* @param attributes
* @param invstr
* @param reverse
*/
public void saveUsingMongoDB(
@NotNull Player player,
Attributes attributes,
String invstr,
Integer reverse
) {
debug(main, "Saving " + player.getName() + "'s data!");
Document doc = new Document("uuid", player.getUniqueId().toString())
.append("name", player.getName())
.append("inv", invstr);
HashMap<String, Attribute> attribute = main
.getManager()
.getPlayerManager()
.getAttribute();
for (String s : attribute.keySet()) {
debug("saving " + s);
doc.append(s, attribute.get(s).get(player));
public PlayerConfig(Raxen main) {
this.main = main;
sto = main.getManager().getStorageManager();
this.mongoDB = main.getManager().getLibsManager().getMongoDB();
this.mongoCollection = mongoDB.getMongoCollection();
playerManager = main.getManager().getPlayerManager();
this.attributes = new Attributes(main);
}
if (playerManager.getRaxenPlayer(player).getStorage() != null) {
if (playerManager.getRaxenPlayer(player).getStorage().getEc() != null) {
debug(main, "Saving " + player.getName() + "'s storage!");
EnderChest ec = playerManager
.getRaxenPlayer(player)
.getStorage()
.getEc();
List<String> list = new ArrayList<String>();
reverse = 0;
for (ItemStack it : ec.getEc()) {
if (it != null && it.getType() != Material.AIR) {
String s = Items.itemStackSerialize(it, reverse);
list.add(s);
}
reverse += 1;
/**
* closes mongo connection
*/
public void close() {
mongoDB.close();
}
/**
* save players stuff to mongo db
*
* @param player
* @param attributes
* @param invstr
* @param reverse
*/
public void saveUsingMongoDB(
@NotNull Player player,
Attributes attributes,
String invstr,
Integer reverse
) {
debug(main, "Saving " + player.getName() + "'s data!");
Document doc = new Document("uuid", player.getUniqueId().toString())
.append("name", player.getName())
.append("inv", invstr);
HashMap<String, Attribute> attribute = main
.getManager()
.getPlayerManager()
.getAttribute();
for (String s : attribute.keySet()) {
debug("saving " + s);
doc.append(s, attribute.get(s).get(player));
}
String ecstr = Items.listItemStackSerialize(list);
doc.append("ec", ecstr);
}
}
Document playerDoc = mongoCollection
.find(Filters.eq("uuid", player.getUniqueId().toString()))
.first();
if (playerDoc == null) {
mongoCollection.insertOne(doc);
debug(main, "insert one");
} else {
mongoCollection.replaceOne(
Filters.eq("uuid", player.getUniqueId().toString()),
doc
);
debug(main, "replace one");
}
}
/**
* save players stuff to yml
* @param player
* @param attributes
* @param invstr
* @param reverse
*/
public void saveUsingYml(
Player player,
Attributes attributes,
String invstr,
Integer reverse
) {
FileConfiguration config = sto.createYml(player);
config.set("name", player.getName());
HashMap<String, Attribute> attribute = main
.getManager()
.getPlayerManager()
.getAttribute();
for (String s : attribute.keySet()) {
config.set(s, attribute.get(s).get(player));
}
config.set("inv", invstr);
if (playerManager.getRaxenPlayer(player).getStorage() != null) {
if (playerManager.getRaxenPlayer(player).getStorage().getEc() != null) {
EnderChest ec = playerManager
.getRaxenPlayer(player)
.getStorage()
.getEc();
List<String> list = new ArrayList<String>();
reverse = 0;
for (ItemStack it : ec.getEc()) {
reverse += 1;
if (it != null) {
String s = Items.itemStackSerialize(it, reverse);
list.add(s);
}
if (playerManager.getRaxenPlayer(player).getStorage() != null) {
if (
playerManager.getRaxenPlayer(player).getStorage().getEc() !=
null
) {
debug(main, "Saving " + player.getName() + "'s storage!");
EnderChest ec = playerManager
.getRaxenPlayer(player)
.getStorage()
.getEc();
List<String> list = new ArrayList<String>();
reverse = 0;
for (ItemStack it : ec.getEc()) {
if (it != null && it.getType() != Material.AIR) {
String s = Items.itemStackSerialize(it, reverse);
list.add(s);
}
reverse += 1;
}
String ecstr = Items.listItemStackSerialize(list);
doc.append("ec", ecstr);
}
}
String ecstr = Items.listItemStackSerialize(list);
config.set("ec", ecstr);
}
}
try {
config.save(
main.getDataFolder() +
"/playerInfo/" +
player.getUniqueId() +
"/" +
"playerInfo.yml"
);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* load player stuff from mongo db
* @param player
*/
public void loadUsingMongoDB(@NotNull Player player) {
Document playerDoc = mongoCollection
.find(Filters.eq("uuid", player.getUniqueId().toString()))
.first();
if (playerDoc == null) {
debug(main, "Intiatilising Data for Player: " + player.getName());
playerManager.getRaxenPlayer(player).createNewAttribute();
playerManager.getRaxenPlayer(player).createStorage();
playerManager.getRaxenPlayer(player).createInventory();
PlayerUtils.updateSkills(main, player);
return;
}
debug(main, "Loading " + player.getName() + "'s data!");
attributes.setAttributes(
player,
playerDoc.getInteger("MAX_HEALTH"),
playerDoc.getInteger("HEALTH"),
playerDoc.getInteger("ITEM_HEALTH"),
playerDoc.getInteger("DEFENSE"),
playerDoc.getInteger("ITEM_DEFENSE"),
playerDoc.getInteger("SPEED"),
playerDoc.getInteger("ITEM_SPEED"),
playerDoc.getInteger("STRENGTH"),
playerDoc.getInteger("ITEM_STRENGTH"),
playerDoc.getInteger("MAX_MANA"),
playerDoc.getInteger("MANA"),
playerDoc.getInteger("ITEM_MANA"),
playerDoc.getInteger("LUCK"),
playerDoc.getInteger("ITEM_LUCK")
);
Inventory ec = Bukkit.createInventory(
null,
54,
Component.text("Ender Chest")
);
if (playerDoc.getString("ec") != null) {
debug(main, "Loading " + player.getName() + "'s storage.");
ec =
setItemsToInventory(
mapItemStackDeserialize(playerDoc.getString("ec")),
ec
);
}
playerManager.getRaxenPlayer(player).setStorage(ec);
PlayerInventory inv = player.getInventory();
inv =
setItemsToInventory(
listItemStackDeserialize(playerDoc.getString("inv")),
inv
);
player.getInventory().setContents(inv.getContents());
player.updateInventory();
me.unurled.raxen.components.entity.player.storages.Inventory invv =
new me.unurled.raxen.components.entity.player.storages.Inventory(inv);
Inventories invvv = new Inventories(invv);
playerManager.getRaxenPlayer(player).setInventory(inv);
PlayerUtils.updateSkills(main, player);
}
/**
* load player stuff from yml
* @param player
* @throws IOException
*/
public void loadUsingYml(Player player) throws IOException {
FileConfiguration config = sto.createYml(player);
attributes.setAttributes(
player,
config.getInt("maxHealth"),
config.getInt("health"),
config.getInt("itemHealth"),
config.getInt("defense"),
config.getInt("itemDefense"),
config.getInt("speed"),
config.getInt("itemSpeed"),
config.getInt("strength"),
config.getInt("itemStrength"),
config.getInt("maxMana"),
config.getInt("mana"),
config.getInt("itemMana"),
config.getInt("luck"),
config.getInt("itemLuck")
);
Inventory ec = Bukkit.createInventory(
null,
54,
Component.text("Ender Chest")
);
if ((String) config.get("ec") != null) {
ec =
setItemsToInventory(
mapItemStackDeserialize((String) config.get("ec")),
ec
);
}
EnderChest ecc = new EnderChest(ec);
Storage storage = new Storage(ecc);
playerManager.getRaxenPlayer(player).setStorage(ec);
PlayerInventory inv = (PlayerInventory) Bukkit.createInventory(
player,
InventoryType.PLAYER
);
inv =
setItemsToInventory(
listItemStackDeserialize((String) config.getString("inv")),
inv
);
player.getInventory().setContents(inv.getContents());
player.updateInventory();
me.unurled.raxen.components.entity.player.storages.Inventory invv =
new me.unurled.raxen.components.entity.player.storages.Inventory(inv);
Inventories invvv = new Inventories(invv);
playerManager.getRaxenPlayer(player).setInventory(inv);
}
/**
* saves player stuff
* @param player
*/
public void savePlayerConfig(@NotNull Player player) {
Attributes attributes = new Attributes(main);
PlayerInventory inv = player.getInventory();
List<String> listInv = new ArrayList<String>();
Integer reverse = 0;
for (ItemStack it : inv) {
reverse = reverse + 1;
if (it != null && it.getType() != Material.AIR) {
String s = Items.itemStackSerialize(it, reverse);
listInv.add(s);
}
}
String invstr = Items.itemStackSer(inv);
debug(main, "saving...");
String storage = sto.getConfig().getString("storage");
Integer finalReverse = reverse;
String finalInvstr = invstr;
new BukkitRunnable() {
@Override
public void run() {
saveUsingMongoDB(player, attributes, finalInvstr, finalReverse);
}
}
.runTaskAsynchronously(main);
debug(main, "using mongo");
if (storage == "MYSQL" || storage == "YML") {
String finalInvstr1 = invstr;
Integer finalReverse1 = reverse;
new BukkitRunnable() {
@Override
public void run() {
saveUsingYml(player, attributes, finalInvstr1, finalReverse1);
Document playerDoc = mongoCollection
.find(Filters.eq("uuid", player.getUniqueId().toString()))
.first();
if (playerDoc == null) {
mongoCollection.insertOne(doc);
debug(main, "insert one");
} else {
mongoCollection.replaceOne(
Filters.eq("uuid", player.getUniqueId().toString()),
doc
);
debug(main, "replace one");
}
}
.runTaskAsynchronously(main);
debug(main, "using yml");
}
debug(main, "Player: " + player.getName() + " data successfully saved!");
}
/**
* load player stuff
* @param player
*/
public void loadPlayerConfig(Player player) {
String st = StorageManager.getConfig().getString("storage");
String value = "";
if (st.equals("MONGODB")) {
new BukkitRunnable() {
@Override
public void run() {
loadUsingMongoDB(player);
/**
* save players stuff to yml
*
* @param player
* @param attributes
* @param invstr
* @param reverse
*/
public void saveUsingYml(
Player player,
Attributes attributes,
String invstr,
Integer reverse
) {
FileConfiguration config = sto.createYml(player);
config.set("name", player.getName());
HashMap<String, Attribute> attribute = main
.getManager()
.getPlayerManager()
.getAttribute();
for (String s : attribute.keySet()) {
config.set(s, attribute.get(s).get(player));
}
}
.runTaskAsynchronously(main);
value = "mongodb";
} else {
value = "yml";
new BukkitRunnable() {
@Override
public void run() {
try {
loadUsingYml(player);
} catch (IOException e) {
config.set("inv", invstr);
if (playerManager.getRaxenPlayer(player).getStorage() != null) {
if (
playerManager.getRaxenPlayer(player).getStorage().getEc() !=
null
) {
EnderChest ec = playerManager
.getRaxenPlayer(player)
.getStorage()
.getEc();
List<String> list = new ArrayList<String>();
reverse = 0;
for (ItemStack it : ec.getEc()) {
reverse += 1;
if (it != null) {
String s = Items.itemStackSerialize(it, reverse);
list.add(s);
}
}
String ecstr = Items.listItemStackSerialize(list);
config.set("ec", ecstr);
}
}
try {
config.save(
main.getDataFolder() +
"/playerInfo/" +
player.getUniqueId() +
"/" +
"playerInfo.yml"
);
} catch (IOException e) {
e.printStackTrace();
}
}
}
.runTaskAsynchronously(main);
}
debug(
main,
"Player: " + player.getName() + " data successfully loaded using " + value
);
}
/**
* load player stuff from mongo db
*
* @param player
*/
public void loadUsingMongoDB(@NotNull Player player) {
Document playerDoc = mongoCollection
.find(Filters.eq("uuid", player.getUniqueId().toString()))
.first();
if (playerDoc == null) {
debug(main, "Intiatilising Data for Player: " + player.getName());
Tutorial tutorial = new Tutorial();
main.getManager().getTutorialManager().addTutorial(player, tutorial);
playerManager.getRaxenPlayer(player).createNewAttribute();
playerManager.getRaxenPlayer(player).createStorage();
playerManager.getRaxenPlayer(player).createInventory();
PlayerUtils.updateSkills(main, player);
return;
}
debug(main, "Loading " + player.getName() + "'s data!");
attributes.setAttributes(
player,
playerDoc.getInteger("MAX_HEALTH"),
playerDoc.getInteger("HEALTH"),
playerDoc.getInteger("ITEM_HEALTH"),
playerDoc.getInteger("DEFENSE"),
playerDoc.getInteger("ITEM_DEFENSE"),
playerDoc.getInteger("SPEED"),
playerDoc.getInteger("ITEM_SPEED"),
playerDoc.getInteger("STRENGTH"),
playerDoc.getInteger("ITEM_STRENGTH"),
playerDoc.getInteger("MAX_MANA"),
playerDoc.getInteger("MANA"),
playerDoc.getInteger("ITEM_MANA"),
playerDoc.getInteger("LUCK"),
playerDoc.getInteger("ITEM_LUCK")
);
Inventory ec = Bukkit.createInventory(
null,
54,
Component.text("Ender Chest")
);
if (playerDoc.getString("ec") != null) {
debug(main, "Loading " + player.getName() + "'s storage.");
ec =
setItemsToInventory(
mapItemStackDeserialize(playerDoc.getString("ec")),
ec
);
}
playerManager.getRaxenPlayer(player).setStorage(ec);
PlayerInventory inv = player.getInventory();
inv =
setItemsToInventory(
listItemStackDeserialize(playerDoc.getString("inv")),
inv
);
player.getInventory().setContents(inv.getContents());
player.updateInventory();
me.unurled.raxen.components.entity.player.storages.Inventory invv =
new me.unurled.raxen.components.entity.player.storages.Inventory(
inv
);
Inventories invvv = new Inventories(invv);
playerManager.getRaxenPlayer(player).setInventory(inv);
PlayerUtils.updateSkills(main, player);
}
/**
* load player stuff from yml
*
* @param player
* @throws IOException
*/
public void loadUsingYml(Player player) throws IOException {
FileConfiguration config = sto.createYml(player);
attributes.setAttributes(
player,
config.getInt("maxHealth"),
config.getInt("health"),
config.getInt("itemHealth"),
config.getInt("defense"),
config.getInt("itemDefense"),
config.getInt("speed"),
config.getInt("itemSpeed"),
config.getInt("strength"),
config.getInt("itemStrength"),
config.getInt("maxMana"),
config.getInt("mana"),
config.getInt("itemMana"),
config.getInt("luck"),
config.getInt("itemLuck")
);
Inventory ec = Bukkit.createInventory(
null,
54,
Component.text("Ender Chest")
);
if ((String) config.get("ec") != null) {
ec =
setItemsToInventory(
mapItemStackDeserialize((String) config.get("ec")),
ec
);
}
EnderChest ecc = new EnderChest(ec);
Storage storage = new Storage(ecc);
playerManager.getRaxenPlayer(player).setStorage(ec);
PlayerInventory inv = (PlayerInventory) Bukkit.createInventory(
player,
InventoryType.PLAYER
);
inv =
setItemsToInventory(
listItemStackDeserialize((String) config.getString("inv")),
inv
);
player.getInventory().setContents(inv.getContents());
player.updateInventory();
me.unurled.raxen.components.entity.player.storages.Inventory invv =
new me.unurled.raxen.components.entity.player.storages.Inventory(
inv
);
Inventories invvv = new Inventories(invv);
playerManager.getRaxenPlayer(player).setInventory(inv);
}
/**
* saves player stuff
*
* @param player
*/
public void savePlayerConfig(@NotNull Player player) {
Attributes attributes = new Attributes(main);
PlayerInventory inv = player.getInventory();
List<String> listInv = new ArrayList<String>();
Integer reverse = 0;
for (ItemStack it : inv) {
reverse = reverse + 1;
if (it != null && it.getType() != Material.AIR) {
String s = Items.itemStackSerialize(it, reverse);
listInv.add(s);
}
}
String invstr = Items.itemStackSer(inv);
debug(main, "saving...");
String storage = sto.getConfig().getString("storage");
Integer finalReverse = reverse;
String finalInvstr = invstr;
new BukkitRunnable() {
@Override
public void run() {
saveUsingMongoDB(player, attributes, finalInvstr, finalReverse);
}
}
.runTaskAsynchronously(main);
debug(main, "using mongo");
if (storage == "MYSQL" || storage == "YML") {
String finalInvstr1 = invstr;
Integer finalReverse1 = reverse;
new BukkitRunnable() {
@Override
public void run() {
saveUsingYml(
player,
attributes,
finalInvstr1,
finalReverse1
);
}
}
.runTaskAsynchronously(main);
debug(main, "using yml");
}
debug(
main,
"Player: " + player.getName() + " data successfully saved!"
);
}
/**
* load player stuff
*
* @param player
*/
public void loadPlayerConfig(Player player) {
String st = StorageManager.getConfig().getString("storage");
String value = "";
if (st.equals("MONGODB")) {
new BukkitRunnable() {
@Override
public void run() {
loadUsingMongoDB(player);
}
}
.runTaskAsynchronously(main);
value = "mongodb";
} else {
value = "yml";
new BukkitRunnable() {
@Override
public void run() {
try {
loadUsingYml(player);
} catch (IOException e) {
e.printStackTrace();
}
}
}
.runTaskAsynchronously(main);
}
debug(
main,
"Player: " +
player.getName() +
" data successfully loaded using " +
value
);
}
}

99
src/main/java/me/unurled/raxen/config/TutorialConfig.java Normal file
View file

@ -0,0 +1,99 @@
package me.unurled.raxen.config;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Filters;
import java.util.Map.Entry;
import java.util.UUID;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.tutorial.Tutorial;
import me.unurled.raxen.manager.server.TutorialManager;
import me.unurled.raxen.utils.libs.MongoDB;
import org.bson.Document;
import org.bukkit.Location;
public class TutorialConfig {
private static Raxen main;
private MongoDB mongoDB;
private MongoCollection<Document> mongoCollection;
public TutorialConfig(Raxen main) {
this.main = main;
this.mongoDB = main.getManager().getLibsManager().getMongoDB();
this.mongoCollection = mongoDB.getMongoConfigs();
}
public void saveUsingMongoDB() {
TutorialManager manager = main.getManager().getTutorialManager();
Document doc = new Document();
Document loc = new Document();
for (Entry<UUID, Location> entry : manager.getLocations().entrySet()) {
Document location = new Document();
location.append("x", entry.getValue().getX());
location.append("y", entry.getValue().getY());
location.append("z", entry.getValue().getZ());
location.append("world", entry.getValue().getWorld().getName());
location.append("uuid", entry.getKey().toString());
loc.append("location", location);
}
doc.append("locations", loc);
Document tutorials = new Document();
for (Entry<UUID, Tutorial> entry : manager.getTutorials().entrySet()) {
Document tutorial = new Document();
tutorial.append("uuid", entry.getKey().toString());
tutorial.append("tutorial", entry.getValue().getStep());
tutorial.append("x", entry.getValue().getX());
tutorial.append("y", entry.getValue().getY());
tutorial.append("z", entry.getValue().getZ());
tutorial.append("world", entry.getValue().getWorld().getName());
tutorials.append(entry.getKey().toString(), tutorial);
}
doc.append("tutorials", tutorials);
Document find = mongoCollection.find(Filters.eq("tutorial", "tutorial")).first();
if (find == null) {
mongoCollection.insertOne(doc);
} else {
mongoCollection.replaceOne(find, doc);
}
}
public void loadUsingMongoDB() {
Document doc = mongoCollection.find(Filters.eq("tutorial", "tutorial")).first();
if (doc != null) {
TutorialManager manager = main.getManager().getTutorialManager();
Document loc = (Document) doc.get("locations");
for (Entry<String, Object> entry : loc.entrySet()) {
Document location = (Document) entry.getValue();
double x = location.getDouble("x");
double y = location.getDouble("y");
double z = location.getDouble("z");
String world = location.getString("world");
UUID uuid = UUID.fromString(location.getString("uuid"));
manager.getLocations()
.put(uuid, new Location(main.getServer().getWorld(world), x, y, z));
}
Document tutorials = (Document) doc.get("tutorials");
for (Entry<String, Object> entry : tutorials.entrySet()) {
Document tutorial = (Document) entry.getValue();
UUID uuid1 = UUID.fromString(tutorial.getString("uuid"));
double x = tutorial.getDouble("x");
double y = tutorial.getDouble("y");
double z = tutorial.getDouble("z");
String world = tutorial.getString("world");
int step = tutorial.getInteger("tutorial");
manager.getTutorials()
.put(uuid1, new Tutorial(step, x, y, z, main.getServer().getWorld(world)));
}
}
}
public void saveTutorialConfig() {
saveUsingMongoDB();
}
public void loadTutorialConfig() {
loadUsingMongoDB();
}
}

417
src/main/java/me/unurled/raxen/listener/entity/DamageEntity.java
View file

@ -5,167 +5,308 @@ import static me.unurled.raxen.utils.Utils.debug;
import java.util.Objects;
import me.unurled.raxen.Raxen;
import me.unurled.raxen.components.entity.other.EntityNamespacedKey;
import me.unurled.raxen.components.entity.other.MobData;
import me.unurled.raxen.components.entity.player.RaxenPlayer;
import me.unurled.raxen.manager.entity.PlayerManager;
import org.bukkit.Bukkit;
import org.bukkit.attribute.Attribute;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByBlockEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.metadata.Metadatable;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.persistence.PersistentDataType;
import org.bukkit.projectiles.ProjectileSource;
public class DamageEntity implements Listener {
private Raxen main;
private EntityNamespacedKey entityNamespacedKey;
private Raxen main;
private EntityNamespacedKey entityNamespacedKey;
public DamageEntity(Raxen main) {
this.main = main;
this.entityNamespacedKey = new EntityNamespacedKey(main);
}
public DamageEntity(Raxen main) {
this.main = main;
this.entityNamespacedKey = new EntityNamespacedKey(main);
}
/**
* fired when an entity is damaged by another entity
* calculates the damage and apply it to the entity
* @param e
*/
@EventHandler
public void entityDamageByEntity(EntityDamageByEntityEvent e) {
if (
!(e.getEntity() instanceof LivingEntity) ||
!(e.getDamager() instanceof LivingEntity)
) {
debug("Not Living Entity, Some block falling shit or block entities");
} else {
e.setDamage(0);
Integer damage = 1;
Integer strength = 0;
Integer itemStrength = 0;
Integer defense = 0;
Integer itemDefense = 0;
Integer health = 0;
Integer itemHealth = 0;
Integer initDamage = 0;
PlayerManager pm =
(
(Raxen) Objects.requireNonNull(
Bukkit.getPluginManager().getPlugin("Raxen")
)
).getManager()
.getPlayerManager();
debug(
main,
e.getEntity().getName(),
e.getEntity().getType().toString(),
e.getDamager().getType().toString(),
e.getDamager().getName()
);
if (e.getDamager() instanceof Player playerDamager) {
strength = pm.getStrength().get(playerDamager);
itemStrength = pm.getItemStrength().get(playerDamager);
} else {
Entity entityDamager = e.getDamager();
PersistentDataContainer data =
entityDamager.getPersistentDataContainer();
/**
* fired when an entity is damaged by something TODO: calculate damage and apply it to the
* entity
*
* @param e event
*/
@EventHandler
public void entityDamage(EntityDamageEvent e) {
e.setCancelled(true);
e.setDamage(0);
e.getEntity().setFireTicks(0);
if (e instanceof EntityDamageByEntityEvent) {
EntityDamageByEntityEvent ev2 = (EntityDamageByEntityEvent) e;
ev2.setCancelled(true);
Entity attacker = ev2.getDamager();
Entity defender = ev2.getEntity();
if (attacker instanceof Player) {
PlayerManager pm = main.getManager().getPlayerManager();
if (defender instanceof Player) {
// attack between players
RaxenPlayer rx = pm.getRaxenPlayer((Player) attacker);
RaxenPlayer rx2 = pm.getRaxenPlayer((Player) defender);
if (rx != null && rx2 != null) {
rx.attackPlayer(rx2);
}
} else {
// attack between player and mob
RaxenPlayer rx = pm.getRaxenPlayer((Player) attacker);
MobData re = main.getManager().getEntityManager().spawnedMob.get(
defender.getUniqueId());
if (rx != null) {
rx.attackMob(re);
}
}
} else if (attacker instanceof Projectile) {
boolean projectile = true;
ProjectileSource source = ((Projectile) attacker).getShooter();
double rpgKnockback = -1;
int rpgDamage = -1;
if (attacker != null) {
Metadatable sourceMeta = (Metadatable) attacker;
// TODO: check metadata
}
if (source == defender) {
attacker.remove();
return;
}
if (source instanceof Player) {
RaxenPlayer rx = main.getManager().getPlayerManager().getRaxenPlayer(
(Player) source);
if (defender instanceof Player) {
RaxenPlayer rx2 = main.getManager().getPlayerManager().getRaxenPlayer(
(Player) defender);
// range attack between players
if (rpgKnockback >= 0) {
rx.attackPlayer(rx2, rpgDamage, projectile, rpgKnockback);
} else {
rx.attackPlayer(rx2, rpgDamage, projectile);
}
} else {
MobData mb = main.getManager().getEntityManager().spawnedMob.get(
defender.getUniqueId());
if (rx != null && mb != null) {
if (rpgKnockback >= 0) {
rx.attackMob(mb, rpgKnockback, rpgDamage, projectile);
} else {
rx.attackMob(mb, rpgDamage, projectile);
}
}
// range attack between player and mob
}
} else {
if (defender instanceof Player) {
MobData a = main.getManager().getEntityManager().spawnedMob.get(
attacker.getUniqueId());
RaxenPlayer d = main.getManager().getPlayerManager().getRaxenPlayer(
(Player) defender);
if (a != null && d != null) {
a.attack(d, rpgDamage, projectile);
}
// range attack between mob and player
} else {
// range attack between mobs
}
}
attacker.remove();
} else {
if (defender instanceof Player) {
MobData a = main.getManager().getEntityManager().spawnedMob.get(
attacker.getUniqueId());
RaxenPlayer d = main.getManager().getPlayerManager().getRaxenPlayer(
(Player) defender);
if (a != null && d != null) {
a.attack(d);
}
// attack between mob and player
} else {
// attack between mobs
}
}
}
}
/**
* fired when an entity is damaged by another entity calculates the damage and apply it to the
* entity
*
* @param e
*/
@Deprecated
// @EventHandler
public void entityDamageByEntity(EntityDamageByEntityEvent e) {
if (
data.has(entityNamespacedKey.strength, PersistentDataType.INTEGER)
!(e.getEntity() instanceof LivingEntity) ||
!(e.getDamager() instanceof LivingEntity)
) {
strength =
data.get(entityNamespacedKey.strength, PersistentDataType.INTEGER);
}
itemStrength =
pm.getItemStrength().getItem((LivingEntity) entityDamager);
}
if (e.getEntity() instanceof Player playerVictim) {
me.unurled.raxen.components.entity.player.attributes.Attributes attributes =
new me.unurled.raxen.components.entity.player.attributes.Attributes(
main
);
defense = pm.getDefense().get(playerVictim);
health = pm.getHealth().get(playerVictim);
itemDefense = pm.getItemDefense().get(playerVictim);
itemHealth = pm.getItemHealth().get(playerVictim);
} else {
Entity entityVictim = e.getEntity();
PersistentDataContainer data =
entityVictim.getPersistentDataContainer();
if (data.has(entityNamespacedKey.defense, PersistentDataType.INTEGER)) {
defense =
data.get(entityNamespacedKey.defense, PersistentDataType.INTEGER);
}
if (data.has(entityNamespacedKey.health, PersistentDataType.INTEGER)) {
health =
data.get(entityNamespacedKey.health, PersistentDataType.INTEGER);
}
itemDefense = pm.getItemDefense().getItem((LivingEntity) entityVictim);
itemHealth = pm.getItemHealth().getItem((LivingEntity) entityVictim);
}
debug(
main,
initDamage.toString(),
itemDefense.toString(),
strength.toString()
);
initDamage = (5 + itemStrength) * (1 + (strength / 100));
damage = initDamage;
defense = defense + itemDefense;
debug(main, String.valueOf(damage));
defense = defense / (defense + 100);
debug(main, String.valueOf(damage));
debug(main, String.valueOf(defense));
Integer health_with_defense = health * (1 + (defense / 100));
debug(main, String.valueOf(damage));
debug(main, String.valueOf(health));
debug(main, String.valueOf(health_with_defense));
if (damage >= health_with_defense) {
debug(main, "Killed entity normally.");
e.setDamage(
Objects
.requireNonNull(
e
.getEntity()
.getType()
.getDefaultAttributes()
.getAttribute(Attribute.GENERIC_MAX_HEALTH)
)
.getDefaultValue()
);
} else {
debug(main, "Applying damage to entity.");
if (defense == 0) {
health = health_with_defense - damage;
} else {
health = health_with_defense - health - damage;
}
if (e.getEntity() instanceof Player playerVictim) {
me.unurled.raxen.components.entity.player.attributes.Attributes attributes =
new me.unurled.raxen.components.entity.player.attributes.Attributes(
main
debug(
"Not Living Entity, Some block falling shit or block entities"
);
pm.getHealth().set(playerVictim, health);
playerVictim.setHealth(health.doubleValue() / 5);
} else {
Entity entityVictim = e.getEntity();
pm.getHealth().set(entityVictim, health);
e.setCancelled(true);
e.setDamage(0);
Integer damage = 1;
Integer strength = 0;
Integer itemStrength = 0;
Integer defense = 0;
Integer itemDefense = 0;
Integer health = 0;
Integer itemHealth = 0;
Integer initDamage = 0;
PlayerManager pm =
(
(Raxen) Objects.requireNonNull(
Bukkit.getPluginManager().getPlugin("Raxen")
)
).getManager()
.getPlayerManager();
debug(
main,
e.getEntity().getName(),
e.getEntity().getType().toString(),
e.getDamager().getType().toString(),
e.getDamager().getName()
);
if (e.getDamager() instanceof Player playerDamager) {
strength = pm.getStrength().get(playerDamager);
itemStrength = pm.getItemStrength().get(playerDamager);
} else {
Entity entityDamager = e.getDamager();
PersistentDataContainer data =
entityDamager.getPersistentDataContainer();
if (
data.has(
entityNamespacedKey.strength,
PersistentDataType.INTEGER
)
) {
strength =
data.get(
entityNamespacedKey.strength,
PersistentDataType.INTEGER
);
}
itemStrength =
pm.getItemStrength().getItem((LivingEntity) entityDamager);
}
if (e.getEntity() instanceof Player playerVictim) {
me.unurled.raxen.components.entity.player.attributes.Attributes attributes =
new me.unurled.raxen.components.entity.player.attributes.Attributes(
main
);
defense = pm.getDefense().get(playerVictim);
health = pm.getHealth().get(playerVictim);
itemDefense = pm.getItemDefense().get(playerVictim);
itemHealth = pm.getItemHealth().get(playerVictim);
} else {
Entity entityVictim = e.getEntity();
PersistentDataContainer data =
entityVictim.getPersistentDataContainer();
if (
data.has(
entityNamespacedKey.defense,
PersistentDataType.INTEGER
)
) {
defense =
data.get(
entityNamespacedKey.defense,
PersistentDataType.INTEGER
);
}
if (
data.has(
entityNamespacedKey.health,
PersistentDataType.INTEGER
)
) {
health =
data.get(
entityNamespacedKey.health,
PersistentDataType.INTEGER
);
}
itemDefense =
pm.getItemDefense().getItem((LivingEntity) entityVictim);
itemHealth =
pm.getItemHealth().getItem((LivingEntity) entityVictim);
}
debug(
main,
initDamage.toString(),
itemDefense.toString(),
strength.toString()
);
initDamage = (5 + itemStrength) * (1 + (strength / 100));
damage = initDamage;
defense = defense + itemDefense;
debug(main, String.valueOf(damage));
defense = defense / (defense + 100);
debug(main, String.valueOf(damage));
debug(main, String.valueOf(defense));
Integer health_with_defense = health * (1 + (defense / 100));
debug(main, String.valueOf(damage));
debug(main, String.valueOf(health));
debug(main, String.valueOf(health_with_defense));
if (damage >= health_with_defense) {
debug(main, "Killed entity normally.");
e.setDamage(
Objects
.requireNonNull(
e
.getEntity()
.getType()
.getDefaultAttributes()
.getAttribute(Attribute.GENERIC_MAX_HEALTH)
)
.getDefaultValue()
);
} else {
debug(main, "Applying damage to entity.");
if (defense == 0) {
health = health_with_defense - damage;
} else {
health = health_with_defense - health - damage;
}
if (e.getEntity() instanceof Player playerVictim) {
me.unurled.raxen.components.entity.player.attributes.Attributes attributes =
new me.unurled.raxen.components.entity.player.attributes.Attributes(
main
);
pm.getHealth().set(playerVictim, health);
playerVictim.setHealth(health.doubleValue() / 5);
} else {
Entity entityVictim = e.getEntity();
pm.getHealth().set(entityVictim, health);
}
debug(main, health.toString());
}
}
debug(main, health.toString());
}
}
}
/**
* damage made by blocks on entity
* @param e
*/
@EventHandler
public void entityDamageByBlock(EntityDamageByBlockEvent e) {
e.setDamage(0);
if (e.getEntity() instanceof Player) {
Player player = (Player) e.getEntity();
/**
* damage made by blocks on entity
*
* @param e
*/
@Deprecated
// @EventHandler
public void entityDamageByBlock(EntityDamageByBlockEvent e) {
e.setDamage(0);
if (e.getEntity() instanceof Player) {
Player player = (Player) e.getEntity();
}
}
}
}

93
src/main/java/me/unurled/raxen/listener/entity/SpawnEvent.java
View file

@ -15,52 +15,53 @@ import org.bukkit.persistence.PersistentDataType;
public class SpawnEvent implements Listener {
private Raxen main;
private EntityUtils entityUtils;
private EntityNamespacedKey namespacedKey;
private Raxen main;
private EntityUtils entityUtils;
private EntityNamespacedKey namespacedKey;
public SpawnEvent(Raxen main) {
this.main = main;
this.entityUtils = new EntityUtils(main);
this.namespacedKey = new EntityNamespacedKey(main);
}
/**
* when a new entity spawns
* adds all persistent data container
* @param e
*/
@EventHandler
public void Spawn(EntitySpawnEvent e) {
if (e.getEntity() instanceof Player) {
//player stuff dont want to talk about it; already doing it in player join event
debug(main, "Player: " + ((Player) e.getEntity()).getName());
} else if (
e.getEntity().getType() != EntityType.DROPPED_ITEM &&
e.getEntity().getType() != EntityType.FALLING_BLOCK
) {
debug(main, e.getEntity().getName());
if (
!e
.getEntity()
.getPersistentDataContainer()
.has(namespacedKey.name, PersistentDataType.STRING)
) {
entityUtils.setNameSpacedKeys(
e.getEntity(),
e.getEntityType().name(),
1,
10,
0,
50,
0,
100,
0,
100,
0
);
}
entityUtils.updateSkills((LivingEntity) e.getEntity());
public SpawnEvent(Raxen main) {
this.main = main;
this.entityUtils = new EntityUtils(main);
this.namespacedKey = new EntityNamespacedKey(main);
}
/**
* when a new entity spawns
* adds all persistent data container
* @param e
*/
@EventHandler
public void Spawn(EntitySpawnEvent e) {
if (e.getEntity() instanceof Player) {
//player stuff dont want to talk about it; already doing it in player join event
debug(main, "Player: " + ((Player) e.getEntity()).getName());
} else if (
e.getEntity().getType() != EntityType.DROPPED_ITEM &&
e.getEntity().getType() != EntityType.FALLING_BLOCK &&
e.getEntity().getType() != EntityType.ARROW
) {
debug(main, e.getEntity().getName());
if (
!e
.getEntity()
.getPersistentDataContainer()
.has(namespacedKey.name, PersistentDataType.STRING)
) {
entityUtils.setNameSpacedKeys(
e.getEntity(),
e.getEntityType().name(),
1,
10,
0,
50,
0,
100,
0,
100,
0
);
}
entityUtils.updateSkills((LivingEntity) e.getEntity());
}
}
}
}

102
src/main/java/me/unurled/raxen/listener/player/ArmorEvent.java
View file

@ -16,56 +16,60 @@ import org.bukkit.inventory.ItemStack;
public class ArmorEvent implements Listener {
private Raxen main;
private Raxen main;
public ArmorEvent(Raxen main) {
this.main = main;
}
public ArmorEvent(Raxen main) {
this.main = main;
}
/**
* when player changes armor, calculates new stats for player and setting it
* @param e
*/
@EventHandler
public void ArmorChangeEvent(PlayerArmorChangeEvent e) {
Player player = e.getPlayer();
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
Entity entity = player;
Attributes attributes = new Attributes(main);
if (e.getOldItem() != null && e.getOldItem().getType() != Material.AIR) {
ItemStack oldItem = e.getOldItem();
NBTItem nbti = new NBTItem(oldItem);
if (nbti.hasTag("SPEED")) {
pm.getSpeed().remove(entity, nbti.getInteger("SPEED"));
}
if (nbti.hasTag("HEALTH")) {
pm.getHealth().remove(entity, nbti.getInteger("HEALTH"));
}
if (nbti.hasTag("DEFENSE")) {
pm.getDefense().remove(entity, nbti.getInteger("DEFENSE"));
}
if (nbti.hasTag("STRENGTH")) {
pm.getStrength().remove(entity, nbti.getInteger("STRENGTH"));
}
/**
* when player changes armor, calculates new stats for player and setting it
* @param e
*/
@EventHandler
public void ArmorChangeEvent(PlayerArmorChangeEvent e) {
Player player = e.getPlayer();
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
Entity entity = player;
Attributes attributes = new Attributes(main);
if (
e.getOldItem() != null && e.getOldItem().getType() != Material.AIR
) {
ItemStack oldItem = e.getOldItem();
NBTItem nbti = new NBTItem(oldItem);
if (nbti.hasTag("SPEED")) {
pm.getSpeed().remove(entity, nbti.getInteger("SPEED"));
}
if (nbti.hasTag("HEALTH")) {
pm.getHealth().remove(entity, nbti.getInteger("HEALTH"));
}
if (nbti.hasTag("DEFENSE")) {
pm.getDefense().remove(entity, nbti.getInteger("DEFENSE"));
}
if (nbti.hasTag("STRENGTH")) {
pm.getStrength().remove(entity, nbti.getInteger("STRENGTH"));
}
}
if (
e.getNewItem() != null && e.getNewItem().getType() != Material.AIR
) {
ItemStack newItem = e.getNewItem();
NBTItem nbti = new NBTItem(newItem);
if (nbti.hasTag("SPEED")) {
pm.getSpeed().add(entity, nbti.getInteger("SPEED"));
}
if (nbti.hasTag("HEALTH")) {
pm.getHealth().add(entity, nbti.getInteger("HEALTH"));
}
if (nbti.hasTag("DEFENSE")) {
pm.getDefense().add(entity, nbti.getInteger("DEFENSE"));
}
if (nbti.hasTag("STRENGTH")) {
pm.getStrength().add(entity, nbti.getInteger("STRENGTH"));
}
}
PlayerUtils.updateSkills(main, player);
}
if (e.getNewItem() != null && e.getNewItem().getType() != Material.AIR) {
ItemStack newItem = e.getNewItem();
NBTItem nbti = new NBTItem(newItem);
if (nbti.hasTag("SPEED")) {
pm.getSpeed().add(entity, nbti.getInteger("SPEED"));
}
if (nbti.hasTag("HEALTH")) {
pm.getHealth().add(entity, nbti.getInteger("HEALTH"));
}
if (nbti.hasTag("DEFENSE")) {
pm.getDefense().add(entity, nbti.getInteger("DEFENSE"));
}
if (nbti.hasTag("STRENGTH")) {
pm.getStrength().add(entity, nbti.getInteger("STRENGTH"));
}
}
PlayerUtils.updateSkills(main, player);
}
}

50
src/main/java/me/unurled/raxen/listener/player/ClickBlockEvent.java
View file

@ -13,31 +13,31 @@ import org.bukkit.inventory.Inventory;
public class ClickBlockEvent implements Listener {
private Raxen main;
private GUI gui;
private Raxen main;
private GUI gui;
public ClickBlockEvent(Raxen main) {
this.main = main;
this.gui = new GUI(main);
}
/**
* use with guis
* @param e
*/
@EventHandler
public void ClickEvent(PlayerInteractEvent e) {
Player player = e.getPlayer();
Block block = e.getClickedBlock();
Action action = e.getAction();
if (action.isRightClick()) {
if (block != null) {
if (block.getType() == Material.CHEST) {
player.closeInventory();
Inventory inv = gui.addItems(player);
player.openInventory(inv);
}
}
public ClickBlockEvent(Raxen main) {
this.main = main;
this.gui = new GUI(main);
}
/**
* use with guis
* @param e
*/
@EventHandler
public void ClickEvent(PlayerInteractEvent e) {
Player player = e.getPlayer();
Block block = e.getClickedBlock();
Action action = e.getAction();
if (action.isRightClick()) {
if (block != null) {
if (block.getType() == Material.CHEST) {
player.closeInventory();
Inventory inv = gui.addItems(player);
player.openInventory(inv);
}
}
}
}
}
}

34
src/main/java/me/unurled/raxen/listener/player/CloseInventoryEvent.java
View file

@ -13,22 +13,24 @@ import org.bukkit.event.inventory.InventoryCloseEvent;
public class CloseInventoryEvent implements Listener {
private PlayerManager playerManager;
private PlayerManager playerManager;
/**
* save enderchest/storage when player close
* @param e
*/
@EventHandler
public void InventoryCloseEvent(InventoryCloseEvent e) {
Player player = (Player) e.getPlayer();
Component title = e.getView().title();
if (title.toString().contains("Ender Chest")) {
playerManager =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
playerManager.getRaxenPlayer(player).setStorage(e.getInventory());
/**
* save enderchest/storage when player close
* @param e
*/
@EventHandler
public void InventoryCloseEvent(InventoryCloseEvent e) {
Player player = (Player) e.getPlayer();
Component title = e.getView().title();
if (title.toString().contains("Ender Chest")) {
playerManager =
(
(Raxen) Bukkit.getPluginManager().getPlugin("Raxen")
).getManager()
.getPlayerManager();
playerManager.getRaxenPlayer(player).setStorage(e.getInventory());
}
log(player.getName() + " " + title.toString());
}
log(player.getName() + " " + title.toString());
}
}

13
src/main/java/me/unurled/raxen/listener/player/FoodLevelEvent.java Normal file
View file

@ -0,0 +1,13 @@
package me.unurled.raxen.listener.player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.FoodLevelChangeEvent;
public class FoodLevelEvent implements Listener {
@EventHandler
public void FoodLevelChange(FoodLevelChangeEvent e) {
e.setFoodLevel(20);
}
}

24
src/main/java/me/unurled/raxen/listener/player/InteractEvent.java
View file

@ -1,5 +1,9 @@
package me.unurled.raxen.listener.player;
import static me.unurled.raxen.utils.Utils.debug;
import static me.unurled.raxen.utils.Utils.log;
import de.tr7zw.nbtapi.NBT;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
@ -9,11 +13,17 @@ import org.bukkit.inventory.ItemStack;
public class InteractEvent implements Listener {
@EventHandler
public void PlayerInteractEvent(PlayerInteractEvent e) {
// Player p = e.getPlayer();
// if (e.hasItem()) {
// ItemStack i = e.getItem();
// }
}
@EventHandler
public void PlayerInteractEvent(PlayerInteractEvent e) {
Player p = e.getPlayer();
if (e.hasItem()) {
ItemStack i = e.getItem();
if (i != null && i.getType() != Material.AIR) {
String id = NBT.get(i, nbt -> nbt.getString("ID"));
if (id != null && !id.isEmpty()) {
if (id.equals("PHONE")) {}
}
}
}
}
}

153
src/main/java/me/unurled/raxen/listener/player/ItemHandEvent.java
View file

@ -20,50 +20,61 @@ import org.bukkit.inventory.ItemStack;
public class ItemHandEvent implements Listener {
private Raxen main;
private Raxen main;
public ItemHandEvent(Raxen main) {
this.main = main;
}
public ItemHandEvent(Raxen main) {
this.main = main;
}
/**
* when player have something in hand, change and add new stats
* @param e
*/
@EventHandler
public void ItemHeldEvent(PlayerItemHeldEvent e) {
Player player = e.getPlayer();
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
Entity entity = player;
Attributes attributes = new Attributes(main);
ItemStack oldItem = player.getInventory().getItem(e.getPreviousSlot());
ItemStack newItem = player.getInventory().getItem(e.getNewSlot());
if (oldItem != null && oldItem.getType() != Material.AIR) {
NBTItem nbti = new NBTItem(oldItem);
for (String s : Attributes.getNameList()) {
if (nbti.hasTag(s.toUpperCase())) {
java.lang.reflect.Method method = null;
try {
method = pm.getClass().getMethod("getItem" + s);
} catch (SecurityException | NoSuchMethodException exception) {}
if (method != null) {
me.unurled.raxen.components.entity.Attributes.Attribute attribute =
null;
try {
attribute = (Attribute) method.invoke(pm, (Object) null);
} catch (
InvocationTargetException | IllegalAccessException ignored
) {}
if (attribute != null) {
attribute.remove(player, nbti.getInteger(s.toUpperCase()));
debug("removed " + s + " for player " + player.getName());
/**
* when player have something in hand, change and add new stats
* @param e
*/
@EventHandler
public void ItemHeldEvent(PlayerItemHeldEvent e) {
Player player = e.getPlayer();
PlayerManager pm =
((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager()
.getPlayerManager();
Entity entity = player;
Attributes attributes = new Attributes(main);
ItemStack oldItem = player.getInventory().getItem(e.getPreviousSlot());
ItemStack newItem = player.getInventory().getItem(e.getNewSlot());
if (oldItem != null && oldItem.getType() != Material.AIR) {
NBTItem nbti = new NBTItem(oldItem);
for (String s : Attributes.getNameList()) {
if (nbti.hasTag(s.toUpperCase())) {
java.lang.reflect.Method method = null;
try {
method = pm.getClass().getMethod("getItem" + s);
} catch (
SecurityException | NoSuchMethodException exception
) {}
if (method != null) {
me.unurled.raxen.components.entity.Attributes.Attribute attribute =
null;
try {
attribute = (Attribute) method.invoke(pm);
} catch (
InvocationTargetException
| IllegalAccessException ignored
) {}
if (attribute != null) {
attribute.remove(
player,
nbti.getInteger(s.toUpperCase())
);
debug(
"removed " +
s +
" for player " +
player.getName()
);
}
}
}
}
}
}
}
/*if(nbti.hasTag("SPEED")) {
/*if(nbti.hasTag("SPEED")) {
pm.getItemSpeed().remove(player, nbti.getInteger("SPEED"));
}
if(nbti.hasTag("HEALTH")) {
@ -75,31 +86,39 @@ public class ItemHandEvent implements Listener {
if(nbti.hasTag("STRENGTH")) {
pm.getItemStrength().remove(player, nbti.getInteger("STRENGTH"));
}*/
}
if (newItem != null && newItem.getType() != Material.AIR) {
NBTItem nbti = new NBTItem(newItem);
for (String s : Attributes.getNameList()) {
if (nbti.hasTag(s.toUpperCase())) {
java.lang.reflect.Method method = null;
try {
method = pm.getClass().getMethod("getItem" + s);
} catch (SecurityException | NoSuchMethodException exception) {}
if (method != null) {
me.unurled.raxen.components.entity.Attributes.Attribute attribute =
null;
try {
attribute = (Attribute) method.invoke(pm, (Object) null);
} catch (
InvocationTargetException | IllegalAccessException ignored
) {}
if (attribute != null) {
attribute.add(player, nbti.getInteger(s.toUpperCase()));
debug("add " + s + " for player " + player.getName());
}
}
}
}
/* if(nbti.hasTag("SPEED")) {
if (newItem != null && newItem.getType() != Material.AIR) {
NBTItem nbti = new NBTItem(newItem);
for (String s : Attributes.getNameList()) {
if (nbti.hasTag(s.toUpperCase())) {
java.lang.reflect.Method method = null;
try {
method = pm.getClass().getMethod("getItem" + s);
} catch (
SecurityException | NoSuchMethodException exception
) {}
if (method != null) {
me.unurled.raxen.components.entity.Attributes.Attribute attribute =
null;
try {
attribute = (Attribute) method.invoke(pm);
} catch (
InvocationTargetException
| IllegalAccessException ignored
) {}
if (attribute != null) {
attribute.add(
player,
nbti.getInteger(s.toUpperCase())
);
debug(
"add " + s + " for player " + player.getName()
);
}
}
}
}
/* if(nbti.hasTag("SPEED")) {
pm.getItemSpeed().add(player, nbti.getInteger("SPEED"));
}
if(nbti.hasTag("HEALTH")) {
@ -113,7 +132,7 @@ public class ItemHandEvent implements Listener {
if(nbti.hasTag("STRENGTH")) {
pm.getItemStrength().add(player, nbti.getInteger("STRENGTH"));
}*/
}
PlayerUtils.updateSkills(main, player);
}
PlayerUtils.updateSkills(main, player);
}
}

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