Initial commit

This commit is contained in:
Scifi9902
2026-10-12 13:57:05 -03:00
commit 4bde3b176a
2576 changed files with 212659 additions and 0 deletions
+68
View File
@@ -0,0 +1,68 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>ProjectCranked</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>Pets</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Utils</artifactId>
</dependency>
<dependency>
<groupId>com.massivecraft</groupId>
<artifactId>Factions</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>CagePvP</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Masks</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Arcade</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>StarItems</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Armor</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Leaderboards</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>StorageUtilsShaded</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../StorageUtils/target/StorageUtils-1.0-shaded.jar</systemPath>
</dependency>
<dependency>
<groupId>com.golfing.wineSpigot</groupId>
<artifactId>winespigot</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../.lib/WineSpigot-V1.4.4.3.jar</systemPath>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,67 @@
package net.crankedpvp.crankedpets;
import de.tr7zw.nbtapi.NBTItem;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.Material;
import org.bukkit.inventory.ItemStack;
import java.util.List;
public class CollarAPI {
public static ItemStack buildCollar(int amount) {
ItemBuilder itemBuilder = new ItemBuilder(Material.LEASH, amount, (short)0, "&6&lPet Collar",
"&7Drag n' Drop this collar onto",
"&7any inventory pet to ensure",
"&7it stays by your side after death");
NBTItem nbtItem = new NBTItem(itemBuilder.colorize().build());
nbtItem.setString("crankedCustomItem", "petCollar");
return nbtItem.getItem();
}
public static ItemStack buildCollar() {
return buildCollar(1);
}
public static ItemStack buildLeash() {
return buildCollar(1);
}
public static boolean isPetCollar(ItemStack itemStack) {
if(ItemUtils.isAirOrNull(itemStack)) return false;
if(itemStack.getType() != Material.LEASH) return false;
NBTItem nbtItem = new NBTItem(itemStack);
if(!nbtItem.hasNBTData() || !nbtItem.hasKey("crankedCustomItem")) return false;
return nbtItem.getString("crankedCustomItem").equals("petCollar");
}
public static boolean hasPetCollar(ItemStack itemStack) {
if(itemStack == null) return false;
NBTItem nbtItem = new NBTItem(itemStack);
if(!nbtItem.hasNBTData()) return false;
if(!nbtItem.hasKey("collarEquipped")) return false;
return nbtItem.getBoolean("collarEquipped");
}
public static ItemStack addCollarToPet(ItemStack itemStack) {
if(itemStack == null) return null;
ItemBuilder itemBuilder = new ItemBuilder(itemStack);
itemBuilder.addLore("&6&l*COLLAR*");
NBTItem nbtItem = new NBTItem(itemBuilder.colorize().build());
nbtItem.setBoolean("collarEquipped", true);
return nbtItem.getItem();
}
public static ItemStack removePetCollarFromItem(ItemStack itemStack) {
if(itemStack == null) return null;
ItemBuilder itemBuilder = new ItemBuilder(itemStack);
List<String> lore = itemBuilder.getLore();
lore.removeIf(line -> line.equals(CC.translate("&6&l*COLLAR*")));
itemBuilder.setLore(lore);
NBTItem nbtItem = new NBTItem(itemBuilder.colorize().build());
nbtItem.setBoolean("holyWhiteScrollEquipped", false);
return nbtItem.getItem();
}
}
@@ -0,0 +1,74 @@
package net.crankedpvp.crankedpets;
import lombok.Getter;
import me.mattstudios.mf.base.CommandManager;
import me.mattstudios.mf.base.components.TypeResult;
import net.crankedpvp.crankedpets.commands.AdminPetCommand;
import net.crankedpvp.crankedpets.commands.PetsCommand;
import net.crankedpvp.crankedpets.language.LanguageHandler;
import net.crankedpvp.crankedpets.listeners.ApplyPetCollarListener;
import net.crankedpvp.crankedpets.listeners.PetListeners;
import net.crankedpvp.crankedpets.listeners.PlayerDeathListener;
import net.crankedpvp.crankedpets.managers.PassivePetManager;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetsRegister;
import net.crankedpvp.crankedpets.struct.config.PetConfigManager;
import net.crankedpvp.crankedpets.tasks.PassivePetTask;
import net.crankedpvp.crankedutils.utils.PluginUtils;
import org.bukkit.Bukkit;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.stream.Collectors;
@Getter
public class CrankedPets extends JavaPlugin {
@Getter
public static CrankedPets instance;
public LanguageHandler languageHandler;
private PetsRegister petRegister;
private CommandManager commandManager;
private PetConfigManager petConfigManager;
private PassivePetManager passivePetManager;
@Override
public void onEnable() {
instance = this;
this.languageHandler = new LanguageHandler(this);
this.languageHandler.load();
this.petRegister = new PetsRegister();
this.petRegister.initialize();
this.petConfigManager = new PetConfigManager(this);
this.petConfigManager.setupFiles();
this.commandManager = new CommandManager(this);
this.registerCommandParameters();
this.registerCommandCompletion();
this.commandManager.register(new AdminPetCommand(this));
this.commandManager.register(new PetsCommand());
this.passivePetManager = new PassivePetManager();
PluginUtils.registerListeners(this, new PetListeners(), new ApplyPetCollarListener(this), new PlayerDeathListener(this));
Bukkit.getScheduler().scheduleSyncRepeatingTask(this, new PassivePetTask(), 60L, 20L);
}
private void registerCommandParameters() {
this.commandManager.getParameterHandler().register(Pet.class, argument -> {
Pet pet = this.petRegister.getPetFromID(this.petRegister.getPetIDFromName(String.valueOf(argument)));
return new TypeResult(pet, argument);
});
}
private void registerCommandCompletion() {
this.commandManager.getCompletionHandler().register("#pets", input -> this.petRegister.getPets().stream().map(Pet::getID).collect(Collectors.toList()));
}
@Override
public void onDisable() {
instance = null;
}
}
@@ -0,0 +1,73 @@
package net.crankedpvp.crankedpets;
import de.tr7zw.nbtapi.NBTCompound;
import de.tr7zw.nbtapi.NBTItem;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetsRegister;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class CrankedPetsAPI {
public static boolean isPet(ItemStack itemStack) {
if (!ItemUtils.isSkull(itemStack)) return false;
NBTItem nbtItem = new NBTItem(itemStack);
if (!nbtItem.hasKey("cosmicType")) return false;
return nbtItem.getString("cosmicType").equals("pet");
}
public static Pet getPetFromItem(ItemStack itemStack) {
NBTItem nbtItem = new NBTItem(itemStack);
NBTCompound compound = nbtItem.getCompound("cosmicData");
String petId = compound.getString("petType");
return PetsRegister.getInstance().getPetFromID(petId);
}
public static boolean hasPetInInventory(Player player, Pet pet) {
for (ItemStack item : player.getInventory().getContents()) {
if (isPet(item)) {
Pet foundPet = getPetFromItem(item);
if (foundPet.getID().equals(pet.getID())) {
return true;
}
}
}
return false;
}
/* public static boolean isPetOnCooldown(ItemStack item) {
Pet pet = getPetFromItem(item);
NBTItem nbtItem = new NBTItem(item);
NBTCompound compound = nbtItem.getCompound("cosmicData");
long lastUsed = compound.getLong("lastUsed");
return lastUsed+(pet.getCooldownInSeconds()* 1000L) > System.currentTimeMillis();
}
public static void enterCooldown(Player player) {
NBTItem nbtItem = new NBTItem(player.getItemInHand());
NBTCompound compound = nbtItem.getCompound("cosmicData");
compound.setLong("lastUsed", System.currentTimeMillis());
player.setItemInHand(nbtItem.getItem());
}
public static long getTimeLeftMs(ItemStack item) {
Pet pet = getPetFromItem(item);
NBTItem nbtItem = new NBTItem(item);
NBTCompound compound = nbtItem.getCompound("cosmicData");
long lastUsed = compound.getLong("lastUsed");
return lastUsed+(pet.getCooldownInSeconds()* 1000L) - System.currentTimeMillis();
}*/
}
@@ -0,0 +1,79 @@
package net.crankedpvp.crankedpets.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedpets.CollarAPI;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.CrankedPetsAPI;
import net.crankedpvp.crankedpets.language.Language;
import net.crankedpvp.crankedpets.language.LanguageHandler;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.config.PetConfigManager;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("cp")
public class AdminPetCommand extends CommandBase {
private final LanguageHandler languageHandler;
private final PetConfigManager petConfigManager;
public AdminPetCommand(CrankedPets plugin) {
this.languageHandler = plugin.getLanguageHandler();
this.petConfigManager = plugin.getPetConfigManager();
}
@Default
@Permission("cranked.admin")
public void mainCommand(CommandSender sender) {
Language.ADMIN_COMMAND_HELP.send(sender);
}
@SubCommand("pet")
@WrongUsage("&cUsage: /cp pet <pet> [player]")
@Permission("cranked.admin")
public void petCommand(CommandSender sender, @Completion("#pets") Pet pet, @Completion("#players") @Optional Player player) {
if (pet == null) {
Language.INVALID_PET.send(sender);
return;
}
if (player != null) {
player.getInventory().addItem(pet.getItem());
return;
}
if (sender instanceof Player) {
((Player) sender).getInventory().addItem(pet.getItem());
}
}
@SubCommand("leash")
@Alias("collar")
@WrongUsage("&cUsage: /cp leash [player]")
@Permission("cranked.admin")
public void leashCommand(final CommandSender commandSender, @Optional @Completion("#players") Player receiver) {
if (receiver != null) {
receiver.getInventory().addItem(CollarAPI.buildCollar());
return;
}
if (commandSender instanceof Player) {
((Player) commandSender).getInventory().addItem(CollarAPI.buildCollar());
}
}
@SubCommand("reload")
@WrongUsage("&cUsage: /cp reload")
@Permission("cranked.admin")
public void reloadCommand(Player sender) {
Language.ADMIN_RELOADING.send(sender);
long then = System.currentTimeMillis();
this.languageHandler.load();
this.petConfigManager.reloadFiles();
long diff = System.currentTimeMillis() - then;
Language.ADMIN_RELOADED.send(sender, str -> str.replace("%took%", String.valueOf(diff)));
}
}
@@ -0,0 +1,24 @@
package net.crankedpvp.crankedpets.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedpets.inventory.PetsInventory;
import net.crankedpvp.crankedpets.inventory.PetsMainInventory;
import org.bukkit.Sound;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("pets")
public class PetsCommand extends CommandBase {
@Default
public void mainCommand(CommandSender sender) {
if(!(sender instanceof Player)) return;
Player player = (Player)sender;
PetsMainInventory petsInventory = new PetsMainInventory();
petsInventory.getUI().open(player);
player.playSound(player.getLocation(), Sound.CHEST_OPEN, 2.0F, 2.0F);
}
}
@@ -0,0 +1,9 @@
package net.crankedpvp.crankedpets.cooldowns;
import net.crankedpvp.crankedutils.utils.cache.cooldown.CurrentCooldown;
public class PetCooldown extends CurrentCooldown {
public PetCooldown(String name, int durationInSeconds) {
super(name, durationInSeconds);
}
}
@@ -0,0 +1,38 @@
package net.crankedpvp.crankedpets.events;
import lombok.Getter;
import lombok.Setter;
import net.crankedpvp.crankedpets.struct.Pet;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerInteractEvent;
@Getter
public class PetUseEvent extends Event implements Cancellable {
private static final HandlerList handlers = new HandlerList();
@Setter
private boolean cancelled;
private final Player player;
private final Pet pet;
private final PlayerInteractEvent interacteEvent;
public PetUseEvent(Player player, Pet pet, PlayerInteractEvent event) {
this.player = player;
this.pet = pet;
this.interacteEvent = event;
this.cancelled = false;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
@@ -0,0 +1,67 @@
package net.crankedpvp.crankedpets.inventory;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.Collection;
public class PetsInventory {
private final Gui petsInventory;
public Gui getUI() {
return this.petsInventory;
}
Collection<Pet> pets = CrankedPets.getInstance().getPetRegister().getPets();
public PetsInventory(PetType type) {
this.petsInventory = new Gui(1, type + " Pets");
this.petsInventory.setDefaultClickAction(event -> event.setCancelled(true));
for(Pet pet : pets) {
if(!pet.getPetType().equals(type)) continue;
this.petsInventory.addItem(new GuiItem(pet.getItem(), event -> {
if(event.getWhoClicked().hasPermission("cranked.admin")) event.getWhoClicked().getInventory().addItem(pet.getItem());
}));
this.petsInventory.setItem(8, new GuiItem(this.createGoBackItem(), event -> {
event.getWhoClicked().closeInventory();
PetsMainInventory petsMainInventory = new PetsMainInventory();
petsMainInventory.getUI().open(event.getWhoClicked());
}));
}
}
private ItemStack createGoBackItem() {
ItemBuilder itemBuilder = new ItemBuilder(Material.ARROW, "&bGo Back", "&7Go back to select",
"&7a different tier.");
return itemBuilder.colorize().build();
}
/*
private ItemStack createInformationItem() {
return new ItemBuilder(Material.BOOK, "&a&lCranked Pets",
"&7Pets are items which can be USED by",
"&7a player to give them buffs.",
"",
"&7Pets can be obtained through",
"&7lootboxes, the underworld, envoys",
"&7and much more.",
"",
"&7Passive pets can be kept inside",
"&7your inventory and their effects",
"&7will keep procing")
.colorize().build();
}
*/
}
@@ -0,0 +1,98 @@
package net.crankedpvp.crankedpets.inventory;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.Collection;
public class PetsMainInventory {
private final Gui petsMainInventory;
public Gui getUI() {
return this.petsMainInventory;
}
Collection<Pet> pets = CrankedPets.getInstance().getPetRegister().getPets();
public PetsMainInventory() {
this.petsMainInventory = new Gui(1, "Cranked Pets");
this.petsMainInventory.setDefaultClickAction(event -> event.setCancelled(true));
/*
this.petsMainInventory.setItem(1, new GuiItem(this.buildItemForType(PetType.COMMON), event -> {
event.getWhoClicked().closeInventory();
PetsInventory petsInventory = new PetsInventory(PetType.COMMON);
petsInventory.getUI().open(event.getWhoClicked());
}));
*/
this.petsMainInventory.setItem(2, new GuiItem(this.buildItemForType(PetType.RARE), event -> {
event.getWhoClicked().closeInventory();
PetsInventory petsInventory = new PetsInventory(PetType.RARE);
petsInventory.getUI().open(event.getWhoClicked());
}));
this.petsMainInventory.setItem(4, new GuiItem(this.buildItemForType(PetType.MYTHIC), event -> {
event.getWhoClicked().closeInventory();
PetsInventory petsInventory = new PetsInventory(PetType.MYTHIC);
petsInventory.getUI().open(event.getWhoClicked());
}));
/*
this.petsMainInventory.setItem(6, new GuiItem(this.buildItemForType(PetType.SEASON), event -> {
event.getWhoClicked().closeInventory();
PetsInventory petsInventory = new PetsInventory(PetType.SEASON);
petsInventory.getUI().open(event.getWhoClicked());
}));
*/
this.petsMainInventory.setItem(6, new GuiItem(this.buildItemForType(PetType.CURSED), event -> {
event.getWhoClicked().closeInventory();
PetsInventory petsInventory = new PetsInventory(PetType.CURSED);
petsInventory.getUI().open(event.getWhoClicked());
}));
}
private ItemStack buildItemForType(PetType petType) {
return new ItemBuilder(Material.STAINED_GLASS_PANE, 1, petType.getData())
.setName(petType.getName() + " &7Pets")
.setLore(
"",
"&fClick me to view all of the",
petType.getName() + " &fpets",
""
).colorize().build();
}
private ItemStack createInformationItem() {
return new ItemBuilder(Material.BOOK, "&a&lCranked Pets",
"&7Pets are items which can be USED by",
"&7a player to give them buffs.",
"",
"&7Pets can be obtained through",
"&7lootboxes, the underworld, envoys",
"&7and much more.",
"",
"&7Passive pets can be kept inside",
"&7your inventory and their effects",
"&7will keep procing")
.colorize().build();
}
private ItemStack createFillerItem() {
ItemStack item = new ItemStack(Material.STAINED_GLASS_PANE, 1, DyeColor.GRAY.getData());
ItemMeta meta = item.getItemMeta();
meta.setDisplayName(CC.translate("&cCranked&fPvP"));
item.setItemMeta(meta);
return item;
}
}
@@ -0,0 +1,102 @@
package net.crankedpvp.crankedpets.language;
import com.google.common.collect.ImmutableList;
import net.crankedpvp.crankedutils.utils.CC;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
public enum Language {
ADMIN_COMMAND_HELP,
INVALID_PET,
PASSIVE_PET,
PVP_DISABLED_REGION,
ADMIN_RELOADING,
ADMIN_RELOADED,
PET_ON_COOLDOWN,
PET_USED,
;
private String value;
private ImmutableList<String> valueList;
public String getValue() {
return value != null ? value : this.name();
}
public String getValue(UnaryOperator<String> function) {
return value != null ? function.apply(value) : this.name();
}
public String getPath() {
return this.name();
}
public List<String> getValuesAsList() {
return valueList;
}
public List<String> getValuesAsList(String oldString, String newString) {
List<String> list = new ArrayList<>(valueList);
list.replaceAll(s -> s.replace(oldString, newString));
return list;
}
void setValue(String value) {
this.value = CC.translate(value);
List<String> tempList = Arrays.stream(StringUtils.split(value, System.lineSeparator()))
.map(CC::translate)
.collect(Collectors.toList());
valueList = ImmutableList.copyOf(tempList);
}
void setValue(List<String> valueList) {
value = CC.translate(valueList.parallelStream().collect(Collectors.joining(System.lineSeparator())));
List<String> tempList = valueList.stream()
.map(CC::translate)
.collect(Collectors.toList());
this.valueList = ImmutableList.copyOf(tempList);
}
public void send(CommandSender sender, UnaryOperator<String> function) {
sender.sendMessage(CC.translate(getValue(function)));
}
public void send(CommandSender sender) {
sender.sendMessage(CC.translate(getValue()));
}
public void send(List<CommandSender> senders, UnaryOperator<String> function) {
String msg = CC.translate(getValue(function));
senders.forEach(sender -> sender.sendMessage(msg));
}
public void sendPlayers(List<Player> senders, UnaryOperator<String> function) {
String msg = CC.translate(getValue(function));
senders.forEach(sender -> sender.sendMessage(msg));
}
public void send(CommandSender ...senders) {
String msg = CC.translate(getValue());
Arrays.asList(senders).forEach(sender -> sender.sendMessage(msg));
}
public String getMessage() {
return CC.translate(getValue());
}
public String getMessage(UnaryOperator<String> function) {
return CC.translate(getValue(function));
}
}
@@ -0,0 +1,82 @@
package net.crankedpvp.crankedpets.language;
import net.crankedpvp.crankedpets.CrankedPets;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public final class LanguageHandler {
private final File file;
private final FileConfiguration config;
private final String path;
private final CrankedPets plugin;
public LanguageHandler(CrankedPets plugin) {
this.plugin = plugin;
this.path = "language.yml";
file = new File(plugin.getDataFolder(), path);
config = new YamlConfiguration();
}
public void load() {
this.saveDefaultConfig();
this.loadConfigFromDisk();
this.copyDefaults();
this.save();
this.loadConfigFromDisk();
this.loadLangMessages();
}
private void loadLangMessages() {
for (Language entry : Language.values()) {
String path = entry.getPath();
if (config.isList(path)) {
entry.setValue(config.getStringList(path));
continue;
}
entry.setValue(config.getString(path));
}
}
private void loadConfigFromDisk() {
try {
config.load(file);
} catch (IOException | InvalidConfigurationException e) {
e.printStackTrace();
}
}
public void save() {
try {
config.save(file);
} catch (IOException e) {
plugin.getLogger().severe("Could not save config file for " + file.getPath() + "!");
e.printStackTrace();
}
}
private void copyDefaults() {
InputStream defConfig = plugin.getResource(this.path);
if (defConfig != null) {
config.setDefaults(YamlConfiguration.loadConfiguration(new InputStreamReader(defConfig)));
}
config.options().copyDefaults(true);
}
private void saveDefaultConfig() {
if (!file.exists()) {
file.getParentFile().mkdirs();
plugin.saveResource(file.getName(),false);
}
}
}
@@ -0,0 +1,54 @@
package net.crankedpvp.crankedpets.listeners;
import net.crankedpvp.crankedpets.CollarAPI;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.CrankedPetsAPI;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class ApplyPetCollarListener implements Listener {
private CrankedPets plugin;
public ApplyPetCollarListener(CrankedPets plugin) {
this.plugin = plugin;
}
@EventHandler
public void applyPetCollar(InventoryClickEvent event) {
if(event.getCurrentItem() == null || event.getCurrentItem().getType() == Material.AIR || event.getCursor() == null || event.getCursor().getType() == Material.AIR) return;
Player player = (Player) event.getWhoClicked();
if(!CollarAPI.isPetCollar(event.getCursor())) return;
event.setCancelled(true);
if(!CrankedPetsAPI.isPet(event.getCurrentItem())) {
player.sendMessage(CC.translate("&c&l(!) &cYou cannot apply a pet collar to this item"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
if(CollarAPI.hasPetCollar(event.getCurrentItem())) {
player.sendMessage(CC.translate("&c&l(!) &cThis pet already has a collar applied"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
ItemStack cursor = event.getCursor();
int amount = cursor.getAmount();
if (amount <= 1) {
event.setCursor(null);
} else {
cursor.setAmount(amount - 1);
event.setCursor(cursor);
}
event.setCurrentItem(CollarAPI.addCollarToPet(event.getCurrentItem()));
player.sendMessage(CC.translate("&a&l(!) &aYou have successfully applied a pet collar to your pet"));
player.playSound(player.getLocation(), Sound.SUCCESSFUL_HIT, 2.0F, 2.0F);
}
}
@@ -0,0 +1,75 @@
package net.crankedpvp.crankedpets.listeners;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.CrankedPetsAPI;
import net.crankedpvp.crankedpets.events.PetUseEvent;
import net.crankedpvp.crankedpets.language.Language;
import net.crankedpvp.crankedpets.struct.PassivePet;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.WorldGuardUtils;
import net.crankedpvp.leaderboards.LeaderboardsAPI;
import org.bukkit.Bukkit;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PotionEffectAddEvent;
import org.bukkit.event.player.PlayerInteractEvent;
public class PetListeners implements Listener {
@EventHandler
public void onPlayerInteractWithPet(PlayerInteractEvent event) {
if (!CrankedPetsAPI.isPet(event.getItem())) return;
Player player = event.getPlayer();
Pet pet = CrankedPetsAPI.getPetFromItem(event.getItem());
if (!WorldGuardUtils.canPvPInRegion(player) && !(pet instanceof PassivePet)) {
Language.PVP_DISABLED_REGION.send(player);
event.setCancelled(true);
return;
}
if (pet instanceof PassivePet) {
Language.PASSIVE_PET.send(player);
} else {
PetUseEvent petUseEvent = new PetUseEvent(player, pet, event);
Bukkit.getServer().getPluginManager().callEvent(petUseEvent);
if (petUseEvent.isCancelled()) {
return;
}
if (CooldownUtils.isCooldownActive(player, pet.getID())) {
String msg = Language.PET_ON_COOLDOWN.getMessage();
msg = msg.replace("%timeLeft%", CooldownUtils.getFormattedCooldown(player, pet.getID()));
msg = msg.replace("%pet%", pet.getDisplayName());
player.sendMessage(CC.translate(msg));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
event.setCancelled(true);
return;
}
pet.procAbility(player);
String msg = Language.PET_USED.getMessage();
msg = msg.replace("%pet%", pet.getDisplayName());
player.sendMessage(CC.translate(msg));
player.playSound(player.getLocation(), Sound.SUCCESSFUL_HIT, 2.0F, 2.0F);
LeaderboardsAPI.getPlayerStats(player.getUniqueId()).incrementPetsUsed();
}
event.setCancelled(true);
}
@EventHandler
public void onCowEffect(PotionEffectAddEvent event) {
if (event.getEntity() instanceof Player) {
if (PotionEffectUtils.getDebuffsList().contains(event.getEffect().getType()) && CrankedPetsAPI.hasPetInInventory((Player) event.getEntity(), CrankedPets.getInstance().getPetRegister().getPetFromID("cow"))) {
event.setCancelled(true);
}
}
}
}
@@ -0,0 +1,51 @@
package net.crankedpvp.crankedpets.listeners;
import net.crankedpvp.crankedpets.CollarAPI;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class PlayerDeathListener implements Listener {
private final CrankedPets plugin;
private final List<String> disabledWorlds = new ArrayList<>();
public PlayerDeathListener(CrankedPets plugin) {
this.plugin = plugin;
disabledWorlds.add("world_nether");
disabledWorlds.add("world_duels");
//disabledWorlds.add(ArcadeAPI.WORLD_NAME);
}
@EventHandler(priority = EventPriority.LOWEST)
public void playerDeathListener(PlayerDeathEvent event) {
if(event.getEntity() == null) return;
if (disabledWorlds.contains(event.getEntity().getWorld().getName())) return;
final Player victim = event.getEntity();
List<ItemStack> collaredPets = new ArrayList<>(event.getDrops())
.stream()
.filter(CollarAPI::hasPetCollar)
.collect(Collectors.toList());
if(collaredPets.isEmpty()) return;
event.getDrops().removeAll(collaredPets);
List<ItemStack> finalCollaredPets = collaredPets.stream().map(CollarAPI::removePetCollarFromItem).collect(Collectors.toList());
Bukkit.getScheduler().runTaskLater(plugin, () -> finalCollaredPets.forEach(itemStack -> {
victim.getInventory().addItem(itemStack);
victim.sendMessage(CC.translate("&a&l+ &6&l*COLLAR* PROTECTION &8➥ " + itemStack.getItemMeta().getDisplayName()));
}), 1L);
}
}
@@ -0,0 +1,56 @@
package net.crankedpvp.crankedpets.managers;
import lombok.Getter;
import net.crankedpvp.crankedpets.CrankedPetsAPI;
import net.crankedpvp.crankedpets.struct.PassivePet;
import net.crankedpvp.crankedpets.struct.Pet;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.*;
public class PassivePetManager {
@Getter
public Map<UUID, List<Pet>> passivePetsMap = new HashMap<>();
public List<Pet> getPassivePets(Player player) {
if (!passivePetsMap.containsKey(player.getUniqueId())) {
List<Pet> passivePets = new ArrayList<>();
passivePetsMap.put(player.getUniqueId(), passivePets);
}
return passivePetsMap.get(player.getUniqueId());
}
public void scanPlayerInventory(Player player) {
if (player.getInventory().getContents().length == 0) return;
List<Pet> pets = getPassivePets(player);
pets.clear();
for (ItemStack item : player.getInventory().getContents().clone()) {
if (CrankedPetsAPI.isPet(item)) {
Pet pet = CrankedPetsAPI.getPetFromItem(item);
if (pet instanceof PassivePet) {
if (pets.contains(pet)) continue;
pets.add(pet);
}
}
}
passivePetsMap.put(player.getUniqueId(), pets);
}
public List<Pet> getCurrentPassivePets(Player player) {
if (player.getInventory().getContents().length == 0) return Collections.emptyList();
List<Pet> pets = new ArrayList<>();
for (ItemStack item : player.getInventory().getContents().clone()) {
if (CrankedPetsAPI.isPet(item)) {
Pet pet = CrankedPetsAPI.getPetFromItem(item);
if (pet instanceof PassivePet) {
if (pets.contains(pet)) continue;
pets.add(pet);
}
}
}
return pets;
}
}
@@ -0,0 +1,166 @@
package net.crankedpvp.crankedpets.pets;
import com.avaje.ebean.validation.NotNull;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.CrankedUtils;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.DamageHandler;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.metadata.FixedMetadataValue;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitScheduler;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class CagePet extends Pet {
private final List<Location> locations = new ArrayList<>();
private final DamageHandler damageHandler = CrankedUtils.getInstance().getDamageHandler();
@ConfigValue
private final int cageDuration = 7;
@ConfigValue
private int cooldown = 150;
@Override
public String getName() {
return "Cage";
}
@Override
public String getDisplayName() {
return "&4&lCage Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZDhlNjUyNTM4NWY3NDgzMjJlZWNjNDE2ODliNjkwYWExZWJiYjIxNzJlYzJjNGEyZWFjMTRmMjJkOTRlZTNiYSJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fSummons a dimensional",
"&fcage for 7 seconds."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oA dangerous pet created",
"&7&oby prisoners that",
"&7&oescaped from the metal cages."
);
}
@Override
public PetType getPetType() {
return PetType.CURSED;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
player.playSound(player.getLocation(), Sound.DIG_SNOW, 1.1F, 3.0F);
player.playSound(player.getLocation(), Sound.WITHER_SHOOT, 1.1F, 3.0F);
cagePlayer(player);
}
public void cagePlayer(Player affected) {
final List<Location> list = new ArrayList<Location>();
final BukkitScheduler scheduler = Bukkit.getScheduler();
final Location baseLocation = affected.getLocation();
list.addAll(setInside(baseLocation.clone().add(0.0, -1.0, 0.0), Material.OBSIDIAN));
list.addAll(setInside(baseLocation.clone().add(0.0, 3.0, 0.0), Material.OBSIDIAN));
list.addAll(setOutside(baseLocation.clone().add(0.0, -1.0, 0.0), Material.OBSIDIAN));
list.addAll(setOutside(baseLocation.clone().add(0.0, 3.0, 0.0), Material.OBSIDIAN));
list.addAll(setOutside(baseLocation.clone().add(0.0, 0.0, 0.0), Material.IRON_FENCE));
list.addAll(setOutside(baseLocation.clone().add(0.0, 1.0, 0.0), Material.IRON_FENCE));
list.addAll(setOutside(baseLocation.clone().add(0.0, 2.0, 0.0), Material.IRON_FENCE));
locations.addAll(list);
scheduler.scheduleSyncDelayedTask(CrankedPets.getInstance(), (Runnable)new BukkitRunnable() {
int count = 0;
public void run() {
if (this.count >= cageDuration) {
removeBlocks(list);
this.cancel();
}
if (affected.getHealth() <= 0.0 || affected.isDead()) {
removeBlocks(list);
this.cancel();
}
++this.count;
}
}.runTaskTimer(CrankedPets.getInstance(), 20L, 20L));
}
private static List<Location> setInside(Location baseLocation, Material material) {
List<Location> locs = new ArrayList<>(Arrays.asList(baseLocation, baseLocation
.clone().add(-1.0D, 0.0D, 0.0D), baseLocation
.clone().add(0.0D, 0.0D, 1.0D), baseLocation
.clone().add(-1.0D, 0.0D, 1.0D)));
return setWithLocations(material, locs);
}
private List<Location> setOutside(Location baseLocation, Material material) {
List<Location> locs = new ArrayList<>(Arrays.asList(baseLocation
.clone().add(0.0D, 0.0D, -1.0D), baseLocation
.clone().add(1.0D, 0.0D, 0.0D), baseLocation
.clone().add(1.0D, 0.0D, -1.0D), baseLocation
.clone().add(1.0D, 0.0D, 1.0D), baseLocation
.clone().add(1.0D, 0.0D, 2.0D), baseLocation
.clone().add(0.0D, 0.0D, 2.0D), baseLocation
.clone().add(-1.0D, 0.0D, 2.0D), baseLocation
.clone().add(-2.0D, 0.0D, 2.0D), baseLocation
.clone().add(-2.0D, 0.0D, 0.0D), baseLocation
.clone().add(-2.0D, 0.0D, 1.0D),
baseLocation
.clone().add(-2.0D, 0.0D, -1.0D), baseLocation
.clone().add(-1.0D, 0.0D, -1.0D)));
return setWithLocations(material, locs);
}
public void removeBlocks(List<Location> list) {
for (Location location : list) {
Block block = location.getBlock();
if (block != null) {
block.setType(Material.AIR);
locations.remove(location);
location.getBlock().removeMetadata("cage", CrankedPets.getInstance());
}
}
}
@NotNull
private static List<Location> setWithLocations(Material material, List<Location> locs) {
List<Location> filteredLocations = new ArrayList<>();
for (Location loc : locs) {
if (loc.getBlock().getType() == Material.AIR) {
filteredLocations.add(loc);
loc.getBlock().setType(material);
loc.getBlock().setMetadata("cage", new FixedMetadataValue(CrankedPets.getInstance(), "cage"));
}
}
return filteredLocations;
}
}
@@ -0,0 +1,71 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.struct.PassivePet;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
import java.util.Arrays;
import java.util.List;
public class ChickenPet extends Pet implements PassivePet {
@Override
public String getName() {
return "Chicken";
}
@Override
public String getDisplayName() {
return "&b&lChicken Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvY2EzNTgyY2U0ODg5MzMzZGFkMzI5ZTRlMjQzNzJhMDNhNWRhYTJjMzQyODBjNTYyNTZhZjUyODNlZGIwNDNmOCJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fGain a permanent speed effect"
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oYou shall run fast by",
"&7&omy side, flap flap."
);
}
@Override
public PetType getPetType() {
return PetType.RARE;
}
@Override
public int getCooldownInSeconds() {
return 300;
}
@Override
public void procAbility(Player player) {
}
@Override
public void passiveAbility(Player player) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.SPEED, 4, "ChickenPet");
}
@Override
public void disablePassiveAbility(Player player) {
PotionEffectUtils.removePotionEffect(player, "ChickenPet");
}
}
@@ -0,0 +1,67 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.struct.PassivePet;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import org.bukkit.entity.Player;
import java.util.Arrays;
import java.util.List;
public class CowPet extends Pet implements PassivePet {
@Override
public String getName() {
return "Cow";
}
@Override
public String getDisplayName() {
return "&4&lCow Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZDY1NTE4NDA5NTVmNTI0MzY3NTgwZjExYjM1MjI4OTM4YjY3ODYzOTdhOGYyZThjOGNjNmIwZWIwMWI1ZGIzZCJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fNegate all negative",
"&fpotion effects."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oWho would harm a cow",
"&7&owhen it did nothing wrong",
"&7&oto them. It's just tasty."
);
}
@Override
public PetType getPetType() {
return PetType.CURSED;
}
@Override
public int getCooldownInSeconds() {
return 300;
}
@Override
public void procAbility(Player player) {
}
@Override
public void passiveAbility(Player player) {
}
@Override
public void disablePassiveAbility(Player player) {
}
}
@@ -0,0 +1,90 @@
package net.crankedpvp.crankedpets.pets;
import lombok.Getter;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.CrankedPetsAPI;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
public class ExperiencePet extends Pet {
@Getter
private List<UUID> playersUsingExpPet = new ArrayList<>();
@ConfigValue
@Getter
private double expMultiplier = 2.5;
@ConfigValue
private int duration = 300;
@ConfigValue
private int cooldown = 1500;
@Override
public String getName() {
return "Experience";
}
@Override
public String getDisplayName() {
return "&b&lExperience Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjIwNjU3ZTI0YjU2ZTFiMmY4ZmMyMTlkYTFkZTc4OGMwYzI0ZjM2Mzg4YjFhNDA5ZDBjZDJkOGRiYTQ0YWEzYiJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fGain an EXP multiplier",
"&ffor 5 minutes."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oAn experimental pet dedicated",
"&7&oto boosting the experience",
"&7&oof it's empowered owner."
);
}
@Override
public PetType getPetType() {
return PetType.RARE;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
final UUID uuid = player.getUniqueId();
playersUsingExpPet.add(uuid);
Bukkit.getScheduler().runTaskLaterAsynchronously(CrankedPets.getInstance(), () -> {
if (player.isOnline()) {
player.sendMessage(CC.translate("&d&lPets &8➥ &7Your experience pet ability has &c&lEXPIRED&7!"));
}
playersUsingExpPet.remove(uuid);
}, 20L * duration);
}
}
@@ -0,0 +1,75 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedarmor.CrankedArmor;
import net.crankedpvp.crankedarmor.CrankedArmorAPI;
import net.crankedpvp.crankedpets.CrankedPetsAPI;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
import java.util.*;
public class IronGolemPet extends Pet {
@ConfigValue
private int potionLevel = 5;
@ConfigValue
private int duration = 10;
@ConfigValue
private int cooldown = 300;
@Override
public String getName() {
return "Iron Golem";
}
@Override
public String getDisplayName() {
return "&e&lIron Golem Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTIyY2M2ZWEzODdmYWQ1ZjI1Y2VmMjU3YTgzMWVhOGQ5N2UwZGZhMmMzNDU0MWZkOGM3ODMwMjAzOGFkMWZiMyJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fGain temporary absorption hearts."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oA heavy and bulky pet",
"&7&ocreated to protect it's owner.");
}
@Override
public PetType getPetType() {
return PetType.MYTHIC;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
int potionLevel = this.potionLevel;
if(Objects.equals(CrankedArmorAPI.getCurrentArmorSet(player), CrankedArmor.getInstance().getArmorSetRegister().getArmorSetFromID("reaper")))
potionLevel += 2;
PotionEffectUtils.addExtraPotionEffect(player, PotionEffectType.ABSORPTION, potionLevel, "IronGolemPet", duration);
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
}
}
@@ -0,0 +1,94 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedmasks.CrankedMasks;
import net.crankedpvp.crankedmasks.CrankedMasksAPI;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.struct.PassivePet;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import java.util.Arrays;
import java.util.List;
public class KrakenPet extends Pet implements PassivePet, Listener {
@ConfigValue
private int outgoingDamageWhileInWater;
@Override
public String getName() {
return "Kraken";
}
@Override
public String getDisplayName() {
return "&b&lKraken Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOTUzMGQyMDY1MWFhMzhjMGU4MmMyZGFmYzM1MDQ0NDNjYzZhNGI5ZTZlZWQxNDViNmVkY2U5OTQ3OWNlODQ4ZiJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fDeal more outgoing damage",
"&fwhile submerged in water"
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oA legendary sea monster",
"&7&oin the form of a pocket",
"&7&osized inventory pet."
);
}
@Override
public PetType getPetType() {
return PetType.RARE;
}
@Override
public int getCooldownInSeconds() {
return 300;
}
@Override
public void procAbility(Player player) {
}
@Override
public void passiveAbility(Player player) {
}
@Override
public void disablePassiveAbility(Player player) {
}
@EventHandler
public void moreDamage(EntityDamageByEntityEvent event) {
if(event.getDamager() == null) return;
if(event.getEntity() == null) return;
if (!(event.getDamager() instanceof Player)) return;
Player damager = (Player) event.getDamager();
if(CrankedPets.getInstance().getPassivePetManager().getPassivePets(damager).contains(this)) {
if(event.getEntity() instanceof Player) {
Player victim = (Player) event.getEntity();
if(CrankedMasksAPI.hasMaskEquipped(victim, CrankedMasks.getInstance().getMasksRegister().getMaskFromID("leviathan"))) return;
}
if(damager.getLocation().getBlock().isLiquid()) {
super.getDamageHandler().increaseDamage(this.outgoingDamageWhileInWater, event, "KrakenPet");
}
}
}
}
@@ -0,0 +1,67 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.struct.PassivePet;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
import java.util.Arrays;
import java.util.List;
public class PigPet extends Pet implements PassivePet {
@Override
public String getName() {
return "Pig";
}
@Override
public String getDisplayName() {
return "&b&lPig Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYmVlODUxNDg5MmYzZDc4YTMyZTg0NTZmY2JiOGM2MDgxZTIxYjI0NmQ4MmYzOThiZDk2OWZlYzE5ZDNjMjdiMyJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fGain a permanent saturation effect"
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
);
}
@Override
public PetType getPetType() {
return PetType.RARE;
}
@Override
public int getCooldownInSeconds() {
return 300;
}
@Override
public void procAbility(Player player) {
}
@Override
public void passiveAbility(Player player) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.SATURATION, 1, "Pig Pet");
}
@Override
public void disablePassiveAbility(Player player) {
PotionEffectUtils.removePotionEffect(player, "Pig Pet");
}
}
@@ -0,0 +1,74 @@
package net.crankedpvp.crankedpets.pets;
import com.massivecraft.factions.util.RelationUtil;
import net.crankedpvp.crankedarmor.CrankedArmor;
import net.crankedpvp.crankedarmor.CrankedArmorAPI;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.*;
import net.crankedpvp.wildpvp.CagePvPPlugin;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
public class ProteinPet extends Pet {
@ConfigValue
private int potionLevel = 3;
@ConfigValue
private int cooldown = 300;
@ConfigValue
private int duration = 4;
@Override
public String getName() {
return "Protein";
}
@Override
public String getDisplayName() {
return "&e&lProtein Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjhiNjRjZWQxYTM4YTljYzBmYTQ3ZTEzN2ZjZWJhOGJhYjU4YzIxNGZmZmYwZmNhNzYxYjg0NmU2OGNiZWU5YSJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fGives all allies within an 8 block",
"&fradius a temporary Strength buff",
"&ffor four seconds."
);
}
@Override
public PetType getPetType() {
return PetType.MYTHIC;
}
@Override
public int getCooldownInSeconds() {
return this.cooldown;
}
@Override
public void procAbility(Player player) {
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
PlayerUtils.getNearbyPlayers(player, 8)
.stream()
.filter(loopPlayer -> !FactionUtils.cantPvPFaction(loopPlayer, player))
.filter(loopPlayer -> !CagePvPPlugin.getInstance().getWildPvPManager().hasWildPvP(loopPlayer))
.forEach(loopPlayer -> PotionEffectUtils.addPotionEffect(loopPlayer, PotionEffectType.INCREASE_DAMAGE, this.potionLevel, this.getName(), this.duration));
PotionEffectUtils.addPotionEffect(player, PotionEffectType.INCREASE_DAMAGE, this.potionLevel, this.getName(), this.duration);
}
}
@@ -0,0 +1,72 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.CrankedPetsAPI;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
import java.util.*;
public class ShieldPet extends Pet {
@ConfigValue
private int resLevel = 1;
@ConfigValue
private int duration = 10;
@ConfigValue
private int cooldown = 900;
@Override
public String getName() {
return "Shield";
}
@Override
public String getDisplayName() {
return "&b&lShield Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTFkMDIyNTkzNzkxZjA1OTM5ZjYyZDYwY2Q1ZDg2NWZmNjhjOWI0OTNlYWFmYWI1ZTQ0MjZjODllMDE2ZTNkIn19fQ==";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fGain a temporary resistance effect."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oA shield made by the",
"&7&oancient warriors from camelot.");
}
@Override
public PetType getPetType() {
return PetType.RARE;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.DAMAGE_RESISTANCE, resLevel, "ShieldPet", duration);
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
}
}
@@ -0,0 +1,100 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.CrankedUtils;
import net.crankedpvp.crankedutils.utils.Arrow;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.staritems.StarItemsAPI;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import java.util.*;
public class SnowGolemPet extends Pet implements Listener {
private List<UUID> proced = new ArrayList<>();
@ConfigValue
private int duration = 7;
@ConfigValue
private int cooldown = 300;
@Override
public String getName() {
return "Snow Golem";
}
@Override
public String getDisplayName() {
return "&e&lSnow Golem Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMzIwMGExZDc2YTJiODMwMjUyZTAxN2MyMDJjZDUwYzlhM2NkNjIzYjQ5MTdlZDc4NjYxYTlhMzcyNjBhNDE5MSJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fBecome immune to taking damage in",
"&fexchange for the ability to attack",
"&ffor a short period of time"
);
}
@Override
public List<String> getLore() {
return Collections.emptyList();
}
@Override
public PetType getPetType() {
return PetType.MYTHIC;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
this.proced.add(player.getUniqueId());
CrankedPets.getInstance().getServer().getScheduler().runTaskLater(CrankedPets.getInstance(), () -> this.proced.remove(player.getUniqueId()), this.duration * 20L);
}
@EventHandler
public void onEntityDamage(EntityDamageByEntityEvent event) {
if(event.getDamager() instanceof Player && event.getEntity() instanceof Player) {
Player damager = (Player) event.getDamager();
Player entity = (Player) event.getEntity();
if(this.proced.contains(entity.getUniqueId())) {
if(!StarItemsAPI.playerHasStarItem(damager, "void")) {
CrankedUtils.getInstance().getDamageHandler().cancelDamage(event, "Snowgolem");
damager.sendMessage(CC.translate("&c&lSnow Golem &8" + Arrow.arrow() + " &eNo damage was dealt due to the Snow Golem Pet"));
return;
}
damager.sendMessage(CC.translate("&d&lVoid &8" + Arrow.arrow() + " &eYou bypassed the &c&lSnow Golem &epet damage cancellation"));
}
if(this.proced.contains(damager.getUniqueId())) {
CrankedUtils.getInstance().getDamageHandler().cancelDamage(event, "Snowgolem");
damager.sendMessage(CC.translate("&c&lSnow Golem &8" + Arrow.arrow() + " &eNo damage was dealt due to the Snow Golem Pet"));
}
}
}
}
@@ -0,0 +1,112 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.BlockUtil;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.EssentialsUtils;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import net.crankedpvp.staritems.StarItemsAPI;
import net.crankedpvp.wildpvp.CagePvPPlugin;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import java.util.Arrays;
import java.util.List;
public class SpiderPet extends Pet {
@ConfigValue
private int abilityDuration = 5;
@ConfigValue
private int cooldown = 900;
@ConfigValue
private int radius = 10;
@Override
public String getName() {
return "Spider";
}
@Override
public String getDisplayName() {
return "&e&lSpider Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMzVlMjQ4ZGEyZTEwOGYwOTgxM2E2Yjg0OGEwZmNlZjExMTMwMDk3ODE4MGVkYTQxZDNkMWE3YThlNGRiYTNjMyJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fTrap nearby enemies in",
"&fa sticky cobweb"
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oYour fellow spider companion",
"&7&othat'll lure enemies into it's",
"&7&owebs, allowing you to strike."
);
}
@Override
public PetType getPetType() {
return PetType.MYTHIC;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
for(Player target : PVPUtils.getNearbyEnemyPlayersExceptPlayer(player, radius)) {
if(StarItemsAPI.playerHasStarItem(target, "ignitedholograph")) continue;
if(StarItemsAPI.playerHasStarItem(target, "combo")) continue;
if (CagePvPPlugin.getInstance().getWildPvPManager().hasWildPvP(target) && !CagePvPPlugin.getInstance().getWildPvPManager().hasWildPvP(player) || !CagePvPPlugin.getInstance().getWildPvPManager().hasWildPvP(target) && CagePvPPlugin.getInstance().getWildPvPManager().hasWildPvP(player)) continue;
if (EssentialsUtils.isVanished(target)) continue;
Location location = target.getLocation();
Block underBlock = location.clone().getBlock();
Material underBlockType = underBlock.getType();
boolean setAtLeastOne = false;
if(underBlockType == Material.AIR) {
BlockUtil.setBlockFast(underBlock, Material.WEB.getId(), (byte) 0, false);
setAtLeastOne = true;
}
if(setAtLeastOne) {
Bukkit.getScheduler().runTaskLater(CrankedPets.getInstance(), () -> {
if (underBlock.getType() == Material.WEB) {
//underBlock.setType(Material.AIR);
BlockUtil.setAir(underBlock, true);
}
}, abilityDuration * 20L);
}
}
}
}
@@ -0,0 +1,110 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.staritems.StarItemsAPI;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class TitanPet extends Pet implements Listener {
@ConfigValue
private int duration = 5;
@ConfigValue
private int cooldown = 300;
@ConfigValue
private double damageIncreasePercent = 10;
@ConfigValue
private double damageIncreasePercentCritical = 5;
private List<Player> titanAbility = new ArrayList<>();
@Override
public String getName() {
return "Titan";
}
@Override
public String getDisplayName() {
return "&4&lTitan Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNzJlNWE5ODRjMzZlZTczMjE3Y2I0YjAzMmQyMTM2MDk2YWZiMWQ3NjEwNDU1OWExNTM5OWI5YzBjNGQyN2NmNiJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&f* Clear all debuffs",
"&f* 1.1x Outgoing damage (5s)",
"&f* 1.15x Outgoing critical damage (5s)",
"&f* Automatic /fix all"
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oMark your target for assured destruction");
}
@Override
public PetType getPetType() {
return PetType.CURSED;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
this.titanAbility.add(player);
for(ItemStack itemStack : player.getInventory().getArmorContents())
if(ItemUtils.isEnchantable(itemStack)) itemStack.setDurability((short) 0);
for(ItemStack itemStack : player.getInventory().getContents())
if(ItemUtils.isEnchantable(itemStack)) itemStack.setDurability((short) 0);
PotionEffectUtils.bless(player);
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
player.updateInventory();
Bukkit.getScheduler().runTaskLater(CrankedPets.getInstance(), () -> this.titanAbility.remove(player), this.duration * 20L);
}
@EventHandler
public void extraDamageOnTitanPet(EntityDamageByEntityEvent event) {
if(event.getEntity() == null) return;
if(event.getDamager() == null) return;
if(!(event.getDamager() instanceof Player)) return;
Player player = (Player)event.getDamager();
if(!this.titanAbility.contains(player)) return;
if(event.getEntity() instanceof Player && StarItemsAPI.playerHasStarItem((Player) event.getEntity(), "olympus")) return;
if(event.getEntity() instanceof Player && StarItemsAPI.playerHasStarItem((Player) event.getEntity(), "combo")) return;
super.getDamageHandler().increaseDamage(this.damageIncreasePercent, event, "TitanPet");
if(PVPUtils.isCritical(player)) {
super.getDamageHandler().increaseDamage(this.damageIncreasePercentCritical, event, "TitanPetCritical");
}
}
}
@@ -0,0 +1,74 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
import java.util.Arrays;
import java.util.List;
public class ValentinePet extends Pet {
@ConfigValue
private int regenLevel = 5;
@ConfigValue
private int regenDuration = 10;
@ConfigValue
private int cooldown = 900;
@Override
public String getName() {
return "Valentine";
}
@Override
public String getDisplayName() {
return "&e&lValentine Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNWUzNGQ0MjlkMWJhOTIzYzlmYjBjZjg1MWZiY2Y4YjQ0YmYxMGY3ZGE1MWZmMzI2NjJmNDc2NmE2ZjZlNTYyOSJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fGain a temporary regeneration effect."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oA pet that is not scared",
"&7&oto to spread it's positive",
"&7&ovibes among it's owners."
);
}
@Override
public PetType getPetType() {
return PetType.MYTHIC;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.REGENERATION, regenLevel, "ValentinePet", regenDuration);
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
}
}
@@ -0,0 +1,82 @@
package net.crankedpvp.crankedpets.pets;
import net.crankedpvp.crankedpets.cooldowns.PetCooldown;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.PetType;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.Potion;
import org.bukkit.potion.PotionType;
import java.util.Arrays;
import java.util.List;
public class WizardPet extends Pet {
@ConfigValue
private int cooldown = 900;
@ConfigValue
private int amountOfPotions = 3;
@Override
public String getName() {
return "Wizard";
}
@Override
public String getDisplayName() {
return "&4&lWizard Pet";
}
@Override
public String getTexture() {
return "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvN2JmYzE3ZWQ5MjhhZGZhZmZmYmY5ZjkxNTg5ZjBkNWI3YWIyMTZmNzRjMGQ3MjE0ZjI5ZTY5NDM4ZTYwOTdiMCJ9fX0=";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&fGive yourself " + this.amountOfPotions + " instant",
"&fhealth two potions"
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oA pet that is willing to",
"&7&ogive you potions at the",
"&7&oexpense of it's own sanity"
);
}
@Override
public PetType getPetType() {
return PetType.CURSED;
}
@Override
public int getCooldownInSeconds() {
return cooldown;
}
@Override
public void procAbility(Player player) {
for(int i = 0; i < this.amountOfPotions; i++)
player.getInventory().addItem(getPotion());
CooldownUtils.registerCooldown(player, new PetCooldown(getID(), getCooldownInSeconds()));
}
private ItemStack getPotion() {
Potion splash = new Potion(PotionType.INSTANT_HEAL, 2);
splash.setSplash(true);
return splash.toItemStack(1);
}
}
@@ -0,0 +1,9 @@
package net.crankedpvp.crankedpets.struct;
import org.bukkit.entity.Player;
public interface PassivePet {
void passiveAbility(Player player);
void disablePassiveAbility(Player player);
}
@@ -0,0 +1,80 @@
package net.crankedpvp.crankedpets.struct;
import de.tr7zw.nbtapi.NBTCompound;
import de.tr7zw.nbtapi.NBTItem;
import lombok.Getter;
import net.crankedpvp.crankedutils.CrankedUtils;
import net.crankedpvp.crankedutils.utils.DamageHandler;
import net.crankedpvp.crankedutils.utils.TimeUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.crankedutils.utils.items.SkullUtils;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
public abstract class Pet implements Listener {
@Getter
private final DamageHandler damageHandler;
public Pet() {
this.damageHandler = CrankedUtils.instance.getDamageHandler();
}
public abstract String getName();
public abstract String getDisplayName();
public abstract String getTexture();
public abstract List<String> getPerks();
public List<String> getLore() {
return null;
}
//make abstract if want to use ^
public abstract PetType getPetType();
public abstract int getCooldownInSeconds();
public abstract void procAbility(Player player);
public String getID() {
return this.getName().toLowerCase(Locale.ROOT).replace(" ", "");
}
public ItemStack getItem() {
List<String> lore = new ArrayList<>();
lore.add(this.getPetType().getName() + " Pet");
lore.add("");
lore.add(this instanceof PassivePet ? "&e&lPASSIVE" : "&a&lACTIVE");
lore.addAll(this.getPerks());
if(!(this instanceof PassivePet)) {
lore.add("");
lore.add("&f&lCooldown:");
lore.add("&7" + TimeUtils.formatSeconds(this.getCooldownInSeconds()));
}
lore.add("");
lore.add("&e&lLevel: 100");
lore.add("&e&lEXP: 0/10100");
lore.add("&c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
ItemStack skull = SkullUtils.getSkull(this.getTexture());
skull = new ItemBuilder(skull).setName(this.getDisplayName() + " &7[Level 100]")
.setLore(lore)
.colorize()
.build();
NBTItem wrapper = new NBTItem(skull);
wrapper.setString("cosmicType", "pet");
NBTCompound cosmicData = wrapper.getOrCreateCompound("cosmicData");
cosmicData.setString("petType", this.getID());
return wrapper.getItem();
}
}
@@ -0,0 +1,18 @@
package net.crankedpvp.crankedpets.struct;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter @AllArgsConstructor
public enum PetType {
//COMMON("&7Common", (short) 8),
RARE("&bRare", (short) 3),
MYTHIC("&eMythic", (short) 4),
//SEASON("&cSeason", (short) 14),
CURSED("&4Cursed", (short) 14)
;
private final String name;
private final short data;
}
@@ -0,0 +1,85 @@
package net.crankedpvp.crankedpets.struct;
import lombok.Getter;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.pets.*;
import org.apache.commons.lang.Validate;
import org.bukkit.Bukkit;
import java.util.*;
public class PetsRegister {
@Getter
private static PetsRegister instance;
private final Map<String, Pet> pets;
public PetsRegister() {
instance = this;
this.pets = new HashMap<>();
}
public void initialize() {
this.registerAll(
new ChickenPet(), new CowPet(), new ExperiencePet(), new IronGolemPet(),
new KrakenPet(), new SpiderPet(), new ValentinePet(), new WizardPet(),
new ProteinPet(), new TitanPet(), new SnowGolemPet(), new CagePet(), new ShieldPet()
);
}
public void registerAll(Pet... Pets) {
for (Pet set : Pets) {
this.register(set);
}
}
public void register(Pet pet) {
try {
this.pets.put(pet.getID(), pet);
CrankedPets.getInstance().getServer().getPluginManager().registerEvents(pet, CrankedPets.getInstance());
} catch (Exception e) {
Bukkit.getLogger().warning("Failed to register pet " + pet.getID());
System.out.println(e.getMessage());
}
}
public void unregisterAll() {
this.pets.clear();
}
public void unregister(Pet pet) {
this.pets.remove(pet.getID());
}
public void reload() {
this.unregisterAll();
this.initialize();
}
public boolean isPet(String name) {
return (this.getPetFromID(name) != null);
}
public Pet getPetFromID(String id) {
Validate.notNull(id);
Validate.notEmpty(id);
return this.pets.get(id.toLowerCase());
}
public Pet getPetFromName(String name) {
Validate.notNull(name);
Validate.notEmpty(name);
name = this.getPetIDFromName(name);
return this.pets.get(name.toLowerCase());
}
public String getPetIDFromName(String name) {
return name.replace(" ", "").toLowerCase(Locale.ROOT);
}
public Collection<Pet> getPets() {
return Collections.unmodifiableCollection(this.pets.values());
}
}
@@ -0,0 +1,19 @@
package net.crankedpvp.crankedpets.struct.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* don't forget to not make the field final when using this annotation
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ConfigValue {
String path() default "pet.";
String name() default "";
}
@@ -0,0 +1,118 @@
package net.crankedpvp.crankedpets.struct.config;
import lombok.AccessLevel;
import lombok.Getter;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.struct.Pet;
import net.crankedpvp.crankedpets.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.Bukkit;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
@Getter
public class PetConfig {
@Getter(value = AccessLevel.PRIVATE)
private final CrankedPets plugin;
private final String path;
private FileConfiguration config;
private final File configFile;
private final Pet pet;
public PetConfig(CrankedPets plugin, String path, Pet pet) {
this.plugin = plugin;
this.path = path;
this.pet = pet;
this.configFile = new File(plugin.getDataFolder(), path);
}
public void setupConfigFile() {
this.createDefaultFile();
this.config = YamlConfiguration.loadConfiguration(configFile);
this.loadVariables();
boolean result = this.saveConfig();
if (result) this.loadConfigFromDisk();
}
public boolean saveConfig() {
try {
config.save(configFile);
return true;
} catch (IOException e) {
plugin.getLogger().severe("Could not save config file for " + path);
e.printStackTrace();
}
return false;
}
public void createDefaultFile() {
if (!configFile.exists()) {
try {
configFile.getParentFile().mkdirs();
configFile.createNewFile();
} catch (IOException e) {
plugin.getLogger().severe("Could not create config file for " + path);
e.printStackTrace();
}
}
}
public void reloadConfig() {
config = YamlConfiguration.loadConfiguration(configFile);
this.loadVariables();
}
public void loadConfigFromDisk() {
try {
config.load(configFile);
} catch (IOException | InvalidConfigurationException e) {
plugin.getLogger().severe("Could not load config for " + path);
e.printStackTrace();
}
}
public void loadVariables() {
boolean needSave = false;
for (Field field : this.pet.getClass().getDeclaredFields()) {
try {
field.setAccessible(true);
if (field.isAnnotationPresent(ConfigValue.class)) {
ConfigValue annotationValue = field.getAnnotation(ConfigValue.class);
String name = annotationValue.name().equals("") ? field.getName() : annotationValue.name();
String path = annotationValue.path().endsWith(".") ? annotationValue.path() : annotationValue.path() + ".";
if (!this.config.contains(path + name)) {
this.config.set(path + name, field.get(this.pet));
needSave = true;
continue;
}
Object fieldValue = this.config.get(path + name);
if (fieldValue instanceof String) fieldValue = CC.translate((String) fieldValue);
field.set(this.pet, fieldValue);
}
} catch (IllegalAccessException | NullPointerException | IllegalArgumentException e) {
Bukkit.getConsoleSender().sendMessage(CC.translate("&c[CrankedPets] - Error invalid config value for pet " + pet.getName()));
}
}
if (needSave) {
saveConfig();
reloadConfig();
}
}
}
@@ -0,0 +1,38 @@
package net.crankedpvp.crankedpets.struct.config;
import lombok.Getter;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.struct.Pet;
import org.bukkit.configuration.file.FileConfiguration;
import java.util.HashMap;
import java.util.Map;
public class PetConfigManager {
@Getter
private final Map<Pet, PetConfig> configs = new HashMap<>();
public PetConfigManager(CrankedPets plugin) {
for (Pet pet : plugin.getPetRegister().getPets()) {
PetConfig petConfig = new PetConfig(plugin, "pets/" + pet.getID() + ".yml", pet);
configs.put(pet, petConfig);
}
}
public void setupFiles() {
configs.values().forEach(PetConfig::setupConfigFile);
}
public void reloadFiles() {
configs.values().forEach(PetConfig::reloadConfig);
}
public PetConfig getAbstractConfig(Pet pet) {
return configs.get(pet);
}
public FileConfiguration getConfig(Pet pet) {
return getAbstractConfig(pet).getConfig();
}
}
@@ -0,0 +1,47 @@
package net.crankedpvp.crankedpets.tasks;
import net.crankedpvp.crankedpets.CrankedPets;
import net.crankedpvp.crankedpets.managers.PassivePetManager;
import net.crankedpvp.crankedpets.struct.PassivePet;
import net.crankedpvp.crankedpets.struct.Pet;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.*;
import java.util.stream.Collectors;
public class PassivePetTask extends BukkitRunnable {
private final PassivePetManager passivePetManager = CrankedPets.instance.getPassivePetManager();
@Override
public void run() {
Map<UUID, List<Pet>> mapCopy = new HashMap<>(passivePetManager.getPassivePetsMap());
for (Map.Entry<UUID, List<Pet>> entry : mapCopy.entrySet()) {
UUID uuid = entry.getKey();
Player player = Bukkit.getPlayer(uuid);
if (player == null || !player.isOnline()) {
passivePetManager.getPassivePetsMap().remove(uuid);
continue;
}
List<Pet> oldPets = entry.getValue();
List<Pet> currentPets = passivePetManager.getCurrentPassivePets(player);
for (Pet pet : oldPets) {
if (!currentPets.contains(pet)) {
((PassivePet)pet).disablePassiveAbility(player);
}
}
for (Pet pet : currentPets) {
((PassivePet)pet).passiveAbility(player);
}
}
for (Player player : Bukkit.getOnlinePlayers()) {
passivePetManager.scanPlayerInventory(player);
}
}
}
+17
View File
@@ -0,0 +1,17 @@
INVALID_PET: "&c&l(!)&c Invalid pet name."
ADMIN_COMMAND_HELP:
- "&8--- &3Cranked &fPets &8---"
- "&3/cp &fpet &7<pet> [player]"
-
PASSIVE_PET:
- "&eWrite some stuff"
- "&7About how passive pets work"
ADMIN_RELOADING: "&3&l(!) &7Reloading configs now..."
ADMIN_RELOADED: "&3&l(!) &7Reloaded configs and other cool stuff. Took &3%took%ms&7."
PVP_DISABLED_REGION: "&d&lPets &8➥ &7You cannot use pets in a pvp-disabled region"
PET_ON_COOLDOWN: "&d&lPets &8➥ &7Your %pet% is still on cooldown for %timeLeft%."
PET_USED: "&d&lPets &8➥ &7you have &a&lACTIVATED&7 your %pet%&7."
+7
View File
@@ -0,0 +1,7 @@
name: CrankedPets
main: net.crankedpvp.crankedpets.CrankedPets
version: ${git.total.commit.count}.0
description: "§fCommit ID: §a${git.commit.id.abbrev}"
website: https://crankedpvp.net/
depend:
- CrankedUtils