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
+30
View File
@@ -0,0 +1,30 @@
<?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>AdminItems</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>
</dependencies>
</project>
@@ -0,0 +1,71 @@
package net.crankedpvp.adminitems;
import lombok.Getter;
import me.mattstudios.mf.base.CommandManager;
import me.mattstudios.mf.base.components.TypeResult;
import net.crankedpvp.adminitems.commands.AdminItemCommand;
import net.crankedpvp.adminitems.language.LanguageHandler;
import net.crankedpvp.adminitems.managers.AdminItemAbilityManager;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.adminitems.struct.AdminItemRegister;
import net.crankedpvp.adminitems.struct.config.AdminItemConfigManager;
import net.crankedpvp.crankedutils.utils.PluginUtils;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.stream.Collectors;
@Getter
public class AdminItemsPlugin extends JavaPlugin {
@Getter
public static AdminItemsPlugin instance;
public LanguageHandler languageHandler;
private AdminItemRegister adminItemRegister;
private CommandManager commandManager;
private AdminItemConfigManager petConfigManager;
private AdminItemAbilityManager abilityManager;
@Override
public void onEnable() {
instance = this;
this.abilityManager = new AdminItemAbilityManager();
this.languageHandler = new LanguageHandler(this);
this.languageHandler.load();
this.adminItemRegister = new AdminItemRegister();
this.adminItemRegister.initialize();
this.petConfigManager = new AdminItemConfigManager(this);
this.petConfigManager.setupFiles();
this.commandManager = new CommandManager(this);
this.registerCommandParameters();
this.registerCommandCompletion();
this.commandManager.register(new AdminItemCommand(this));
}
private void registerCommandParameters() {
this.commandManager.getParameterHandler().register(AdminItem.class, argument -> {
AdminItem pet = this.adminItemRegister.getAdminItemFromID(this.adminItemRegister.getAdminItemIDFromName(String.valueOf(argument)));
return new TypeResult(pet, argument);
});
}
private void registerCommandCompletion() {
this.commandManager.getCompletionHandler().register("#adminItems", input -> {
return this.adminItemRegister.getAdminItems().stream().map(AdminItem::getID).collect(Collectors.toList());
});
}
@Override
public void onDisable() {
instance = null;
}
}
@@ -0,0 +1,88 @@
package net.crankedpvp.adminitems;
import de.tr7zw.nbtapi.NBTCompound;
import de.tr7zw.nbtapi.NBTItem;
import net.crankedpvp.adminitems.language.Language;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.adminitems.struct.AdminItemRegister;
import net.crankedpvp.adminitems.struct.Throwable;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class CrankedAdminItemsAPI {
public static boolean isAdminItem(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() == Material.AIR) return false;
NBTItem nbtItem = new NBTItem(itemStack);
if (!nbtItem.hasKey("cosmicType")) return false;
return nbtItem.getString("cosmicType").equals("adminItem");
}
public static AdminItem getAdminItemFromItem(ItemStack itemStack) {
NBTItem nbtItem = new NBTItem(itemStack);
NBTCompound compound = nbtItem.getCompound("cosmicData");
String adminItemType = compound.getString("adminItemType");
return AdminItemRegister.getInstance().getAdminItemFromID(adminItemType);
}
public static int getUsesFromFromItem(ItemStack itemStack) {
NBTItem nbtItem = new NBTItem(itemStack);
NBTCompound compound = nbtItem.getCompound("cosmicData");
return compound.getInteger("adminItemUses");
}
public static boolean canUseAdminItem(Player player, ItemStack itemStack, String cooldownID, AdminItem adminItem) {
if (!CrankedAdminItemsAPI.getAdminItemFromItem(itemStack).getID().equals(adminItem.getID())) {
return false;
}
if (itemStack.getAmount() > 1) {
Language.USE_STACKED_ADMIN_ITEM.send(player);
player.playSound(player.getLocation(), Sound.VILLAGER_NO, 10f, 1.1f);
if (adminItem instanceof Throwable) {
int amount = itemStack.getAmount();
int uses = CrankedAdminItemsAPI.getUsesFromFromItem(itemStack);
ItemStack item = adminItem.getItem(uses).clone();
item.setAmount(amount);
player.setItemInHand(item);
}
return false;
}
if (CooldownUtils.isCooldownActive(player, cooldownID)) {
player.sendMessage(CC.translate(Language.ADMIN_ITEM_ABILITY_COOLDOWN.getMessage().replace("%time%", CooldownUtils.getFormattedCooldown(player, cooldownID))));
player.playSound(player.getLocation(), Sound.VILLAGER_NO, 10f, 1.1f);
if (adminItem instanceof Throwable) {
int uses = CrankedAdminItemsAPI.getUsesFromFromItem(itemStack);
player.setItemInHand(adminItem.getItem(uses));
}
return false;
}
return true;
}
public static void decreaseUses(Player player, AdminItem adminItem) {
int uses = CrankedAdminItemsAPI.getUsesFromFromItem(player.getItemInHand());
if (uses != -1) {
if (uses - 1 == 0) {
player.setItemInHand(null);
} else {
player.setItemInHand(adminItem.getItem(uses-1));
}
}
}
}
@@ -0,0 +1,63 @@
package net.crankedpvp.adminitems.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.adminitems.AdminItemsPlugin;
import net.crankedpvp.adminitems.language.Language;
import net.crankedpvp.adminitems.language.LanguageHandler;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.adminitems.struct.config.AdminItemConfigManager;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("cai")
public class AdminItemCommand extends CommandBase {
private final LanguageHandler languageHandler;
private final AdminItemConfigManager adminItemConfigManager;
public AdminItemCommand(AdminItemsPlugin plugin) {
this.languageHandler = plugin.getLanguageHandler();
this.adminItemConfigManager = plugin.getPetConfigManager();
}
@Default
@Permission("cranked.admin")
public void mainCommand(CommandSender sender) {
Language.ADMIN_COMMAND_HELP.send(sender);
}
@SubCommand("item")
@WrongUsage("&cUsage: /cp item <adminItem> <uses> [player]")
@Permission("cranked.admin")
public void itemCommand(CommandSender sender, @Completion("#adminItems") AdminItem adminItem, Integer uses ,@Completion("#players") @Optional Player player) {
if (adminItem == null) {
Language.INVALID_ADMIN_ITEM.send(sender);
return;
}
if (player != null) {
player.getInventory().addItem(adminItem.getItem(uses));
return;
}
if (sender instanceof Player) {
((Player) sender).getInventory().addItem(adminItem.getItem(uses));
}
}
@SubCommand("reload")
@WrongUsage("&cUsage: /cai reload")
@Permission("cranked.admin")
public void reloadCommand(Player sender) {
Language.ADMIN_RELOADING.send(sender);
long then = System.currentTimeMillis();
this.languageHandler.load();
this.adminItemConfigManager.reloadFiles();
long diff = System.currentTimeMillis() - then;
Language.ADMIN_RELOADED.send(sender, str -> str.replace("%took%", String.valueOf(diff)));
}
}
@@ -0,0 +1,9 @@
package net.crankedpvp.adminitems.cooldowns;
import net.crankedpvp.crankedutils.utils.cache.cooldown.CurrentCooldown;
public class AbilityCooldown extends CurrentCooldown {
public AbilityCooldown(String name, int durationInSeconds) {
super(name, durationInSeconds);
}
}
@@ -0,0 +1,31 @@
package net.crankedpvp.adminitems.events;
import lombok.Getter;
import lombok.Setter;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.crankedutils.events.ArmorEquipEvent;
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 AdminItemUseEvent extends Event implements Cancellable {
@Setter
private boolean cancelled;
private final Player player;
private final AdminItem adminItem;
private final PlayerInteractEvent playerInteractEvent;
private final HandlerList handlers;
public AdminItemUseEvent(Player player, AdminItem adminItem, PlayerInteractEvent event) {
this.player = player;
this.adminItem = adminItem;
this.playerInteractEvent = event;
this.cancelled = false;
this.handlers = new HandlerList();
}
}
@@ -0,0 +1,157 @@
package net.crankedpvp.adminitems.items;
import net.crankedpvp.adminitems.CrankedAdminItemsAPI;
import net.crankedpvp.adminitems.cooldowns.AbilityCooldown;
import net.crankedpvp.adminitems.language.Language;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.adminitems.struct.Interactable;
import net.crankedpvp.adminitems.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.ProjectileLaunchEvent;
import org.bukkit.event.player.PlayerFishEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.Vector;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
public class GrappleHook extends AdminItem implements Interactable {
@ConfigValue()
private int cooldown = 10;
private final HashMap<Player, Vector> grapple = new HashMap<>();
@Override
public String getName() {
return "GrappleHook";
}
@Override
public String getDisplayName() {
return "&b&lGrapple Hook";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&7Grapple yourself across the world",
"&7and pull other enemies towards you.",
"&7There is a " + cooldown + " seconds cooldown",
"&7between every grapple use."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oEscape from all your problems with",
"&7&othe grappler hook. Escape from reality.",
"&7&oand start a new adventure on cranked."
);
}
@Override
public ChatColor getColor() {
return ChatColor.AQUA;
}
@Override
public Material getMaterial() {
return Material.FISHING_ROD;
}
@Override
public String getCooldownID() {
return "grappleHook";
}
@EventHandler
public void onGrappleLaunch(ProjectileLaunchEvent e) {
if (!(e.getEntity().getShooter() instanceof Player)) {
return;
}
final Player shooter = (Player) e.getEntity().getShooter();
if (!CrankedAdminItemsAPI.isAdminItem(shooter.getItemInHand())) {
return;
}
if (CrankedAdminItemsAPI.getAdminItemFromItem(shooter.getItemInHand()) != this) {
return;
}
if(shooter.getWorld().getName().equals("world_nether")) {
e.setCancelled(true);
Language.GRAPPLED_CANNOT_USE_IN_WORLD.send(shooter);
return;
}
this.grapple.put(shooter, e.getEntity().getVelocity());
}
@EventHandler
public void onPlayerFish(PlayerFishEvent e) {
final ItemStack item = e.getPlayer().getItemInHand();
if (!CrankedAdminItemsAPI.isAdminItem(item)) return;
if (!CrankedAdminItemsAPI.canUseAdminItem(e.getPlayer(), item, getCooldownID(), this)) {
return;
}
if(e.getPlayer().getWorld().getName().equals("world_nether")) {
e.setCancelled(true);
Language.GRAPPLED_CANNOT_USE_IN_WORLD.send(e.getPlayer());
return;
}
if (e.getState() == PlayerFishEvent.State.FISHING) return;
final Player p = e.getPlayer();
if (!this.grapple.containsKey(p)) {
return;
}
if (e.getCaught() instanceof Player) {
final Location loc = e.getCaught().getLocation();
final Location hookLoc = p.getLocation();
final double dis = loc.distance(hookLoc);
Vector direction = e.getCaught().getLocation().toVector().subtract(p.getLocation().toVector()).normalize();
final double Y = (1.0 + 0.12 * dis) * (hookLoc.getY() - loc.getY()) / dis - -0.04 * dis;
direction.setY(Y);
direction.setX(direction.getX() * -1 * (0.11 * dis));
direction.setZ(direction.getZ() * -1 * (0.11 * dis));
e.getCaught().setVelocity(direction);
p.sendMessage(CC.translate(Language.GRAPPLED_ENEMY.getMessage()).replace("%enemy%", e.getCaught().getName()));
e.getCaught().sendMessage(CC.translate(Language.GRAPPLED_BY_PLAYER.getMessage()).replace("%player%", p.getName()));
} else {
final double distance = p.getLocation().distance(e.getHook().getLocation());
final Location loc = p.getLocation();
final Location hookLoc = e.getHook().getLocation();
final double dis = loc.distance(hookLoc);
final double X = (1.0 + 0.24 * dis) * (hookLoc.getX() - loc.getX()) / dis;
final double Y = (1.0 + 0.12 * dis) * (hookLoc.getY() - loc.getY()) / dis - -0.04 * dis;
final double Z = (1.0 + 0.24 * dis) * (hookLoc.getZ() - loc.getZ()) / dis;
final Vector v = p.getVelocity();
v.setX(X);
v.setY(Y);
v.setZ(Z);
p.setVelocity(v);
p.setVelocity(this.grapple.get(p).multiply(distance * 0.3).setY((distance * 0.1 > 1.0) ? 1.0 : ((p.getLocation().getPitch() < -70.0f) ? 1.25 : ((p.getLocation().getPitch() < -50.0f) ? 1.125 : 1.0))));
Language.GRAPPLED.send(p);
}
this.grapple.remove(p);
item.setDurability((short) 0);
p.setItemInHand(item);
CrankedAdminItemsAPI.decreaseUses(p, this);
CooldownUtils.registerCooldown(p, new AbilityCooldown(getCooldownID(), cooldown));
}
}
@@ -0,0 +1,158 @@
package net.crankedpvp.adminitems.items;
import net.crankedpvp.adminitems.AdminItemsPlugin;
import net.crankedpvp.adminitems.CrankedAdminItemsAPI;
import net.crankedpvp.adminitems.cooldowns.AbilityCooldown;
import net.crankedpvp.adminitems.language.Language;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.adminitems.struct.Throwable;
import net.crankedpvp.adminitems.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.WorldGuardUtils;
import org.apache.commons.codec.language.bm.Lang;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.util.Vector;
import java.util.*;
import java.util.concurrent.*;
import org.bukkit.inventory.*;
import org.bukkit.event.*;
import org.bukkit.event.entity.*;
import org.bukkit.entity.*;
import org.bukkit.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
public class SwitcherBall extends AdminItem implements Throwable {
@ConfigValue()
private int cooldown = 60;
private Map<UUID, Player> snowballPlayers = new HashMap<>();
@Override
public String getName() {
return "SwitcherBall";
}
@Override
public String getDisplayName() {
return "&d&lSwitcher Ball";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&7Upon hit, your location will be switched",
"&7with the person you hit with the ball.",
"&7There is a 60 seconds cooldown",
"&7between every switcher ball use."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oEver wanted to know how it is",
"&7&oto step in someone else's shoes?"
);
}
@Override
public ChatColor getColor() {
return ChatColor.LIGHT_PURPLE;
}
@Override
public Material getMaterial() {
return Material.SNOW_BALL;
}
@Override
public String getCooldownID() {
return "switcherBall";
}
@EventHandler
public void onPlayerLaunchEgg(ProjectileLaunchEvent e) {
if (!(e.getEntity() instanceof Snowball)) {
return;
}
if (!(e.getEntity().getShooter() instanceof Player)) {
return;
}
final Player shooter = (Player) e.getEntity().getShooter();
if (!CrankedAdminItemsAPI.isAdminItem(shooter.getItemInHand())) {
return;
}
if (!CrankedAdminItemsAPI.canUseAdminItem(shooter, shooter.getItemInHand(), getCooldownID(), this)) {
return;
}
this.snowballPlayers.put(e.getEntity().getUniqueId(), ((Player) e.getEntity().getShooter()).getPlayer());
}
@EventHandler
public void onPlayerHitBySnowball(EntityDamageByEntityEvent e) {
if (!(e.getEntity() instanceof Player)) {
return;
}
if (!(e.getDamager() instanceof Snowball)) {
return;
}
final Player hit = (Player) e.getEntity();
final Entity damager = e.getDamager();
final Snowball snowball = (Snowball) damager;
if (!(snowball.getShooter() instanceof Player)) {
return;
}
final Player shooter = (Player) snowball.getShooter();
if (!this.snowballPlayers.containsKey(snowball.getUniqueId())) {
return;
}
if (this.snowballPlayers.get(snowball.getUniqueId()) != shooter) {
return;
}
if (!WorldGuardUtils.canPvPInRegion(shooter.getLocation()) || !WorldGuardUtils.canPvPInRegion(hit.getLocation())) return;
this.snowballPlayers.remove(snowball.getUniqueId());
final Location loc = shooter.getLocation();
shooter.teleport(hit);
hit.teleport(loc);
shooter.sendMessage(CC.translate(Language.SWITCHERED.getMessage().replace("%shot%", hit.getName())));
hit.sendMessage(CC.translate(Language.SWITCHERED_BY_PLAYER.getMessage().replace("%player%", shooter.getName())));
CooldownUtils.registerCooldown(shooter, new AbilityCooldown(getCooldownID(), cooldown));
}
@EventHandler
public void onHit(ProjectileHitEvent event) {
if (event.getEntity() instanceof Snowball) {
if (snowballPlayers.containsKey(event.getEntity().getUniqueId())) {
Player shooter = snowballPlayers.get(event.getEntity().getUniqueId());
Language.SWITCHER_HIT_NONE.send(shooter);
//shooter.setItemInHand(AdminItemsPlugin.getInstance().getAdminItemRegister().getAdminItemFromID("SwitcherBall").getItem(1));
snowballPlayers.remove(event.getEntity().getUniqueId());
}
}
}
}
@@ -0,0 +1,135 @@
package net.crankedpvp.adminitems.items;
import com.gmail.filoghost.holographicdisplays.api.Hologram;
import com.gmail.filoghost.holographicdisplays.api.HologramsAPI;
import net.crankedpvp.adminitems.AdminItemsPlugin;
import net.crankedpvp.adminitems.CrankedAdminItemsAPI;
import net.crankedpvp.adminitems.cooldowns.AbilityCooldown;
import net.crankedpvp.adminitems.language.Language;
import net.crankedpvp.adminitems.managers.AdminItemAbilityManager;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.adminitems.struct.Interactable;
import net.crankedpvp.adminitems.struct.annotations.ConfigValue;
import net.crankedpvp.adminitems.tasks.TimeTravelerTask;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.*;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import java.util.Arrays;
import java.util.List;
public class TimeTraveler extends AdminItem implements Interactable {
private AdminItemAbilityManager abilityManager = AdminItemsPlugin.getInstance().getAbilityManager();
@ConfigValue()
private int time = 30;
@ConfigValue()
private int cooldown = 120;
@Override
public String getName() {
return "TimeTraveler";
}
@Override
public String getDisplayName() {
return "&5&lTime Traveler";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&7Upon use, your current location will be",
"&7saved and after &f" + time + "&7 seconds you will",
"&7be teleported back to that location."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oMany people claim they have seen the",
"&7&othe past but never seen the future.",
"&7&oTime Travelers are everywhere and nowhere."
);
}
@Override
public ChatColor getColor() {
return ChatColor.DARK_PURPLE;
}
@Override
public Material getMaterial() {
return Material.WATCH;
}
@Override
public String getCooldownID() {
return "timeTraveler";
}
@EventHandler
public void onPlayerInteractWithAdminItem(PlayerInteractEvent event) {
if (!CrankedAdminItemsAPI.isAdminItem(event.getItem())) return;
if (!CrankedAdminItemsAPI.canUseAdminItem(event.getPlayer(), event.getItem(), getCooldownID(), this)) {
return;
}
procOnClickAbility(event.getPlayer());
}
public void procOnClickAbility(Player player) {
final Location spawnLocation = player.getEyeLocation();
CooldownUtils.registerCooldown(player, new AbilityCooldown(getCooldownID(), cooldown));
Hologram hologram = HologramsAPI.createHologram(AdminItemsPlugin.getInstance(), spawnLocation.clone());
hologram.appendTextLine(CC.translate("&d&l✰ &5&lTime Travelling &d&l✰"));
hologram.appendTextLine(CC.translate("&d&l * &fTime: &d" + 0 + "s &fleft"));
hologram.appendTextLine(CC.translate("&d&l * &fTraveler: &d" + player.getName()));
player.sendMessage(CC.translate(Language.TIME_TRAVEL_USED.getMessage().replace("%time%", String.valueOf(time))));
CrankedAdminItemsAPI.decreaseUses(player, this);
TimeTravelerTask timeTravelerTask = new TimeTravelerTask(this.time, hologram, player, spawnLocation);
timeTravelerTask.runTaskTimer(AdminItemsPlugin.getInstance(), 0L, 20L);
abilityManager.getTimeTravellers().put(player.getUniqueId(), timeTravelerTask);
}
@EventHandler
public void onDeath(PlayerDeathEvent event) {
if (abilityManager.getTimeTravellers().containsKey(event.getEntity().getUniqueId())) {
TimeTravelerTask timeTravelerTask = (TimeTravelerTask) abilityManager.getTimeTravellers().get(event.getEntity().getUniqueId());
Language.TIME_TRAVEL_DIED.send(event.getEntity());
timeTravelerTask.getHologram().delete();
timeTravelerTask.cancel();
abilityManager.getTimeTravellers().remove(event.getEntity().getUniqueId());
}
}
@EventHandler
public void onTeleportBeforeTimeTraveler(PlayerTeleportEvent event) {
if (event.getPlayer() == null) return;
if (event.getCause() == null) return;
if (event.getCause() == PlayerTeleportEvent.TeleportCause.ENDER_PEARL) return;
if (!this.abilityManager.getTimeTravellers().containsKey(event.getPlayer().getUniqueId())) return;
this.abilityManager.getTimeTravellers().remove(event.getPlayer().getUniqueId());
Language.TIME_TRAVEL_CANCELED_BECAUSE_TELEPORT.send(event.getPlayer());
}
}
@@ -0,0 +1,188 @@
package net.crankedpvp.adminitems.items;
import net.crankedpvp.adminitems.AdminItemsPlugin;
import net.crankedpvp.adminitems.CrankedAdminItemsAPI;
import net.crankedpvp.adminitems.cooldowns.AbilityCooldown;
import net.crankedpvp.adminitems.language.Language;
import net.crankedpvp.adminitems.managers.AdminItemAbilityManager;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.adminitems.struct.Interactable;
import net.crankedpvp.adminitems.struct.annotations.ConfigValue;
import net.crankedpvp.crankedutils.utils.*;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import java.util.*;
public class TrapBlocker extends AdminItem implements Interactable {
private final AdminItemAbilityManager abilityManager = AdminItemsPlugin.getInstance().getAbilityManager();
@ConfigValue()
private int radius = 16;
@ConfigValue()
private int time = 10;
@ConfigValue()
private int cooldown = 60;
@Override
public String getName() {
return "TrapBlocker";
}
@Override
public String getDisplayName() {
return "&c&lTrap Blocker";
}
@Override
public List<String> getPerks() {
return Arrays.asList(
"&7Upon use, people in a &f" + radius + "x" + radius + "&7 radius",
"&7will no longer be able to:",
"&7open doors, place or break blocks",
"&7for a duration of &f" + time + "&7 seconds."
);
}
@Override
public List<String> getLore() {
return Arrays.asList(
"&7&oThose who have been trapped",
"&7&oin life know how it is to escape",
"&7&ofrom it's darkest dreams."
);
}
@Override
public ChatColor getColor() {
return ChatColor.RED;
}
@Override
public Material getMaterial() {
return Material.STICK;
}
@Override
public String getCooldownID() {
return "trapBlocker";
}
public void procOnClickAbility(Player player) {
List<Player> nearbyPlayers = PVPUtils.getNearbyEnemyPlayersExceptPlayer(player, radius);
List<UUID> trapBlockedPossibleList = new ArrayList<>();
for (Player enemy : nearbyPlayers) {
final UUID uuid = enemy.getUniqueId();
if (CooldownUtils.isCooldownActive(enemy, getCooldownID())) {
String cd = CooldownUtils.getFormattedCooldown(enemy, getCooldownID());
String msg = Language.TRAP_BLOCKER_ENEMY_ON_COOLDOWN.getMessage().replace("%time%", cd);
msg = msg.replace("%enemy%", enemy.getName());
player.sendMessage(CC.translate(msg));
} else {
trapBlockedPossibleList.add(uuid);
}
}
if (trapBlockedPossibleList.isEmpty()) {
int uses = CrankedAdminItemsAPI.getUsesFromFromItem(player.getItemInHand());
player.setItemInHand(super.getItem(uses));
Language.TRAP_BLOCKER_NO_NEARBY.send(player);
return;
}
StringBuilder listFormatted = new StringBuilder(new StringBuilder());
for (UUID uuid : trapBlockedPossibleList) {
Player enemy = Bukkit.getPlayer(uuid);
if (enemy == null) continue;
abilityManager.trapBlock(uuid);
Bukkit.getScheduler().runTaskLaterAsynchronously(AdminItemsPlugin.getInstance(), ()-> {
Language.TRAP_BLOCKER_ENDED.send(Bukkit.getPlayer(uuid));
abilityManager.getTrapBlockered().remove(uuid);
}, time* 20L);
CooldownUtils.registerCooldown(enemy, new AbilityCooldown(getCooldownID(), cooldown));
String msg = Language.TRAP_BLOCKED_BY.getMessage().replace("%time%", Integer.toString(this.time));
msg = msg.replace("%enemy%", player.getName());
enemy.sendMessage(CC.translate(msg));
listFormatted.append(enemy.getName()).append(", ");
listFormatted = new StringBuilder(listFormatted.substring(0, listFormatted.length() - 2));
}
String msgPlayer = Language.TRAP_BLOCKED.getMessage().replace("%blockedList%", listFormatted.toString());
msgPlayer = msgPlayer.replace("%amount%", Integer.toString(trapBlockedPossibleList.size()));
player.sendMessage(CC.translate(msgPlayer));
CrankedAdminItemsAPI.decreaseUses(player, this);
}
@EventHandler
public void onPlayerInteractWithAdminItem(PlayerInteractEvent event) {
if (!CrankedAdminItemsAPI.isAdminItem(event.getItem())) return;
if (!CrankedAdminItemsAPI.canUseAdminItem(event.getPlayer(), event.getItem(), getCooldownID(), this)) {
return;
}
procOnClickAbility(event.getPlayer());
}
@EventHandler
public void onBuild(BlockPlaceEvent event) {
if (abilityManager.isTrapBlockered(event.getPlayer().getUniqueId())) {
Language.TRAP_BLOCKER_CANNOT_INTERACT.send(event.getPlayer());
event.setCancelled(true);
}
}
@EventHandler
public void onLogout(PlayerQuitEvent event) {
if (abilityManager.isTrapBlockered(event.getPlayer().getUniqueId())) {
abilityManager.getTrapBlockered().remove(event.getPlayer().getUniqueId());
}
}
@EventHandler
public void onKick(PlayerKickEvent event) {
if (abilityManager.isTrapBlockered(event.getPlayer().getUniqueId())) {
abilityManager.getTrapBlockered().remove(event.getPlayer().getUniqueId());
}
}
@EventHandler
public void onDeath(PlayerDeathEvent event) {
if (abilityManager.isTrapBlockered(event.getEntity().getUniqueId())) {
abilityManager.getTrapBlockered().remove(event.getEntity().getUniqueId());
}
}
@EventHandler
public void onBreak(BlockBreakEvent event) {
if (abilityManager.isTrapBlockered(event.getPlayer().getUniqueId())) {
Language.TRAP_BLOCKER_CANNOT_INTERACT.send(event.getPlayer());
event.setCancelled(true);
}
}
@EventHandler
public void onInteract(PlayerInteractEvent event) {
if (event.getClickedBlock() == null) return;
if (!event.getClickedBlock().getType().name().endsWith("_DOOR")) return;
if (abilityManager.isTrapBlockered(event.getPlayer().getUniqueId())) {
Language.TRAP_BLOCKER_CANNOT_INTERACT.send(event.getPlayer());
event.setCancelled(true);
}
}
}
@@ -0,0 +1,118 @@
package net.crankedpvp.adminitems.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_ADMIN_ITEM,
ADMIN_RELOADING,
USE_STACKED_ADMIN_ITEM,
TRAP_BLOCKER_CANNOT_INTERACT,
TRAP_BLOCKER_ENEMY_ON_COOLDOWN,
TRAP_BLOCKED_BY,
TRAP_BLOCKED,
TRAP_BLOCKER_NO_NEARBY,
TRAP_BLOCKER_ENDED,
TIME_TRAVEL_DIED,
TIME_TRAVEL_TIME,
TIME_TRAVEL_USED,
TIME_TRAVEL_ENDED,
TIME_TRAVEL_CANCELED_BECAUSE_TELEPORT,
GRAPPLED,
GRAPPLED_BY_PLAYER,
GRAPPLED_ENEMY,
GRAPPLED_CANNOT_USE_IN_WORLD,
SWITCHERED,
SWITCHER_HIT_NONE,
SWITCHERED_BY_PLAYER,
ADMIN_ITEM_ABILITY_COOLDOWN,
ADMIN_RELOADED,
;
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.adminitems.language;
import net.crankedpvp.adminitems.AdminItemsPlugin;
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 AdminItemsPlugin plugin;
public LanguageHandler(AdminItemsPlugin 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,27 @@
package net.crankedpvp.adminitems.managers;
import lombok.Getter;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.*;
@Getter
public class AdminItemAbilityManager {
private List<UUID> trapBlockered;
private Map<UUID, BukkitRunnable> timeTravellers;
public AdminItemAbilityManager() {
this.trapBlockered = new ArrayList<>();
this.timeTravellers = new HashMap<>();
}
public boolean isTrapBlockered(UUID uuid) {
return trapBlockered.contains(uuid);
}
public boolean trapBlock(UUID uuid) {
return trapBlockered.add(uuid);
}
}
@@ -0,0 +1,57 @@
package net.crankedpvp.adminitems.struct;
import de.tr7zw.nbtapi.NBTCompound;
import de.tr7zw.nbtapi.NBTItem;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerFishEvent;
import org.bukkit.inventory.ItemStack;
import java.util.List;
import java.util.Locale;
public abstract class AdminItem implements Listener {
public abstract String getName();
public abstract String getDisplayName();
public abstract List<String> getPerks();
public abstract List<String> getLore();
public abstract ChatColor getColor();
public abstract Material getMaterial();
public abstract String getCooldownID();
public String getID() {
return this.getName().toLowerCase(Locale.ROOT).replace(" ", "");
}
public ItemStack getItem(int uses) {
ItemStack item = new ItemBuilder(getMaterial()).setName(this.getDisplayName())
.addLore(this.getLore())
.addLore("")
.addLore(this.getColor() + "&l" + "Ability")
.addLore(this.getPerks())
.addLore("")
.addLore(this.getColor() + "&l" + "Uses")
.addLore("&f" +(uses == -1? "Unlimited": Integer.toString(uses)))
.colorize()
.setGlowing()
.build();
NBTItem wrapper = new NBTItem(item);
wrapper.setString("cosmicType", "adminItem");
NBTCompound cosmicData = wrapper.getOrCreateCompound("cosmicData");
cosmicData.setString("adminItemType", this.getID());
cosmicData.setInteger("adminItemUses", uses);
return wrapper.getItem();
}
}
@@ -0,0 +1,89 @@
package net.crankedpvp.adminitems.struct;
import lombok.Getter;
import net.crankedpvp.adminitems.AdminItemsPlugin;
import net.crankedpvp.adminitems.items.GrappleHook;
import net.crankedpvp.adminitems.items.SwitcherBall;
import net.crankedpvp.adminitems.items.TimeTraveler;
import net.crankedpvp.adminitems.items.TrapBlocker;
import org.apache.commons.lang.Validate;
import org.bukkit.Bukkit;
import java.util.*;
public class AdminItemRegister {
@Getter
private static AdminItemRegister instance;
private final Map<String, AdminItem> adminItems;
public AdminItemRegister() {
instance = this;
this.adminItems = new HashMap<>();
}
public void initialize() {
this.registerAll(
new TrapBlocker(),
new TimeTraveler(),
new GrappleHook(),
new SwitcherBall()
);
}
public void registerAll(AdminItem... Adminitems) {
for (AdminItem adminItem : Adminitems) {
this.register(adminItem);
}
}
public void register(AdminItem adminItem) {
try {
this.adminItems.put(adminItem.getID(), adminItem);
AdminItemsPlugin.getInstance().getServer().getPluginManager().registerEvents(adminItem, AdminItemsPlugin.getInstance());
} catch (Exception e) {
Bukkit.getLogger().warning("Failed to register admin item " + adminItem.getID());
System.out.println(e.getMessage());
}
}
public void unregisterAll() {
this.adminItems.clear();
}
public void unregister(AdminItem adminItem) {
this.adminItems.remove(adminItem.getID());
}
public void reload() {
this.unregisterAll();
this.initialize();
}
public boolean isAdminItem(String name) {
return (this.getAdminItemFromID(name) != null);
}
public AdminItem getAdminItemFromID(String id) {
Validate.notNull(id);
Validate.notEmpty(id);
return this.adminItems.get(id.toLowerCase());
}
public AdminItem getAdminItemFromName(String name) {
Validate.notNull(name);
Validate.notEmpty(name);
name = this.getAdminItemIDFromName(name);
return this.adminItems.get(name.toLowerCase());
}
public String getAdminItemIDFromName(String name) {
return name.replace(" ", "").toLowerCase(Locale.ROOT);
}
public Collection<AdminItem> getAdminItems() {
return Collections.unmodifiableCollection(this.adminItems.values());
}
}
@@ -0,0 +1,4 @@
package net.crankedpvp.adminitems.struct;
public interface Interactable {
}
@@ -0,0 +1,5 @@
package net.crankedpvp.adminitems.struct;
public interface Throwable {
}
@@ -0,0 +1,19 @@
package net.crankedpvp.adminitems.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 "adminitem.";
String name() default "";
}
@@ -0,0 +1,119 @@
package net.crankedpvp.adminitems.struct.config;
import lombok.AccessLevel;
import lombok.Getter;
import net.crankedpvp.adminitems.AdminItemsPlugin;
import net.crankedpvp.adminitems.struct.AdminItem;
import net.crankedpvp.adminitems.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 AdminItemConfig {
@Getter(value = AccessLevel.PRIVATE)
private final AdminItemsPlugin plugin;
private final String path;
private FileConfiguration config;
private final File configFile;
private final AdminItem adminItem;
public AdminItemConfig(AdminItemsPlugin plugin, String path, AdminItem adminItem) {
this.plugin = plugin;
this.path = path;
this.adminItem = adminItem;
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.adminItem.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.adminItem));
needSave = true;
continue;
}
Object fieldValue = this.config.get(path + name);
if (fieldValue instanceof String) fieldValue = CC.translate((String) fieldValue);
field.set(this.adminItem, fieldValue);
}
} catch (IllegalAccessException | NullPointerException | IllegalArgumentException e) {
Bukkit.getConsoleSender().sendMessage(CC.translate("&c[CrankedAdminItems] - Error invalid config value for adminItem " + adminItem.getName()));
}
}
if (needSave) {
saveConfig();
reloadConfig();
}
}
}
@@ -0,0 +1,38 @@
package net.crankedpvp.adminitems.struct.config;
import lombok.Getter;
import net.crankedpvp.adminitems.AdminItemsPlugin;
import net.crankedpvp.adminitems.struct.AdminItem;
import org.bukkit.configuration.file.FileConfiguration;
import java.util.HashMap;
import java.util.Map;
public class AdminItemConfigManager {
@Getter
private final Map<AdminItem, AdminItemConfig> configs = new HashMap<>();
public AdminItemConfigManager(AdminItemsPlugin plugin) {
for (AdminItem adminItem : plugin.getAdminItemRegister().getAdminItems()) {
AdminItemConfig adminItemConfig = new AdminItemConfig(plugin, "adminitems/" + adminItem.getID() + ".yml", adminItem);
configs.put(adminItem, adminItemConfig);
}
}
public void setupFiles() {
configs.values().forEach(AdminItemConfig::setupConfigFile);
}
public void reloadFiles() {
configs.values().forEach(AdminItemConfig::reloadConfig);
}
public AdminItemConfig getAbstractConfig(AdminItem pet) {
return configs.get(pet);
}
public FileConfiguration getConfig(AdminItem pet) {
return getAbstractConfig(pet).getConfig();
}
}
@@ -0,0 +1,87 @@
package net.crankedpvp.adminitems.tasks;
import com.gmail.filoghost.holographicdisplays.api.Hologram;
import com.gmail.filoghost.holographicdisplays.api.line.TextLine;
import lombok.Getter;
import net.crankedpvp.adminitems.AdminItemsPlugin;
import net.crankedpvp.adminitems.language.Language;
import net.crankedpvp.adminitems.managers.AdminItemAbilityManager;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.ChunkUtils;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.Location;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.scheduler.BukkitRunnable;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
@Getter
public class TimeTravelerTask extends BukkitRunnable {
private AdminItemAbilityManager abilityManager = AdminItemsPlugin.getInstance().getAbilityManager();
private int duration;
private Hologram hologram;
private Player player;
private Location spawnLocation;
private ParticleBuilder particle;
public TimeTravelerTask(int duration, Hologram hologram, Player player, Location spawnLocation) {
this.duration = duration;
this.hologram = hologram;
this.player = player;
this.spawnLocation = spawnLocation;
this.particle = new ParticleBuilder(ParticleEffect.PORTAL, player.getLocation())
.setAmount(200)
.setOffsetY(1.5f)
.setOffsetX(1.5f)
.setOffsetZ(1.5f)
.setSpeed(0.05f);
}
@Override
public void run() {
if (player == null) {
hologram.delete();
abilityManager.getTimeTravellers().remove(player.getUniqueId());
this.cancel();
return;
}
if (!player.isOnline()) {
hologram.delete();
abilityManager.getTimeTravellers().remove(player.getUniqueId());
this.cancel();
return;
}
if (spawnLocation.getWorld() != player.getWorld()) {
hologram.delete();
abilityManager.getTimeTravellers().remove(player.getUniqueId());
this.cancel();
return;
}
if (duration == 0) {
Language.TIME_TRAVEL_ENDED.send(player);
player.teleport(spawnLocation, PlayerTeleportEvent.TeleportCause.UNKNOWN);
player.playSound(player.getLocation(), Sound.PORTAL_TRIGGER, 10f, 1.4f);
hologram.delete();
abilityManager.getTimeTravellers().remove(player.getUniqueId());
this.cancel();
return;
}
updateHologram(CC.translate("&d&l * &fTime: &d" + duration + "s &7left"));
this.particle.setLocation(player.getLocation()).display(PVPUtils.getNearbyPlayers(player, 30));
player.sendMessage(CC.translate(Language.TIME_TRAVEL_TIME.getMessage().replace("%time%", String.valueOf(duration))));
duration--;
}
private void updateHologram(String newText) {
final TextLine textLine = (TextLine)this.hologram.getLine(1);
textLine.setText(newText);
}
}
@@ -0,0 +1,35 @@
INVALID_ADMIN_ITEM: "&c&l(!)&c Invalid admin item name."
USE_STACKED_ADMIN_ITEM: "&3&lAdmin Items &8➥ &7You cannot use stacked admin items."
ADMIN_COMMAND_HELP:
- "&8--- &3Cranked &fAdminItems &8---"
- "&3/cai &fitem &7<adminItem> [player]"
ADMIN_RELOADING: "&3&l(!) &7Reloading configs now..."
ADMIN_RELOADED: "&3&l(!) &7Reloaded configs and other cool stuff. Took &3%took%ms&7."
ADMIN_ITEM_ABILITY_COOLDOWN: "&3&lAdmin Items &8➥ &7You cannot use this ability for another &f%time&7."
TRAP_BLOCKER_CANNOT_INTERACT: "&c&lTRAP BLOCKER:&c You cannot do this while being trap blocked!"
TRAP_BLOCKER_ENEMY_ON_COOLDOWN: "&c&lTRAP BLOCKER:&c %enemy% is still on trap blocker cooldown for %time%!"
TRAP_BLOCKED_BY: "&c&lTRAP BLOCKER:&c You have been trap blocked by &7%enemy%&c for &7%time%&c. &cWhile trap blocked you can no longer build, break blocks or open doors."
TRAP_BLOCKED: "&c&lTRAP BLOCKER:&c You have trap blocked &7%amount% &cenemies: &7%blockedList%&c."
TRAP_BLOCKER_NO_NEARBY: "&c&lTRAP BLOCKER:&c No valid targets have been found!"
TRAP_BLOCKER_ENDED: "&c&lTRAP BLOCKER:&c You are no longer trap blocked!"
TIME_TRAVEL_DIED: "&5&lTIME TRAVELER:&5 Since you died you will no longer be teleported to your previous location."
TIME_TRAVEL_TIME: "&5&lTIME TRAVELER:&5 You will teleported back to your previous location in &7%time% seconds&5."
TIME_TRAVEL_USED: "&5&lTIME TRAVELER:&5 You have used a time traveler, you will be teleported back in &7%time% seconds&5."
TIME_TRAVEL_ENDED: "&5&lTIME TRAVELER:&5 You have been teleported back to your previous location!"
TIME_TRAVEL_CANCELED_BECAUSE_TELEPORT: "&5&lTIME TRAVELER:&5 Your time traveler was canceled!"
GRAPPLED_ENEMY: "&b&lGRAPPLING HOOK:&b You have grappled &7%enemy% &btowards you!"
GRAPPLED_BY_PLAYER: "&b&lGRAPPLING HOOK:&b You have been grappled towards %player%&b!"
GRAPPLED: "&b&lGRAPPLING HOOK: &bYou have grappled away!"
GRAPPLED_CANNOT_USE_IN_WORLD: "&b&lGRAPPLING HOOK: &bYou cannot use grappling hooks in this world"
SWITCHERED: "&d&lSWITCHER BALL: &dYou have switched positions with &7%shot%!"
SWITCHERED_BY_PLAYER: "&d&lSWITCHER BALL: &dYou have been hit with a switcher ball by &7%player%&d!"
SWITCHER_HIT_NONE: "&d&lSWITCHER BALL: &dYou didn't hit a player while using the switcher ball!"
+7
View File
@@ -0,0 +1,7 @@
name: CrankedAdminItems
main: net.crankedpvp.adminitems.AdminItemsPlugin
version: ${git.total.commit.count}.0
description: "§fCommit ID: §a${git.commit.id.abbrev}"
website: https://crankedpvp.net/
depend:
- CrankedUtils