SacredRealms/SR-Game
1
0
Fork 0
Code Issues 19 Pull requests Projects 1 Releases Activity Actions

code refactoring

Browse source
This commit is contained in:
unurled 2024-03-18 22:01:16 +01:00
parent 456df87c33
commit 9105d31a02
Signed by: unurled
GPG key ID: FDBC9CBE1F82423F
9 changed files with 652 additions and 542 deletions
Download patch file Download diff file Expand all files Collapse all files

63
src/main/java/me/unurled/sacredrealms/sr/commands/admin/AttributeCommand.java
View file

@ -10,6 +10,7 @@ import me.unurled.sacredrealms.sr.components.attributes.Attribute;
import me.unurled.sacredrealms.sr.components.player.PlayerManager;
import me.unurled.sacredrealms.sr.components.player.SRPlayer;
import me.unurled.sacredrealms.sr.gui.attributes.AttributesGUI;
import me.unurled.sacredrealms.sr.managers.Manager;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
@ -26,7 +27,7 @@ public class AttributeCommand implements TabExecutor {
@Nullable
private static SRPlayer getSrPlayer(@NotNull CommandSender sender, Player target) {
PlayerManager pm = PlayerManager.getInstance(PlayerManager.class);
PlayerManager pm = Manager.getInstance(PlayerManager.class);
if (pm == null) {
sender.sendMessage(comp("<red>An error occurred."));
return null;
@ -39,21 +40,20 @@ public class AttributeCommand implements TabExecutor {
return player;
}
private static boolean remove(@NotNull CommandSender sender, Player target, Attribute attribute) {
private static void remove(@NotNull CommandSender sender, Player target, Attribute attribute) {
SRPlayer player = getSrPlayer(sender, target);
if (player == null) return true;
if (player == null) return;
player.removeAttribute(attribute);
player.removeItemAttributes(attribute, target.getInventory().getItemInMainHand());
syncSRToPlayer(player, target);
sender.sendMessage("Removed " + attribute.getName() + FOR + target.getName());
PlayerManager pm = PlayerManager.getInstance(PlayerManager.class);
PlayerManager pm = Manager.getInstance(PlayerManager.class);
pm.savePlayer(player);
return false;
}
private static boolean get(@NotNull CommandSender sender, Player target, Attribute attribute) {
private static void get(@NotNull CommandSender sender, Player target, Attribute attribute) {
SRPlayer player = getSrPlayer(sender, target);
if (player == null) return true;
if (player == null) return;
sender.sendMessage(
"Get "
+ attribute.getName()
@ -61,10 +61,9 @@ public class AttributeCommand implements TabExecutor {
+ target.getName()
+ ": "
+ player.getAttribute(attribute));
return false;
}
private static boolean set(
private static void set(
@NotNull CommandSender sender,
@NotNull String @NotNull [] args,
Attribute attribute,
@ -77,40 +76,38 @@ public class AttributeCommand implements TabExecutor {
+ attribute.getMinValue()
+ ", Max: "
+ attribute.getMaxValue());
return true;
return;
}
SRPlayer player = getSrPlayer(sender, target);
if (player == null) return true;
if (player == null) return;
player.setAttribute(attribute, value);
sender.sendMessage("Set " + attribute.getName() + " to " + value + FOR + target.getName());
player.setItemAttributes(attribute, target.getInventory().getItemInMainHand(), value);
syncSRToPlayer(player, target);
PlayerManager pm = PlayerManager.getInstance(PlayerManager.class);
PlayerManager pm = Manager.getInstance(PlayerManager.class);
pm.savePlayer(player);
} catch (NumberFormatException e) {
sender.sendMessage("Invalid value.");
}
return false;
}
private static boolean itemInHand(
@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
private static void itemInHand(@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
if (!(sender instanceof Player target)) {
sender.sendMessage("You must be a player to use this command.");
return true;
return;
}
Attribute attribute;
try {
attribute = Attribute.valueOf(args[2].toUpperCase());
} catch (IllegalArgumentException e) {
sender.sendMessage("Attribute not found.");
return true;
return;
}
if (args[0].equalsIgnoreCase("set")) {
try {
Result result = getResult(sender, args, target, attribute);
if (result == null) return true;
if (result == null) return;
result.player().setHandItemAttribute(attribute, result.value());
sender.sendMessage(
"Set " + attribute.getName() + " to " + result.value() + FOR + target.getName());
@ -125,7 +122,7 @@ public class AttributeCommand implements TabExecutor {
}
} else if (args[0].equalsIgnoreCase("get")) {
SRPlayer player = getSrPlayer(sender, target);
if (player == null) return true;
if (player == null) return;
sender.sendMessage(
"Get "
+ attribute.getName()
@ -136,7 +133,7 @@ public class AttributeCommand implements TabExecutor {
+ player.getHandItemAttribute(attribute));
} else if (args[0].equalsIgnoreCase(REMOVE)) {
SRPlayer player = getSrPlayer(sender, target);
if (player == null) return true;
if (player == null) return;
player.removeHandItemAttribute(attribute);
player.removeItemAttributes(attribute, target.getInventory().getItemInMainHand());
@ -144,23 +141,22 @@ public class AttributeCommand implements TabExecutor {
} else {
sender.sendMessage("Usage: /attribute <set|get|remove> <player> <attribute> [value]");
}
return true;
}
private static boolean gui(@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
private static void gui(@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
// open gui
if (args.length != 2) {
sender.sendMessage("Usage: /attribute gui <player>");
return true;
return;
}
if (!(sender instanceof Player p)) {
sender.sendMessage("You must be a player to use this command.");
return true;
return;
}
Player target = Bukkit.getPlayer(args[1]);
if (target == null) {
sender.sendMessage("Player not found.");
return true;
return;
}
Window window =
Window.single()
@ -169,8 +165,6 @@ public class AttributeCommand implements TabExecutor {
.setGui(AttributesGUI.createGui(target))
.build();
window.open();
return true;
}
@Nullable
@ -225,10 +219,12 @@ public class AttributeCommand implements TabExecutor {
return true;
}
if (args[0].equals("gui")) {
return gui(sender, args);
gui(sender, args);
return true;
}
if (args[1].equals("item-in-hand")) {
return itemInHand(sender, args);
itemInHand(sender, args);
return true;
}
Player target = Bukkit.getPlayer(args[1]);
if (target == null) {
@ -244,13 +240,16 @@ public class AttributeCommand implements TabExecutor {
return true;
}
if (args[0].equalsIgnoreCase("set") && (set(sender, args, attribute, target))) {
if (args[0].equalsIgnoreCase("set")) {
set(sender, args, attribute, target);
return true;
}
if (args[0].equalsIgnoreCase("get") && (get(sender, target, attribute))) {
if (args[0].equalsIgnoreCase("get")) {
get(sender, target, attribute);
return true;
}
if (args[0].equalsIgnoreCase(REMOVE) && (remove(sender, target, attribute))) {
if (args[0].equalsIgnoreCase(REMOVE)) {
remove(sender, target, attribute);
return true;
}

13
src/main/java/me/unurled/sacredrealms/sr/commands/admin/ClientBuildCommand.java
View file

@ -218,7 +218,7 @@ public class ClientBuildCommand implements TabExecutor, Listener {
public void onBlockPlace(@NotNull BlockPlaceEvent e) {
Player p = e.getPlayer();
if (manager == null) {
manager = ClientBuildManager.getInstance(ClientBuildManager.class);
manager = Manager.getInstance(ClientBuildManager.class);
}
if (manager.hasTemporaryBlocks(p)) {
log("block placed " + e.getBlock().getType());
@ -237,7 +237,7 @@ public class ClientBuildCommand implements TabExecutor, Listener {
public void onBlockBreak(@NotNull BlockBreakEvent e) {
Player p = e.getPlayer();
if (manager == null) {
manager = ClientBuildManager.getInstance(ClientBuildManager.class);
manager = Manager.getInstance(ClientBuildManager.class);
}
if (manager.hasTemporaryBlocks(p)) {
manager.getTemporaryBlocks(p).remove(e.getBlock().getLocation());
@ -275,11 +275,10 @@ public class ClientBuildCommand implements TabExecutor, Listener {
|| args[0].equalsIgnoreCase(DISPLAY))) {
ClientBuildManager clientBuildManager = Manager.getInstance(ClientBuildManager.class);
List<String> buildNames = clientBuildManager.getBuildNames();
if (nameCompletions.isEmpty() || !new HashSet<>(nameCompletions).containsAll(buildNames)) {
nameCompletions = buildNames;
}
return nameCompletions;
if (nameCompletions.isEmpty() || !new HashSet<>(nameCompletions).containsAll(buildNames)) {
nameCompletions = buildNames;
}
return nameCompletions;
}
return null;
}

9
src/main/java/me/unurled/sacredrealms/sr/commands/admin/EntityTypeCommand.java
View file

@ -8,6 +8,7 @@ import java.util.List;
import me.unurled.sacredrealms.sr.components.entity.EntityManager;
import me.unurled.sacredrealms.sr.components.entity.SREntityType;
import me.unurled.sacredrealms.sr.gui.entitytype.EntityTypeGUI;
import me.unurled.sacredrealms.sr.managers.Manager;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
@ -40,7 +41,7 @@ public class EntityTypeCommand implements TabExecutor {
return true;
}
if (args.length < 3) {
EntityManager em = EntityManager.getInstance(EntityManager.class);
EntityManager em = Manager.getInstance(EntityManager.class);
if (!em.getTypes().stream().map(SREntityType::getID).toList().contains(args[1])) {
sender.sendMessage("Invalid entity type.");
return true;
@ -66,7 +67,7 @@ public class EntityTypeCommand implements TabExecutor {
}
try {
EntityType type = EntityType.valueOf(args[4]);
EntityManager em = EntityManager.getInstance(EntityManager.class);
EntityManager em = Manager.getInstance(EntityManager.class);
if (setType(sender, args, em, type)) return true;
} catch (IllegalArgumentException e) {
sender.sendMessage("Invalid entity type.");
@ -179,12 +180,12 @@ public class EntityTypeCommand implements TabExecutor {
return List.of("create", "delete", "edit", "list");
}
if (args.length == 2) {
return EntityManager.getInstance(EntityManager.class).getTypes().stream()
return Manager.getInstance(EntityManager.class).getTypes().stream()
.map(SREntityType::getID)
.toList();
}
if (args.length == 3 && (args[0].equalsIgnoreCase("edit"))) {
return List.of("type", "behavior", "loot", "item", "stats", "name", "level");
return List.of("type", "behavior", "loot", "item", "stats", "name", "level");
}
if (args.length == 4
&& (args[0].equalsIgnoreCase("edit") && (args[2].equalsIgnoreCase("type")))) {

714
src/main/java/me/unurled/sacredrealms/sr/commands/admin/ItemCommand.java
View file

@ -10,6 +10,7 @@ import me.unurled.sacredrealms.sr.components.item.Item;
import me.unurled.sacredrealms.sr.components.item.ItemManager;
import me.unurled.sacredrealms.sr.components.item.ItemType;
import me.unurled.sacredrealms.sr.components.item.Rarity;
import me.unurled.sacredrealms.sr.managers.Manager;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.command.Command;
@ -21,6 +22,369 @@ import org.jetbrains.annotations.Nullable;
public class ItemCommand implements TabExecutor {
public static final String DELETE = "delete";
public static final String DOES_NOT_EXIST = "<red>An item with that ID does not exist.";
public static final String MODIFY = "modify";
public static final String MATERIAL = "material";
public static final String ENCHANTMENTS = "enchantments";
public static final String ATTRIBUTES = "attributes";
public static final String ABILITIES = "abilities";
public static final String CUSTOMMODELDATA = "custommodeldata";
public static final String RARITY = "rarity";
public static final String REMOVE = "remove";
public static final String USAGE =
"Usage: /item modify <id> <name|material|enchantments|attributes|abilities|custommodeldata|rarity|type|description> [value]";
private static void modify(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p) {
if (args.length < 2) {
p.sendMessage(USAGE);
return;
}
ItemManager im = Manager.getInstance(ItemManager.class);
if (!im.getItemIDs().contains(args[1])) {
sender.sendMessage(comp(DOES_NOT_EXIST));
return;
}
Item item = im.getItem(args[1]);
if (args.length == 2) {
p.sendMessage(USAGE);
return;
}
switch (args[2].toLowerCase()) {
case "name" -> modifyName(sender, args, p, item);
case MATERIAL -> modifyMaterial(sender, args, p, item);
case ENCHANTMENTS -> modifyEnchantments(args, p);
case ATTRIBUTES -> modifyAttributes(sender, args, p, item);
case ABILITIES -> modifyAbilities(sender, args, p);
case CUSTOMMODELDATA -> modifyModelData(sender, args, p, item);
case RARITY -> modifyRarity(sender, args, p, item);
case "type" -> modifyType(sender, args, p, item);
case "description" -> modifyDescription(sender, args, p, item);
default -> p.sendMessage(USAGE);
}
}
private static void modifyDescription(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> description <value>");
return;
}
String description = String.join(" ", Arrays.copyOfRange(args, 3, args.length));
item.setDescription(description);
sender.sendMessage(comp("<green>Description set."));
}
private static void modifyType(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> type <value>");
return;
}
ItemType type;
try {
type = ItemType.valueOf(args[3]);
} catch (Exception e) {
sender.sendMessage(comp("<red>Type not found."));
return;
}
item.setType(type);
sender.sendMessage(comp("<green>Type set."));
}
private static void modifyRarity(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> rarity <value>");
return;
}
Rarity rarity;
try {
rarity = Rarity.valueOf(args[3]);
} catch (Exception e) {
sender.sendMessage(comp("<red>Rarity not found."));
return;
}
item.setRarity(rarity);
sender.sendMessage(comp("<green>Rarity set."));
}
private static void modifyModelData(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> custommodeldata <value>");
return;
}
int customModelData;
try {
customModelData = Integer.parseInt(args[3]);
} catch (NumberFormatException e) {
sender.sendMessage(comp("<red>Invalid value."));
return;
}
item.setCustomModelData(customModelData);
sender.sendMessage(comp("<green>Custom model data set."));
}
private static void modifyAbilities(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p) {
if (args.length < 5) {
p.sendMessage("Usage: /item modify <id> abilities add <ability>");
return;
}
if (args[3].equalsIgnoreCase("add")) {
p.sendMessage("Abilities not working for now.");
// TODO: add ability
} else if (args[3].equalsIgnoreCase(REMOVE)) {
sender.sendMessage("Abilities not working for now.");
// TODO: remove ability
}
}
private static void modifyName(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> name <value>");
return;
}
String name = String.join(" ", Arrays.copyOfRange(args, 3, args.length));
item.setName(name);
sender.sendMessage(comp("<green>Item name set."));
// TODO: update item in player inventory
}
private static void modifyMaterial(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> material <value>");
return;
}
Material material = Material.matchMaterial(args[3]);
if (material == null) {
sender.sendMessage(comp("<red>Material not found."));
return;
}
item.setMaterial(material);
sender.sendMessage(comp("<green>Item material set."));
}
private static void modifyEnchantments(@NotNull String @NotNull [] args, Player p) {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> enchantments <add|remove> [enchantment]");
return;
}
if (args[3].equalsIgnoreCase("add")) {
if (args.length < 5) {
p.sendMessage("Usage: /item modify <id> enchantments add <enchantment>");
return;
}
// TODO: add enchantment
p.sendMessage("Enchantments not working for now.");
return;
}
if (args[3].equalsIgnoreCase(REMOVE)) {
if (args.length < 5) {
p.sendMessage("Usage: /item modify <id> enchantments remove <enchantment>");
return;
}
// TODO: remove enchantment
p.sendMessage("Enchantments not working for now.");
}
}
private static void modifyAttributes(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p, Item item) {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> attributes <add|remove> [attribute] [value]");
return;
}
if (args[3].equalsIgnoreCase("add")) {
if (args.length < 6) {
p.sendMessage("Usage: /item modify <id> attributes add <attribute> <value>");
return;
}
Attribute attribute = null;
try {
attribute = Attribute.valueOf(args[4]);
} catch (Exception e) {
sender.sendMessage(comp("<red>Attribute not found."));
error("Error on attribute affectation on item: " + args[1] + "\n" + e);
return;
}
double value;
try {
value = Double.parseDouble(args[5]);
} catch (NumberFormatException e) {
sender.sendMessage(comp("<red>Invalid value."));
return;
}
item.addAttribute(attribute, value);
sender.sendMessage(comp("<green>Attribute added."));
return;
}
if (args[3].equalsIgnoreCase(REMOVE)) {
if (args.length < 5) {
p.sendMessage("Usage: /item modify <id> attributes remove <attribute>");
return;
}
Attribute attribute = null;
try {
attribute = Attribute.valueOf(args[4]);
} catch (Exception e) {
sender.sendMessage(comp("<red>Attribute not found."));
error("Error on attribute affectation on item: " + args[1] + "\n" + e);
return;
}
item.removeAttribute(attribute);
sender.sendMessage(comp("<green>Attribute removed."));
}
}
private static void give(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p) {
if (args.length < 2) {
sender.sendMessage("Usage: /item give <id>");
return;
}
ItemManager im = Manager.getInstance(ItemManager.class);
if (!im.getItemIDs().contains(args[1])) {
sender.sendMessage(comp(DOES_NOT_EXIST));
return;
}
Item item = im.getItem(args[1]);
if (args.length == 2) {
p.getInventory().addItem(item.toItemStack());
sender.sendMessage(comp("<green>Item given."));
return;
}
Player target = Bukkit.getPlayer(args[2]);
if (target == null) {
sender.sendMessage(comp("<red>Player not found."));
return;
}
target.getInventory().addItem(item.toItemStack());
sender.sendMessage(comp("<green>Item given."));
}
private static void delete(
@NotNull CommandSender sender, @NotNull String @NotNull [] args, Player p) {
if (args.length < 2) {
p.sendMessage("Usage: /item delete <id>");
return;
}
ItemManager im = Manager.getInstance(ItemManager.class);
if (!im.getItemIDs().contains(args[1])) {
sender.sendMessage(comp(DOES_NOT_EXIST));
return;
}
im.removeItem(args[1]);
sender.sendMessage(comp("<green>Item deleted."));
}
private static void create(@NotNull CommandSender sender, @NotNull String @NotNull [] args) {
if (args.length < 2) {
sender.sendMessage("Usage: /item create <id>");
return;
}
ItemManager im = Manager.getInstance(ItemManager.class);
if (im.getItemIDs().contains(args[1])) {
sender.sendMessage(comp("<red>An item with that ID already exists."));
return;
}
Item item = new Item();
item.setID(args[1]);
im.addItem(item);
sender.sendMessage(
comp(
"<green>Item created. You can now modify it using "
+ "<click:suggest_command:/item "
+ "modify "
+ args[1]
+ "> /item modify "
+ args[1]
+ "</click>"));
}
private static void list(@NotNull CommandSender sender, Player p) {
ItemManager im = Manager.getInstance(ItemManager.class);
if (im.getItemIDs().isEmpty()) {
sender.sendMessage(comp("<red>There are no items."));
return;
}
sender.sendMessage("Items:");
im.getItemIDs().forEach(p::sendMessage);
}
@Nullable
private static List<String> modify(@NotNull String @NotNull [] args) {
if (args.length == 5 && (args[0].equalsIgnoreCase(MODIFY))) {
// TODO: Enchantments in completion
/*if (args[2].equalsIgnoreCase("enchantments")) {
return Arrays.stream(Enchantment.values()).map(Enum::name).toList();
} else*/ if (args[2].equalsIgnoreCase(ATTRIBUTES)) {
return Arrays.stream(Attribute.values()).map(Enum::name).toList();
}
}
return null;
}
@Nullable
private static List<String> modifyCompletion(@NotNull String @NotNull [] args) {
if (args.length == 4 && (args[0].equalsIgnoreCase(MODIFY))) {
if (args[2].equalsIgnoreCase(RARITY)) {
return Arrays.stream(Rarity.values()).map(Enum::name).toList();
} else if (args[2].equalsIgnoreCase("type")) {
return Arrays.stream(ItemType.values()).map(Enum::name).toList();
} else if (args[2].equalsIgnoreCase(MATERIAL)) {
return Arrays.stream(Material.values()).map(Enum::name).toList();
} else if (args[2].equalsIgnoreCase(ENCHANTMENTS)) {
return List.of("add", REMOVE);
} else if (args[2].equalsIgnoreCase(ATTRIBUTES)) {
return List.of("add", REMOVE);
} else if (args[2].equalsIgnoreCase(ABILITIES)) {
return List.of("add", REMOVE);
} else if (args[2].equalsIgnoreCase(CUSTOMMODELDATA)) {
try {
Integer.parseInt(args[3]);
} catch (NumberFormatException e) {
return List.of("1");
}
}
}
return null;
}
@Nullable
private static List<String> argsLengthThree(@NotNull String @NotNull [] args) {
if (args.length == 3) {
if (args[0].equalsIgnoreCase(MODIFY)) {
return List.of(
"name",
MATERIAL,
ENCHANTMENTS,
ATTRIBUTES,
ABILITIES,
CUSTOMMODELDATA,
RARITY,
"type",
"description");
} else if (args[0].equalsIgnoreCase("give")) {
return Bukkit.getOnlinePlayers().stream().map(Player::getName).toList();
}
}
return null;
}
/**
* Executes the given command, returning its success. <br>
* If false is returned, then the "usage" plugin.yml entry for this command (if defined) will be
@ -54,279 +418,28 @@ public class ItemCommand implements TabExecutor {
}
if (args[0].equalsIgnoreCase("list")) {
ItemManager im = ItemManager.getInstance(ItemManager.class);
if (im.getItemIDs().isEmpty()) {
p.sendMessage(comp("<red>There are no items."));
return true;
}
p.sendMessage("Items:");
im.getItemIDs().forEach(p::sendMessage);
list(sender, p);
return true;
}
if (args[0].equalsIgnoreCase("create")) {
if (args.length < 2) {
p.sendMessage("Usage: /item create <id>");
return true;
}
ItemManager im = ItemManager.getInstance(ItemManager.class);
if (im.getItemIDs().contains(args[1])) {
p.sendMessage(comp("<red>An item with that ID already exists."));
return true;
}
Item item = new Item();
item.setID(args[1]);
im.addItem(item);
p.sendMessage(
comp(
"<green>Item created. You can now modify it using "
+ "<click:suggest_command:/item "
+ "modify "
+ args[1]
+ "> /item modify "
+ args[1]
+ "</click>"));
create(sender, args);
return true;
}
if (args[0].equalsIgnoreCase("delete")) {
if (args.length < 2) {
p.sendMessage("Usage: /item delete <id>");
return true;
}
ItemManager im = ItemManager.getInstance(ItemManager.class);
if (!im.getItemIDs().contains(args[1])) {
p.sendMessage(comp("<red>An item with that ID does not exist."));
return true;
}
im.removeItem(args[1]);
p.sendMessage(comp("<green>Item deleted."));
if (args[0].equalsIgnoreCase(DELETE)) {
delete(sender, args, p);
return true;
}
if (args[0].equalsIgnoreCase("give")) {
if (args.length < 2) {
p.sendMessage("Usage: /item give <id>");
return true;
}
ItemManager im = ItemManager.getInstance(ItemManager.class);
if (!im.getItemIDs().contains(args[1])) {
p.sendMessage(comp("<red>An item with that ID does not exist."));
return true;
}
Item item = im.getItem(args[1]);
if (args.length == 2) {
p.getInventory().addItem(item.toItemStack());
p.sendMessage(comp("<green>Item given."));
return true;
}
Player target = Bukkit.getPlayer(args[2]);
if (target == null) {
p.sendMessage(comp("<red>Player not found."));
return true;
}
target.getInventory().addItem(item.toItemStack());
p.sendMessage(comp("<green>Item given."));
give(sender, args, p);
return true;
}
if (args[0].equalsIgnoreCase("modify")) {
if (args.length < 2) {
p.sendMessage(
"Usage: /item modify <id> <name|material|enchantments|attributes|abilities|custommodeldata|rarity|type|description> [value]");
return true;
}
ItemManager im = ItemManager.getInstance(ItemManager.class);
if (!im.getItemIDs().contains(args[1])) {
p.sendMessage(comp("<red>An item with that ID does not exist."));
return true;
}
Item item = im.getItem(args[1]);
if (args.length == 2) {
p.sendMessage(
"Usage: /item modify <id> <name|material|enchantments|attributes|abilities|custommodeldata|rarity|type|description> [value]");
return true;
}
switch (args[2].toLowerCase()) {
case "name" -> {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> name <value>");
return true;
}
String name = String.join(" ", Arrays.copyOfRange(args, 3, args.length));
item.setName(name);
p.sendMessage(comp("<green>Item name set."));
// TODO: update item in player inventory
return true;
}
case "material" -> {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> material <value>");
return true;
}
Material material = Material.matchMaterial(args[3]);
if (material == null) {
p.sendMessage(comp("<red>Material not found."));
return true;
}
item.setMaterial(material);
p.sendMessage(comp("<green>Item material set."));
}
case "enchantments" -> {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> enchantments <add|remove> [enchantment]");
return true;
}
if (args[3].equalsIgnoreCase("add")) {
if (args.length < 5) {
p.sendMessage("Usage: /item modify <id> enchantments add <enchantment>");
return true;
}
// TODO: add enchantment
p.sendMessage("Enchantments not working for now.");
return true;
}
if (args[3].equalsIgnoreCase("remove")) {
if (args.length < 5) {
p.sendMessage("Usage: /item modify <id> enchantments remove <enchantment>");
return true;
}
// TODO: remove enchantment
p.sendMessage("Enchantments not working for now.");
return true;
}
}
case "attributes" -> {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> attributes <add|remove> [attribute] [value]");
return true;
}
if (args[3].equalsIgnoreCase("add")) {
if (args.length < 6) {
p.sendMessage("Usage: /item modify <id> attributes add <attribute> <value>");
return true;
}
Attribute attribute = null;
try {
attribute = Attribute.valueOf(args[4]);
} catch (Exception e) {
p.sendMessage(comp("<red>Attribute not found."));
error("Error on attribute affectation on item: " + args[1] + "\n" + e);
return true;
}
double value;
try {
value = Double.parseDouble(args[5]);
} catch (NumberFormatException e) {
p.sendMessage(comp("<red>Invalid value."));
return true;
}
item.addAttribute(attribute, value);
p.sendMessage(comp("<green>Attribute added."));
return true;
}
if (args[3].equalsIgnoreCase("remove")) {
if (args.length < 5) {
p.sendMessage("Usage: /item modify <id> attributes remove <attribute>");
return true;
}
Attribute attribute = null;
try {
attribute = Attribute.valueOf(args[4]);
} catch (Exception e) {
p.sendMessage(comp("<red>Attribute not found."));
error("Error on attribute affectation on item: " + args[1] + "\n" + e);
return true;
}
item.removeAttribute(attribute);
p.sendMessage(comp("<green>Attribute removed."));
return true;
}
return true;
}
case "abilities" -> {
if (args.length < 5) {
p.sendMessage("Usage: /item modify <id> abilities add <ability>");
return true;
}
if (args[3].equalsIgnoreCase("add")) {
p.sendMessage("Abilities not working for now.");
// TODO: add ability
} else if (args[3].equalsIgnoreCase("remove")) {
p.sendMessage("Abilities not working for now.");
// TODO: remove ability
}
return true;
}
case "custommodeldata" -> {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> custommodeldata <value>");
return true;
}
int customModelData;
try {
customModelData = Integer.parseInt(args[3]);
} catch (NumberFormatException e) {
p.sendMessage(comp("<red>Invalid value."));
return true;
}
item.setCustomModelData(customModelData);
p.sendMessage(comp("<green>Custom model data set."));
return true;
}
case "rarity" -> {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> rarity <value>");
return true;
}
Rarity rarity;
try {
rarity = Rarity.valueOf(args[3]);
} catch (Exception e) {
p.sendMessage(comp("<red>Rarity not found."));
return true;
}
item.setRarity(rarity);
p.sendMessage(comp("<green>Rarity set."));
return true;
}
case "type" -> {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> type <value>");
return true;
}
ItemType type;
try {
type = ItemType.valueOf(args[3]);
} catch (Exception e) {
p.sendMessage(comp("<red>Type not found."));
return true;
}
item.setType(type);
p.sendMessage(comp("<green>Type set."));
return true;
}
case "description" -> {
if (args.length < 4) {
p.sendMessage("Usage: /item modify <id> description <value>");
return true;
}
String description = String.join(" ", Arrays.copyOfRange(args, 3, args.length));
item.setDescription(description);
p.sendMessage(comp("<green>Description set."));
return true;
}
}
if (args[0].equalsIgnoreCase(MODIFY)) {
modify(sender, args, p);
return true;
}
return true;
@ -355,78 +468,33 @@ public class ItemCommand implements TabExecutor {
}
if (args.length == 1) {
return List.of("list", "create", "delete", "give", "modify");
return List.of("list", "create", DELETE, "give", MODIFY);
}
if (args.length == 2) {
if (args[0].equalsIgnoreCase("delete")
|| args[0].equalsIgnoreCase("give")
|| args[0].equalsIgnoreCase("modify")) {
ItemManager im = ItemManager.getInstance(ItemManager.class);
if (args.length == 2
&& (args[0].equalsIgnoreCase(DELETE)
|| args[0].equalsIgnoreCase("give")
|| args[0].equalsIgnoreCase(MODIFY))) {
ItemManager im = Manager.getInstance(ItemManager.class);
return im.getItemIDs();
}
}
if (args.length == 3) {
if (args[0].equalsIgnoreCase("modify")) {
return List.of(
"name",
"material",
"enchantments",
"attributes",
"abilities",
"custommodeldata",
"rarity",
"type",
"description");
} else if (args[0].equalsIgnoreCase("give")) {
return Bukkit.getOnlinePlayers().stream().map(Player::getName).toList();
}
}
List<String> completions = argsLengthThree(args);
if (completions != null) return completions;
if (args.length == 4) {
if (args[0].equalsIgnoreCase("modify")) {
if (args[2].equalsIgnoreCase("rarity")) {
return Arrays.stream(Rarity.values()).map(Enum::name).toList();
} else if (args[2].equalsIgnoreCase("type")) {
return Arrays.stream(ItemType.values()).map(Enum::name).toList();
} else if (args[2].equalsIgnoreCase("material")) {
return Arrays.stream(Material.values()).map(Enum::name).toList();
} else if (args[2].equalsIgnoreCase("enchantments")) {
return List.of("add", "remove");
} else if (args[2].equalsIgnoreCase("abilities")) {
return List.of("add", "remove");
} else if (args[2].equalsIgnoreCase("attributes")) {
return List.of("add", "remove");
} else if (args[2].equalsIgnoreCase("custommodeldata")) {
try {
Integer.parseInt(args[3]);
} catch (NumberFormatException e) {
return List.of("1");
}
}
}
}
completions = modifyCompletion(args);
if (completions != null) return completions;
if (args.length == 5) {
if (args[0].equalsIgnoreCase("modify")) {
/*if (args[2].equalsIgnoreCase("enchantments")) { // TODO: Enchantments in completion
return Arrays.stream(Enchantment.values()).map(Enum::name).toList();
} else*/ if (args[2].equalsIgnoreCase("attributes")) {
return Arrays.stream(Attribute.values()).map(Enum::name).toList();
}
}
}
completions = modify(args);
if (completions != null) return completions;
if (args.length == 6) {
if (args[0].equalsIgnoreCase("modify")) {
if (args[2].equalsIgnoreCase("attributes")) {
try {
Double.parseDouble(args[5]);
} catch (NumberFormatException e) {
return List.of("1.0");
}
}
if (args.length == 6
&& (args[0].equalsIgnoreCase(MODIFY))
&& (args[2].equalsIgnoreCase(ATTRIBUTES))) {
try {
Double.parseDouble(args[5]);
} catch (NumberFormatException e) {
return List.of("1.0");
}
}

3
src/main/java/me/unurled/sacredrealms/sr/commands/admin/LevelCommand.java
View file

@ -3,6 +3,7 @@ package me.unurled.sacredrealms.sr.commands.admin;
import java.util.List;
import me.unurled.sacredrealms.sr.components.player.PlayerManager;
import me.unurled.sacredrealms.sr.components.player.SRPlayer;
import me.unurled.sacredrealms.sr.managers.Manager;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
@ -46,7 +47,7 @@ public class LevelCommand implements TabExecutor {
return true;
}
PlayerManager pm = PlayerManager.getInstance(PlayerManager.class);
PlayerManager pm = Manager.getInstance(PlayerManager.class);
SRPlayer player = pm.getPlayer(target.getUniqueId());
if (player != null) {

57
src/main/java/me/unurled/sacredrealms/sr/commands/player/ResetAdventureCommand.java
View file

@ -9,6 +9,7 @@ import java.util.Objects;
import me.unurled.sacredrealms.sr.SR;
import me.unurled.sacredrealms.sr.components.player.PlayerManager;
import me.unurled.sacredrealms.sr.data.DataManager;
import me.unurled.sacredrealms.sr.managers.Manager;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
@ -42,29 +43,7 @@ public class ResetAdventureCommand implements TabExecutor {
@NotNull String label,
@NotNull String[] args) {
if (sender.hasPermission("sr.resetadventure")) {
if (args.length > 2) {
sender.sendMessage(comp("<red>Usage: /resetadventure <player>"));
return true;
}
if (sender instanceof Player p) {
if (args.length == 0) {
boolean status = resetAdventure(p);
if (status) {
p.sendMessage(comp("<green>Your adventure has been reset."));
} else {
p.sendMessage(comp("<red>Failed to reset your adventure."));
}
return true;
}
}
OfflinePlayer player = SR.getInstance().getServer().getOfflinePlayer(args[0]);
boolean status = resetAdventure(player);
if (status) {
sender.sendMessage(comp("<green>Successfully reset " + player.getName() + "'s adventure."));
} else {
sender.sendMessage(comp("<red>Failed to reset " + player.getName() + "'s adventure."));
}
reset(sender, args);
return true;
}
if (args.length > 0) {
@ -76,7 +55,7 @@ public class ResetAdventureCommand implements TabExecutor {
long lastUsed = cooldowns.get(player);
long secondsLeft = ((lastUsed / 1000) + COOLDOWN) - (System.currentTimeMillis() / 1000);
if (secondsLeft > 0) {
player.sendMessage(
sender.sendMessage(
comp(
"<red>You must wait "
+ secondsLeft
@ -86,17 +65,41 @@ public class ResetAdventureCommand implements TabExecutor {
}
boolean status = resetAdventure(player);
if (status) {
player.sendMessage(comp("<green>Your adventure has been reset."));
sender.sendMessage(comp("<green>Your adventure has been reset."));
} else {
player.sendMessage(comp("<red>Failed to reset your adventure."));
sender.sendMessage(comp("<red>Failed to reset your adventure."));
}
cooldowns.put(player, System.currentTimeMillis());
}
return true;
}
private void reset(@NotNull CommandSender sender, @NotNull String[] args) {
if (args.length > 2) {
sender.sendMessage(comp("<red>Usage: /resetadventure <player>"));
return;
}
if (sender instanceof Player p && (args.length == 0)) {
boolean status = resetAdventure(p);
if (status) {
sender.sendMessage(comp("<green>Your adventure has been reset."));
} else {
sender.sendMessage(comp("<red>Failed to reset your adventure."));
}
return;
}
OfflinePlayer player = SR.getInstance().getServer().getOfflinePlayer(args[0]);
boolean status = resetAdventure(player);
if (status) {
sender.sendMessage(comp("<green>Successfully reset " + player.getName() + "'s adventure."));
} else {
sender.sendMessage(comp("<red>Failed to reset " + player.getName() + "'s adventure."));
}
}
private boolean resetAdventure(OfflinePlayer player) {
DataManager dataManager = DataManager.getInstance(DataManager.class);
DataManager dataManager = Manager.getInstance(DataManager.class);
if (dataManager != null) {
if (dataManager.getDataHandler().exists(PlayerManager.PLAYER_KEY + player.getUniqueId())) {
dataManager.getDataHandler().remove(PlayerManager.PLAYER_KEY + player.getUniqueId());

18
src/main/java/me/unurled/sacredrealms/sr/components/clientbuild/ClientBuildManager.java
View file

@ -29,6 +29,7 @@ import org.jetbrains.annotations.Nullable;
public class ClientBuildManager extends Manager {
public static final String SR_PLAYERS_CLIENTBUILD = "sr.players.clientbuild.";
private final List<ClientBuild> builds = new ArrayList<>();
/** a map of players that have ClientBuild displayed */
@ -54,7 +55,7 @@ public class ClientBuildManager extends Manager {
public void saveData() {
// save client side builds to redis
DataManager dataManager = DataManager.getInstance(DataManager.class);
DataManager dataManager = Manager.getInstance(DataManager.class);
DataHandler dh = dataManager.getDataHandler();
Gson gson =
@ -69,7 +70,7 @@ public class ClientBuildManager extends Manager {
for (Entry<Player, List<String>> entry : playerBlocks.entrySet()) {
for (String name : entry.getValue()) {
// save for player
dh.set("sr.players.clientbuild." + entry.getKey().getUniqueId() + "." + name, "true");
dh.set(SR_PLAYERS_CLIENTBUILD + entry.getKey().getUniqueId() + "." + name, "true");
}
}
}
@ -78,7 +79,7 @@ public class ClientBuildManager extends Manager {
@Override
public void loadData() {
// load client side builds from redis
DataManager dataManager = DataManager.getInstance(DataManager.class);
DataManager dataManager = Manager.getInstance(DataManager.class);
DataHandler dh = dataManager.getDataHandler();
if (dh == null) {
@ -107,11 +108,10 @@ public class ClientBuildManager extends Manager {
@EventHandler
public void onPlayerJoin(@NotNull PlayerJoinEvent e) {
DataHandler dh = DataManager.getInstance(DataManager.class).getDataHandler();
DataHandler dh = Manager.getInstance(DataManager.class).getDataHandler();
Player p = e.getPlayer();
List<String> names =
new ArrayList<>(dh.getKeysAll("sr.players.clientbuild." + p.getUniqueId()));
List<String> names = new ArrayList<>(dh.getKeysAll(SR_PLAYERS_CLIENTBUILD + p.getUniqueId()));
playerBlocks.put(p, names);
@ -144,13 +144,13 @@ public class ClientBuildManager extends Manager {
// save the player's displayed builds
DataManager dataManager = DataManager.getInstance(DataManager.class);
DataManager dataManager = Manager.getInstance(DataManager.class);
DataHandler dh = dataManager.getDataHandler();
dh.remove("sr.players.clientbuild." + p.getUniqueId());
dh.remove(SR_PLAYERS_CLIENTBUILD + p.getUniqueId());
for (String name : names) {
dh.set("sr.players.clientbuild." + p.getUniqueId() + "." + name, "true");
dh.set(SR_PLAYERS_CLIENTBUILD + p.getUniqueId() + "." + name, "true");
}
playerBlocks.get(p).clear();

301
src/main/java/me/unurled/sacredrealms/sr/components/combat/CombatManager.java
View file

@ -26,7 +26,6 @@ import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
import org.bukkit.inventory.EntityEquipment;
import org.jetbrains.annotations.NotNull;
@SuppressWarnings("EmptyMethod")
public class CombatManager extends Manager {
public static final Random RANDOM = new Random();
@ -41,6 +40,66 @@ public class CombatManager extends Manager {
e.setCancelled(true);
}
private static void playerVictim(
@NotNull EntityDamageByEntityEvent e, Player player, Mob mob, PlayerManager pm) {
// get equipment of damager
EntityEquipment equipment = mob.getEquipment();
Double dStrength = Items.getTotalAttribute(equipment, Attribute.STRENGTH);
Double eDefense = Items.getTotalAttribute(player, Attribute.DEFENSE);
double damage = dStrength - eDefense;
Double dLuck = Items.getTotalAttribute(equipment, Attribute.LUCK);
Double eLuck = Items.getTotalAttribute(player, Attribute.LUCK);
double luck = dLuck - eLuck;
if (luck < -1000) {
// 100% chance of miss
player.sendMessage(player.identity(), comp("<red>You dodged!"));
player.playSound(player, Sound.ENTITY_ARROW_SHOOT, 1.0f, 1.0f);
e.setCancelled(true);
return;
} else if (luck > 1000) {
// 100% chance of critical hit
luck = 10000d;
player.playSound(player, Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
damage = damage * 2;
}
if (luck < 0) {
// chances of miss
if (RANDOM.nextBoolean()) {
player.playSound(player, Sound.ENTITY_ARROW_SHOOT, 1.0f, 1.0f);
e.setCancelled(true);
player.sendMessage(comp("<red>You dodged!"));
return;
}
} else if (luck > 0 && luck < 1000 && RANDOM.nextBoolean()) {
// chance of critical hit
player.playSound(player, Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
// damage * 2
damage = damage * 2;
}
// apply damage
player.damage(damage);
// add an
SRPlayer player1 = pm.getPlayer(player.getUniqueId());
if (player1 != null) {
player1.setHealth(player.getHealth() - damage, DamageCause.ENTITY_ATTACK);
if (player1.getHealth() <= 0) {
player.damage(player.getHealth());
}
updateActionBar(player, player1);
}
spawnIndicator(player, false, damage);
// TODO: check for status effects (apply status effects depending item of damager)
}
// TODO: Finish this
@EventHandler
public void onDamage(@NotNull EntityDamageByEntityEvent e) {
@ -56,156 +115,124 @@ public class CombatManager extends Manager {
}
if (damager instanceof Player d) {
if (entity instanceof Player) {
// no pvp
playerDamager(e, entity, d, pm);
return;
}
if (entity instanceof Player player && damager instanceof Mob mob) {
playerVictim(e, player, mob, pm);
}
}
private void playerDamager(
@NotNull EntityDamageByEntityEvent e, LivingEntity entity, Player d, PlayerManager pm) {
if (entity instanceof Player) {
// no pvp
e.setCancelled(true);
d.sendMessage(comp("<red>You can't attack players!"));
d.playSound(d, Sound.BLOCK_ANVIL_HIT, 1.0f, 1.0f);
return;
}
if (entity instanceof Mob mob) {
isMob(e, entity, d, pm, mob);
}
}
private void isMob(
@NotNull EntityDamageByEntityEvent e,
LivingEntity entity,
Player d,
PlayerManager pm,
Mob mob) {
double dStrength = Items.getTotalAttribute(d, Attribute.STRENGTH);
SRPlayer player = pm.getPlayer(d.getUniqueId());
if (player != null) {
dStrength += player.getAttribute(Attribute.STRENGTH);
}
EntityEquipment equipment = mob.getEquipment();
double eDefense = Items.getTotalAttribute(equipment, Attribute.DEFENSE);
double damage = dStrength - eDefense;
Double dLuck = Items.getTotalAttribute(d, Attribute.LUCK);
Double eLuck = Items.getTotalAttribute(equipment, Attribute.LUCK);
double luck = dLuck - eLuck;
if (luck < -1000) {
// 100% chance of miss
d.sendMessage(comp("<red>You missed!"));
d.playSound(d, Sound.ENTITY_ARROW_SHOOT, 1.0f, 1.0f);
e.setCancelled(true);
return;
} else if (luck > 1000) {
// 100% chance of critical hit
luck = 10000d;
d.playSound(d, Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
damage = damage * 2;
}
if (luck < 0) {
// chances of miss
if (RANDOM.nextBoolean()) {
d.playSound(d, Sound.ENTITY_ARROW_SHOOT, 1.0f, 1.0f);
e.setCancelled(true);
d.sendMessage(comp("<red>You can't attack players!"));
d.playSound(d, Sound.BLOCK_ANVIL_HIT, 1.0f, 1.0f);
d.sendMessage(comp("<red>You missed!"));
return;
}
if (entity instanceof Mob mob) {
double dStrength = Items.getTotalAttribute(d, Attribute.STRENGTH);
SRPlayer player = pm.getPlayer(d.getUniqueId());
if (player != null) {
dStrength += player.getAttribute(Attribute.STRENGTH);
}
EntityEquipment equipment = mob.getEquipment();
double eDefense = Items.getTotalAttribute(equipment, Attribute.DEFENSE);
} else if (luck > 0 && luck < 1000 && RANDOM.nextBoolean()) {
// chance of critical hit
d.playSound(d, Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
// damage * 2
damage = damage * 2;
}
// apply damage
Double damage = dStrength - eDefense;
historyHandler(entity, d, damage);
entity.damage(damage);
Double dLuck = Items.getTotalAttribute(d, Attribute.LUCK);
Double eLuck = Items.getTotalAttribute(equipment, Attribute.LUCK);
EntityManager em = EntityManager.getInstance(EntityManager.class);
SREntity ent = em.getEntity(entity.getUniqueId());
double luck = dLuck - eLuck;
if (luck < -1000) {
// 100% chance of miss
d.sendMessage(comp("<red>You missed!"));
d.playSound(d, Sound.ENTITY_ARROW_SHOOT, 1.0f, 1.0f);
e.setCancelled(true);
return;
} else if (luck > 1000) {
// 100% chance of critical hit
luck = 10000d;
d.playSound(d, Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
damage = damage * 2;
}
if (entity.getHealth() <= 0) {
die(entity, d, pm, ent);
return;
}
if (luck < 0) {
// chances of miss
if (RANDOM.nextBoolean()) {
d.playSound(d, Sound.ENTITY_ARROW_SHOOT, 1.0f, 1.0f);
e.setCancelled(true);
d.sendMessage(comp("<red>You missed!"));
return;
}
} else if (luck > 0 && luck < 1000 && RANDOM.nextBoolean()) {
// chance of critical hit
d.playSound(d, Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
// damage * 2
damage = damage * 2;
}
// apply damage
spawnIndicator(entity, false, damage);
// TODO: check for status effects (apply status effects depending item of damager)
}
if (historyMobDamage.containsKey(entity.getUniqueId())) {
HashMap<Player, Double> history =
historyMobDamage.getOrDefault(entity.getUniqueId(), new HashMap<>());
if (history.containsKey(d)) {
history.put(d, history.get(d) + damage);
} else {
history.put(d, damage);
}
} else {
HashMap<Player, Double> history = new HashMap<>();
history.put(d, damage);
historyMobDamage.put(entity.getUniqueId(), history);
}
entity.damage(damage);
EntityManager em = EntityManager.getInstance(EntityManager.class);
SREntity ent = em.getEntity(entity.getUniqueId());
if (entity.getHealth() <= 0) {
// entity is dead, give experience to player
SRPlayer player1 = pm.getPlayer(d.getUniqueId());
if (player1 != null && ent != null) {
// calculate experience % based on damage
HashMap<Player, Double> playerDoubleHashMap =
historyMobDamage.get(entity.getUniqueId());
if (playerDoubleHashMap == null) {
return;
}
for (Entry<Player, Double> map : playerDoubleHashMap.entrySet()) {
Double exp = ent.getExperience() * (map.getValue() / ent.getHealth());
SRPlayer tmp = pm.getPlayer(map.getKey().getUniqueId());
if (tmp != null) {
tmp.setExperience((long) (tmp.getExperience() + exp));
}
}
}
}
spawnIndicator(entity, false, damage);
// TODO: check for status effects (apply status effects depending item of damager)
}
} else if (entity instanceof Player player && damager instanceof Mob mob) {
// damager is not player
// get equipment of damager
EntityEquipment equipment = mob.getEquipment();
Double dStrength = Items.getTotalAttribute(equipment, Attribute.STRENGTH);
Double eDefense = Items.getTotalAttribute(player, Attribute.DEFENSE);
double damage = dStrength - eDefense;
Double dLuck = Items.getTotalAttribute(equipment, Attribute.LUCK);
Double eLuck = Items.getTotalAttribute(player, Attribute.LUCK);
double luck = dLuck - eLuck;
if (luck < -1000) {
// 100% chance of miss
player.sendMessage(comp("<red>You dodged!"));
player.playSound(player, Sound.ENTITY_ARROW_SHOOT, 1.0f, 1.0f);
e.setCancelled(true);
private void die(LivingEntity entity, Player d, PlayerManager pm, SREntity ent) {
// entity is dead, give experience to player
SRPlayer player1 = pm.getPlayer(d.getUniqueId());
if (player1 != null && ent != null) {
// calculate experience % based on damage
HashMap<Player, Double> playerDoubleHashMap = historyMobDamage.get(entity.getUniqueId());
if (playerDoubleHashMap == null) {
return;
} else if (luck > 1000) {
// 100% chance of critical hit
luck = 10000d;
player.playSound(player, Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
damage = damage * 2;
}
if (luck < 0) {
// chances of miss
if (RANDOM.nextBoolean()) {
player.playSound(player, Sound.ENTITY_ARROW_SHOOT, 1.0f, 1.0f);
e.setCancelled(true);
player.sendMessage(comp("<red>You dodged!"));
return;
for (Entry<Player, Double> map : playerDoubleHashMap.entrySet()) {
Double exp = ent.getExperience() * (map.getValue() / ent.getHealth());
SRPlayer tmp = pm.getPlayer(map.getKey().getUniqueId());
if (tmp != null) {
tmp.setExperience((long) (tmp.getExperience() + exp));
}
} else if (luck > 0 && luck < 1000 && RANDOM.nextBoolean()) {
// chance of critical hit
player.playSound(player, Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
// damage * 2
damage = damage * 2;
}
}
}
// apply damage
player.damage(damage);
// add an
SRPlayer player1 = pm.getPlayer(player.getUniqueId());
if (player1 != null) {
player1.setHealth(player.getHealth() - damage, DamageCause.ENTITY_ATTACK);
if (player1.getHealth() <= 0) {
player.damage(player.getHealth());
}
updateActionBar(player, player1);
private void historyHandler(LivingEntity entity, Player d, Double damage) {
if (historyMobDamage.containsKey(entity.getUniqueId())) {
HashMap<Player, Double> history =
historyMobDamage.getOrDefault(entity.getUniqueId(), new HashMap<>());
if (history.containsKey(d)) {
history.put(d, history.get(d) + damage);
} else {
history.put(d, damage);
}
spawnIndicator(player, false, damage);
// TODO: check for status effects (apply status effects depending item of damager)
} else {
HashMap<Player, Double> history = new HashMap<>();
history.put(d, damage);
historyMobDamage.put(entity.getUniqueId(), history);
}
}
}

16
src/main/java/me/unurled/sacredrealms/sr/utils/Component.java
View file

@ -1,16 +1,28 @@
package me.unurled.sacredrealms.sr.utils;
import net.kyori.adventure.text.TextComponent;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.jetbrains.annotations.NotNull;
public class Component {
public static final String NOT_PLAYER = "<red>You must be a player to use this command.";
public static final String NO_PERMISSION = "<red>You do not have permission to use this command.";
private static MiniMessage miniMessage;
private Component() {}
public static net.kyori.adventure.text.@NotNull Component comp(String msg) {
MiniMessage mm = MiniMessage.miniMessage();
return mm.deserialize(msg);
if (miniMessage == null) {
miniMessage = MiniMessage.miniMessage();
}
return miniMessage.deserialize(msg);
}
public static net.kyori.adventure.text.@NotNull TextComponent textComp(String msg) {
if (miniMessage == null) {
miniMessage = MiniMessage.miniMessage();
}
return (TextComponent) miniMessage.deserialize(msg);
}
}