Brandon
/
javaee-plugins
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

f 

f
This commit is contained in:
disclearing 2019-01-21 21:58:36 +00:00
parent 3bd7c2da34
commit bc0329b758
772 changed files with 60822 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitattributes vendored Normal file
View File

@ -0,0 +1,2 @@
# Auto detect text files and perform LF normalization
* text=auto

75
Bunkers/pom.xml Normal file
View File

@ -0,0 +1,75 @@
<?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">
<modelVersion>4.0.0</modelVersion>
<groupId>me.javaee.bunkers</groupId>
<artifactId>Bunkers</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
</execution>
</executions>
<configuration>
<finalName>${artifactId}-${version}</finalName>
<artifactSet>
<includes>
<include>org.mongodb:mongo-java-driver</include>
<include>com.google.code.gson:gson</include>
</includes>
</artifactSet>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.github.paperspigot</groupId>
<artifactId>paperspigot-api</artifactId>
<version>1.7.10-R0.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.github.paperspigot</groupId>
<artifactId>paperspigot</artifactId>
<version>1.7.10-R0.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.5.0</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.2</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.18</version>
</dependency>
<dependency>
<groupId>com.comphenix.protocol</groupId>
<artifactId>ProtocolLib</artifactId>
<version>4.4.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>

89
Bunkers/src/main/java/com/bizarrealex/azazel/Azazel.java Normal file
View File

@ -0,0 +1,89 @@
package com.bizarrealex.azazel;
import com.bizarrealex.azazel.tab.Tab;
import com.bizarrealex.azazel.tab.TabAdapter;
import lombok.Getter;
import lombok.Setter;
import net.minecraft.server.v1_7_R4.EntityPlayer;
import net.minecraft.server.v1_7_R4.PacketPlayOutPlayerInfo;
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class Azazel implements Listener {
@Getter private final JavaPlugin plugin;
private final Map<UUID, Tab> tabs;
@Getter @Setter private TabAdapter adapter;
public Azazel(JavaPlugin plugin) {
this.plugin = plugin;
this.tabs = new ConcurrentHashMap<>();
if (Bukkit.getMaxPlayers() < 60) {
Bukkit.getLogger().severe("There aren't 60 player slots, this will fuck up the tab list."); //TODO: Possibly set max players to 60?
}
for (Player player : Bukkit.getOnlinePlayers()) {
if (!(tabs.containsKey(player.getUniqueId()))) {
tabs.put(player.getUniqueId(), new Tab(player, true, this));
}
}
new AzazelTask(this, plugin);
Bukkit.getPluginManager().registerEvents(this, plugin);
}
public Azazel(JavaPlugin plugin, TabAdapter adapter) {
this(plugin);
this.adapter = adapter;
}
public Tab getTabByPlayer(Player player) {
return tabs.get(player.getUniqueId());
}
@EventHandler
public void onPlayerJoinEvent(PlayerJoinEvent event) {
for (Player player : Bukkit.getOnlinePlayers()) {
PacketPlayOutPlayerInfo packet = PacketPlayOutPlayerInfo.removePlayer(((CraftPlayer) event.getPlayer()).getHandle());
((CraftPlayer) player).getHandle().playerConnection.sendPacket(packet);
}
new BukkitRunnable() {
@Override
public void run() {
tabs.put(event.getPlayer().getUniqueId(), new Tab(event.getPlayer(), true, Azazel.this));
}
}.runTaskLater(plugin, 20L);
}
@EventHandler
public void onPlayerQuitEvent(PlayerQuitEvent event) {
tabs.remove(event.getPlayer().getUniqueId());
for (Player other : Bukkit.getOnlinePlayers()) {
EntityPlayer entityPlayer = ((CraftPlayer) other).getHandle();
if (entityPlayer.playerConnection.networkManager.getVersion() >= 47) {
Tab tab = getTabByPlayer(event.getPlayer());
if (tab != null && tab.getElevatedTeam() != null) {
tab.getElevatedTeam().removeEntry(event.getPlayer().getName());
}
}
}
}
}

104
Bunkers/src/main/java/com/bizarrealex/azazel/AzazelTask.java Normal file
View File

@ -0,0 +1,104 @@
package com.bizarrealex.azazel;
import com.bizarrealex.azazel.tab.TabTemplate;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scoreboard.Team;
import com.bizarrealex.azazel.tab.Tab;
import com.bizarrealex.azazel.tab.TabAdapter;
import java.util.*;
/*
TODO: Clean this thing up
*/
public class AzazelTask extends BukkitRunnable {
private final Azazel azazel;
public AzazelTask(Azazel azazel, JavaPlugin plugin) {
this.azazel = azazel;
runTaskTimerAsynchronously(plugin, 2L, 2L);
}
@Override
public void run() {
TabAdapter adapter = azazel.getAdapter();
if (adapter != null) {
for (Player player : Bukkit.getOnlinePlayers()) {
Tab tab = azazel.getTabByPlayer(player);
if (tab != null) {
TabTemplate template = adapter.getTemplate(player);
if (template == null || (template.getLeft().isEmpty() && template.getMiddle().isEmpty() && template.getRight().isEmpty())) {
for (Tab.TabEntryPosition position : tab.getPositions()) {
Team team = player.getScoreboard().getTeam(position.getKey());
if (team != null) {
if (team.getPrefix() != null && !team.getPrefix().isEmpty()) {
team.setPrefix("");
}
if (team.getSuffix() != null && !team.getSuffix().isEmpty()) {
team.setSuffix("");
}
}
}
continue;
}
for (int i = 0; i < 20 - template.getLeft().size(); i++) {
template.left("");
}
for (int i = 0; i < 20 - template.getMiddle().size(); i++) {
template.middle("");
}
for (int i = 0; i < 20 - template.getRight().size(); i++) {
template.right("");
}
List<List<String>> rows = Arrays.asList(template.getLeft(), template.getMiddle(), template.getRight(), template.getFarRight());
for (int l = 0; l < rows.size(); l++) {
for (int i = 0; i < rows.get(l).size(); i++) {
Team team = tab.getByLocation(l, i);
if (team != null) {
Map.Entry<String, String> prefixAndSuffix = getPrefixAndSuffix(rows.get(l).get(i));
String prefix = prefixAndSuffix.getKey();
String suffix = prefixAndSuffix.getValue();
if (team.getPrefix().equals(prefix) && team.getSuffix().equals(suffix)) {
continue;
}
team.setPrefix(prefix);
team.setSuffix(suffix);
}
}
}
}
}
}
}
private Map.Entry<String, String> getPrefixAndSuffix(String text) {
String prefix, suffix;
text = ChatColor.translateAlternateColorCodes('&', text);
if (text.length() > 16){
int splitAt = text.charAt(15) == ChatColor.COLOR_CHAR ? 15 : 16;
prefix = text.substring(0, splitAt);
String suffixTemp = ChatColor.getLastColors(prefix) + text.substring(splitAt);
suffix = (suffixTemp.substring(0, Math.min(suffixTemp.length(), 16)));
} else {
prefix = text;
suffix = "";
}
return new AbstractMap.SimpleEntry<>(prefix, suffix);
}
}

221
Bunkers/src/main/java/com/bizarrealex/azazel/tab/Tab.java Normal file
View File

@ -0,0 +1,221 @@
package com.bizarrealex.azazel.tab;
import com.bizarrealex.azazel.Azazel;
import lombok.Getter;
import lombok.Setter;
import net.minecraft.server.v1_7_R4.Packet;
import net.minecraft.server.v1_7_R4.PacketPlayOutPlayerInfo;
import net.minecraft.util.com.mojang.authlib.GameProfile;
import net.minecraft.util.com.mojang.authlib.properties.Property;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.scoreboard.Scoreboard;
import org.bukkit.scoreboard.Team;
import java.lang.reflect.Field;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class Tab {
@Getter private Scoreboard scoreboard;
@Getter @Setter private Team elevatedTeam;
private Map<TabEntryPosition, String> entries;
public Tab(Player player, boolean hook, Azazel azazel) {
this.entries = new ConcurrentHashMap<>();
scoreboard = Bukkit.getScoreboardManager().getNewScoreboard();
if (hook && !player.getScoreboard().equals(Bukkit.getScoreboardManager().getMainScoreboard())) {
scoreboard = player.getScoreboard();
}
elevatedTeam = scoreboard.registerNewTeam(getBlanks().get(getBlanks().size() - 1));
for (Player other : Bukkit.getOnlinePlayers()) {
getElevatedTeam(other, azazel).addEntry(other.getName());
Tab tab = azazel.getTabByPlayer(other);
if (tab != null) {
tab.getElevatedTeam(player, azazel).addEntry(player.getName());
}
PacketPlayOutPlayerInfo packet = PacketPlayOutPlayerInfo.removePlayer(((CraftPlayer) other).getHandle());
((CraftPlayer) player).getHandle().playerConnection.sendPacket(packet);
}
player.setScoreboard(scoreboard);
initialize(player);
}
public Team getElevatedTeam(Player player, Azazel azazel) {
if (player.hasMetadata("HydrogenPrefix")) {
String prefix = ChatColor.getLastColors(player.getDisplayName().replace(ChatColor.RESET + "", ""));
String name = getBlanks().get(getBlanks().size() - 1) + prefix;
if (name.length() > 16) {
name = name.substring(0, 15);
}
Team team = scoreboard.getTeam(name);
if (team == null) {
team = scoreboard.registerNewTeam(name);
team.setPrefix(prefix);
}
return team;
}
return elevatedTeam;
}
public Set<TabEntryPosition> getPositions() {
return entries.keySet();
}
public Team getByLocation(int x, int y) {
for (TabEntryPosition position : entries.keySet()) {
if (position.getX() == x && position.getY() == y) {
return scoreboard.getTeam(position.getKey());
}
}
return null;
}
private void initialize(Player player) {
if (((CraftPlayer) player).getHandle().playerConnection.networkManager.getVersion() >= 47) {
for (int x = 0; x < 4; x++) {
for (int y = 0; y < 20; y++) {
String key = getNextBlank();
TabEntryPosition position = new TabEntryPosition(x, y, key, scoreboard);
entries.put(position, key);
((CraftPlayer) player).getHandle().playerConnection.sendPacket(getPlayerPacket(entries.get(position)));
Team team = scoreboard.getTeam(position.getKey());
if (team == null) {
team = scoreboard.registerNewTeam(position.getKey());
}
team.addEntry(entries.get(position));
}
}
} else {
for (int i = 0; i < 60; i++) {
int x = i % 3;
int y = i / 3;
String key = getNextBlank();
TabEntryPosition position = new TabEntryPosition(x, y, key, scoreboard);
entries.put(position, key);
((CraftPlayer) player).getHandle().playerConnection.sendPacket(getPlayerPacket(entries.get(position)));
Team team = scoreboard.getTeam(position.getKey());
if (team == null) {
team = scoreboard.registerNewTeam(position.getKey());
}
team.addEntry(entries.get(position));
}
}
}
private String getNextBlank() {
outer:
for (String blank : getBlanks()) {
if (scoreboard.getTeam(blank) != null) {
continue;
}
for (String identifier : entries.values()) {
if (identifier.equals(blank)) {
continue outer;
}
}
return blank;
}
return null;
}
public List<String> getBlanks() {
List<String> toReturn = new ArrayList<>();
for (ChatColor color : ChatColor.values()) {
for (int i = 0; i < 4; i++) {
String identifier = StringUtils.repeat(color + "", 4 - i) + ChatColor.RESET;
toReturn.add(identifier);
}
}
return toReturn;
}
/*
There should be a better way to do this without reflection
*/
private static Packet getPlayerPacket(String name) {
return getPlayerPacket(name, 1);
}
private static Packet getPlayerPacket(String name, int ping) {
PacketPlayOutPlayerInfo packet = new PacketPlayOutPlayerInfo();
Field action;
Field username;
Field player;
Field latency;
try {
action = PacketPlayOutPlayerInfo.class.getDeclaredField("action");
username = PacketPlayOutPlayerInfo.class.getDeclaredField("username");
player = PacketPlayOutPlayerInfo.class.getDeclaredField("player");
latency = PacketPlayOutPlayerInfo.class.getDeclaredField("ping");
action.setAccessible(true);
username.setAccessible(true);
player.setAccessible(true);
latency.setAccessible(true);
action.set(packet, 0);
username.set(packet, name);
latency.set(packet, ping);
GameProfile profile = new GameProfile(UUID.randomUUID(), name);
profile.getProperties().put("textures", new Property("textures", "eyJ0aW1lc3RhbXAiOjE0MTEyNjg3OTI3NjUsInByb2ZpbGVJZCI6IjNmYmVjN2RkMGE1ZjQwYmY5ZDExODg1YTU0NTA3MTEyIiwicHJvZmlsZU5hbWUiOiJsYXN0X3VzZXJuYW1lIiwidGV4dHVyZXMiOnsiU0tJTiI6eyJ1cmwiOiJodHRwOi8vdGV4dHVyZXMubWluZWNyYWZ0Lm5ldC90ZXh0dXJlLzg0N2I1Mjc5OTg0NjUxNTRhZDZjMjM4YTFlM2MyZGQzZTMyOTY1MzUyZTNhNjRmMzZlMTZhOTQwNWFiOCJ9fX0=", "u8sG8tlbmiekrfAdQjy4nXIcCfNdnUZzXSx9BE1X5K27NiUvE1dDNIeBBSPdZzQG1kHGijuokuHPdNi/KXHZkQM7OJ4aCu5JiUoOY28uz3wZhW4D+KG3dH4ei5ww2KwvjcqVL7LFKfr/ONU5Hvi7MIIty1eKpoGDYpWj3WjnbN4ye5Zo88I2ZEkP1wBw2eDDN4P3YEDYTumQndcbXFPuRRTntoGdZq3N5EBKfDZxlw4L3pgkcSLU5rWkd5UH4ZUOHAP/VaJ04mpFLsFXzzdU4xNZ5fthCwxwVBNLtHRWO26k/qcVBzvEXtKGFJmxfLGCzXScET/OjUBak/JEkkRG2m+kpmBMgFRNtjyZgQ1w08U6HHnLTiAiio3JswPlW5v56pGWRHQT5XWSkfnrXDalxtSmPnB5LmacpIImKgL8V9wLnWvBzI7SHjlyQbbgd+kUOkLlu7+717ySDEJwsFJekfuR6N/rpcYgNZYrxDwe4w57uDPlwNL6cJPfNUHV7WEbIU1pMgxsxaXe8WSvV87qLsR7H06xocl2C0JFfe2jZR4Zh3k9xzEnfCeFKBgGb4lrOWBu1eDWYgtKV67M2Y+B3W5pjuAjwAxn0waODtEn/3jKPbc/sxbPvljUCw65X+ok0UUN1eOwXV5l2EGzn05t3Yhwq19/GxARg63ISGE8CKw="));
player.set(packet, profile);
} catch (NoSuchFieldException e) {
e.printStackTrace();
return null;
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return packet;
}
public static class TabEntryPosition {
@Getter private final int x, y;
@Getter private final String key;
public TabEntryPosition(int x, int y, String key, Scoreboard scoreboard) {
this.x = x;
this.y = y;
this.key = key;
}
}
}

9
Bunkers/src/main/java/com/bizarrealex/azazel/tab/TabAdapter.java Normal file
View File

@ -0,0 +1,9 @@
package com.bizarrealex.azazel.tab;
import org.bukkit.entity.Player;
public interface TabAdapter {
TabTemplate getTemplate(Player player);
}

80
Bunkers/src/main/java/com/bizarrealex/azazel/tab/TabTemplate.java Normal file
View File

@ -0,0 +1,80 @@
package com.bizarrealex.azazel.tab;
import lombok.Getter;
import java.util.ArrayList;
import java.util.List;
public class TabTemplate {
@Getter private final List<String> left;
@Getter private final List<String> middle;
@Getter private final List<String> right;
@Getter private final List<String> farRight;
public TabTemplate() {
left = new ArrayList<>();
middle = new ArrayList<>();
right = new ArrayList<>();
farRight = new ArrayList<>();
}
/*
Will only display on 1.8 clients
*/
public TabTemplate farRight(String string) {
return farRight(farRight.size(), string);
}
public TabTemplate farRight(int index, String string) {
if (index > farRight.size()) {
for (int i = farRight.size(); i < index; i++) {
farRight.add("");
}
}
farRight.add(index, string);
return this;
}
public TabTemplate left(String string) {
return left(left.size(), string);
}
public TabTemplate middle(String string) {
return middle(middle.size(), string);
}
public TabTemplate right(String string) {
return right(right.size(), string);
}
public TabTemplate left(int index, String string) {
if (index > left.size()) {
for (int i = left.size(); i < index; i++) {
left.add("");
}
}
left.add(index, string);
return this;
}
public TabTemplate middle(int index, String string) {
if (index > middle.size()) {
for (int i = middle.size(); i < index; i++) {
middle.add("");
}
}
middle.add(index, string);
return this;
}
public TabTemplate right(int index, String string) {
if (index > right.size()) {
for (int i = right.size(); i < index; i++) {
right.add("");
}
}
right.add(index, string);
return this;
}
}

99
Bunkers/src/main/java/com/bizarrealex/azazel/tab/example/ExampleTabAdapter.java Normal file
View File

@ -0,0 +1,99 @@
package com.bizarrealex.azazel.tab.example;
import com.bizarrealex.azazel.tab.TabAdapter;
import com.bizarrealex.azazel.tab.TabTemplate;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.tasks.GameTimeTask;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.BukkitUtils;
import net.minecraft.util.org.apache.commons.lang3.time.DurationFormatUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import java.lang.management.ManagementFactory;
import java.text.DecimalFormat;
import java.util.UUID;
public class ExampleTabAdapter implements TabAdapter {
Information information = Bunkers.getPlugin().getInformationManager().getInformation();
public TabTemplate getTemplate(Player player) {
TabTemplate template = new TabTemplate();
template.left(0, "&6&l" + information.getServerName());
template.middle(0, "&e&lBunkers");
template.right(0, "&6&l" + information.getServerName());
if (Bunkers.getPlugin().getTeamManager().getByPlayer(player) != null) {
Team team = Bunkers.getPlugin().getTeamManager().getByPlayer(player);
template.left(2, "&6&lTeam Info");
template.left(3, "&eDTR&7: &f" + team.getDtr());
template.left(4, "&eOnline&7: &f" + team.getMembers().size());
} else {
template.left(2, "&6&lTeam Info");
template.left(3, "&eSelect a team...");
}
template.left(6, "&6&lLocation");
if (Bunkers.getPlugin().getTeamManager().getByLocation(player.getLocation()) == null) {
template.left(7, "&4Warzone");
} else {
template.left(7, Bunkers.getPlugin().getTeamManager().getByLocation(player.getLocation()).getColor() + Bunkers.getPlugin().getTeamManager().getByLocation(player.getLocation()).getName() + " Base");
}
template.left(8, "(" + player.getLocation().getBlockX() + ", " + player.getLocation().getBlockZ() + ")");
template.left(10, "&6&lGame Info");
template.left(11, "&eKoth&7: &f" + (GameTimeTask.getNumOfSeconds() < 300 ? "Starts in " + BukkitUtils.niceTime(300 - GameTimeTask.getNumOfSeconds(), false) : BukkitUtils.niceTime(Bunkers.getPlugin().getKoth().getCapSeconds(), false)));
template.left(13, "&6&lTeams DTR");
template.left(14, "&cRed&7: &f" + Bunkers.getPlugin().getTeamManager().getByName("Red").getDtr());
template.left(15, "&9Blue&7: &f" + Bunkers.getPlugin().getTeamManager().getByName("Blue").getDtr());
template.left(16, "&aGreen&7: &f" + Bunkers.getPlugin().getTeamManager().getByName("Green").getDtr());
template.left(17, "&eYellow&7: &f" + Bunkers.getPlugin().getTeamManager().getByName("Yellow").getDtr());
template.middle(2, "&c&lRed Team");
for (String member : Bunkers.getPlugin().getTeamManager().getByName("Red").getMembersNames()) {
if (member != null) {
template.middle("&c" + member);
}
}
template.middle(10, "&a&lGreen Team");
for (String member : Bunkers.getPlugin().getTeamManager().getByName("Green").getMembersNames()) {
if (member != null) {
template.middle("&a" + member);
}
}
template.right(2, "&9&lBlue Team");
for (String member : Bunkers.getPlugin().getTeamManager().getByName("Blue").getMembersNames()) {
if (member != null) {
template.right("&9" + member);
}
}
template.right(10, "&e&lYellow Team");
for (String member : Bunkers.getPlugin().getTeamManager().getByName("Yellow").getMembersNames()) {
if (member != null) {
template.right("&e" + member);
}
}
if (player.hasPermission("bunkers.admin")) {
template.farRight(2, "&6&lServer Information");
template.farRight("&eTicks Per Sec&7: &f" + new DecimalFormat("#.##").format(Bukkit.spigot().getTPS()[0]));
template.farRight("&ePerformance&7: &f" + new DecimalFormat("#.##").format(getLag()) + "%");
template.farRight("&eRam&7: &f" + ((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / 1048576L) + "/" + Runtime.getRuntime().totalMemory() / 1048576L + "MB");
}
return template;
}
public double getLag() {
return (Bukkit.spigot().getTPS()[0] / 20 * 100 > 100 ? 100 : Bukkit.spigot().getTPS()[0] / 20 * 100);
}
}

111
Bunkers/src/main/java/me/redis/bunkers/Bunkers.java Normal file
View File

@ -0,0 +1,111 @@
package me.redis.bunkers;
import com.bizarrealex.azazel.Azazel;
import com.bizarrealex.azazel.tab.example.ExampleTabAdapter;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import lombok.Getter;
import me.redis.bunkers.entity.EntityManager;
import me.redis.bunkers.game.GameManager;
import me.redis.bunkers.game.status.GameStatus;
import me.redis.bunkers.information.InformationManager;
import me.redis.bunkers.koth.Koth;
import me.redis.bunkers.listeners.DeathMessageListener;
import me.redis.bunkers.listeners.PlayerListeners;
import me.redis.bunkers.profiles.ProfileManager;
import me.redis.bunkers.protocol.ProtocolListener;
import me.redis.bunkers.scoreboard.Aether;
import me.redis.bunkers.scoreboard.sidebars.BunkersSidebar;
import me.redis.bunkers.spectator.Spectator;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.team.TeamManager;
import me.redis.bunkers.timer.TimerManager;
import me.redis.bunkers.utils.command.CommandRegistrer;
import me.redis.bunkers.wand.WandManager;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.IOException;
@Getter
public class Bunkers extends JavaPlugin {
@Getter private static Bunkers plugin;
private MongoClient mongoClient;
private MongoDatabase mongoDatabase;
private MongoCollection informationCollection;
private InformationManager informationManager;
private MongoCollection teamsCollection;
private TeamManager teamManager;
private MongoCollection profilesCollection;
private ProfileManager profileManager;
private WandManager wandManager;
private GameManager gameManager;
private Koth koth;
private TimerManager timerManager;
private Spectator spectatorManager;
private EntityManager entityManager;
private Azazel azazel;
@Override
public void onEnable() {
plugin = this;
for (World world : Bukkit.getWorlds()) {
for (Entity entity : world.getEntities()) {
entity.remove();
}
world.setGameRuleValue("doMobSpawning", "false");
world.setGameRuleValue("doDayLightCycle", "false");
world.setTime(0);
}
/* Initialize Mongo first*/
mongoClient = new MongoClient(getConfig().getString("DATABASE.AUTH.HOST"), getConfig().getInt("DATABASE.AUTH.PORT"));
mongoDatabase = mongoClient.getDatabase(getConfig().getString("DATABASE.NAME"));
informationCollection = mongoDatabase.getCollection(getConfig().getString("DATABASE.COLLECTIONS.INFORMATION"));
teamsCollection = mongoDatabase.getCollection(getConfig().getString("DATABASE.COLLECTIONS.TEAMS"));
profilesCollection = mongoDatabase.getCollection(getConfig().getString("DATABASE.COLLECTIONS.PROFILES"));
/* Initialize Mongo first*/
teamManager = new TeamManager();
try {
teamManager.nig();
} catch (IOException e) {
e.printStackTrace();
}
informationManager = new InformationManager();
profileManager = new ProfileManager();
wandManager = new WandManager();
gameManager = new GameManager();
gameManager.setStatus(GameStatus.WAITING);
koth = new Koth();
timerManager = new TimerManager(this);
spectatorManager = new Spectator();
entityManager = new EntityManager();
new CommandRegistrer();
new ProtocolListener();
Bukkit.getPluginManager().registerEvents(new PlayerListeners(), this);
Bukkit.getPluginManager().registerEvents(new DeathMessageListener(), this);
new Aether(this, new BunkersSidebar(this));
azazel = new Azazel(this, new ExampleTabAdapter());
}
@Override
public void onDisable() {
teamManager.getTeams().values().forEach(Team::save);
}
}

123
Bunkers/src/main/java/me/redis/bunkers/entity/EntityManager.java Normal file
View File

@ -0,0 +1,123 @@
package me.redis.bunkers.entity;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.entity.types.BuildEntity;
import me.redis.bunkers.entity.types.CombatEntity;
import me.redis.bunkers.entity.types.EnchantEntity;
import me.redis.bunkers.entity.types.SellEntity;
import me.redis.bunkers.menu.MenuListener;
import me.redis.bunkers.menu.menu.BuildMenu;
import me.redis.bunkers.menu.menu.CombatMenu;
import me.redis.bunkers.menu.menu.EnchanterMenu;
import me.redis.bunkers.menu.menu.SellMenu;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.BukkitUtils;
import me.redis.bunkers.utils.LocationUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.Villager;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.event.player.PlayerInteractEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class EntityManager implements Listener {
public Map<Entity, ShopType> killedVillagers = new HashMap<>();
public EntityManager() {
Bukkit.getPluginManager().registerEvents(this, Bunkers.getPlugin());
Bukkit.getPluginManager().registerEvents(new MenuListener(), Bunkers.getPlugin());
}
@EventHandler
public void onInteract(PlayerInteractEntityEvent event) {
Player player = event.getPlayer();
if (event.getRightClicked() != null && event.getRightClicked() instanceof Villager && ((Villager) event.getRightClicked()).getCustomName() != null) {
String name = ChatColor.stripColor(((Villager) event.getRightClicked()).getCustomName());
if (name.toLowerCase().contains("combat")) {
new CombatMenu(player).open(player);
} else if (name.toLowerCase().contains("sell")) {
new SellMenu(player).open(player);
} else if (name.toLowerCase().contains("build")) {
new BuildMenu(player).open(player);
} else if (name.toLowerCase().contains("enchant")) {
new EnchanterMenu(player).open(player);
}
event.setCancelled(true);
}
}
@EventHandler
public void onDamage(EntityDamageEvent event) {
if (event.getEntity() instanceof Villager && ((Villager) event.getEntity()).getCustomName() != null && ((Villager) event.getEntity()).getCustomName().toLowerCase().contains("dead"))
event.setCancelled(true);
}
@EventHandler
public void onEntityDeath(EntityDeathEvent event) {
if (event.getEntity() instanceof Villager && event.getEntity().getCustomName() != null) {
if (event.getEntity().getCustomName().toLowerCase().contains("combat") || event.getEntity().getCustomName().toLowerCase().contains("enchant") || event.getEntity().getCustomName().toLowerCase().contains("build") || event.getEntity().getCustomName().toLowerCase().contains("sell")) {
final int[] counter = {15};
ShopType type = null;
if (event.getEntity().getCustomName().toLowerCase().contains("combat")) type = ShopType.COMBAT;
else if (event.getEntity().getCustomName().toLowerCase().contains("enchant")) type = ShopType.ENCHANT;
else if (event.getEntity().getCustomName().toLowerCase().contains("sell")) type = ShopType.SELL;
else if (event.getEntity().getCustomName().toLowerCase().contains("build")) type = ShopType.BUILD;
killedVillagers.put(event.getEntity(), type);
Villager villager = (Villager) event.getEntity().getLocation().getWorld().spawnEntity(event.getEntity().getLocation(), EntityType.VILLAGER);
villager.setFallDistance(0);
villager.setRemoveWhenFarAway(false);
villager.setAdult();
villager.setProfession(Villager.Profession.BLACKSMITH);
villager.setCanPickupItems(false);
villager.setMaxHealth(40);
villager.setHealth(40);
villager.setCustomNameVisible(true);
villager.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, -6, true), true);
new BukkitRunnable() {
@Override public void run() {
if (counter[0] <= 0) {
Team team = Bunkers.getPlugin().getTeamManager().getByColor(ChatColor.getByChar(ChatColor.getLastColors(event.getEntity().getCustomName()).replace("§", "").replace("&", "")));
if (killedVillagers.get(event.getEntity()) == ShopType.SELL) {
new SellEntity(team, LocationUtils.getLocation(team.getSellShop()));
} else if (killedVillagers.get(event.getEntity()) == ShopType.BUILD) {
new BuildEntity(team, LocationUtils.getLocation(team.getBuildShop()));
} else if (killedVillagers.get(event.getEntity()) == ShopType.ENCHANT) {
new EnchantEntity(team, LocationUtils.getLocation(team.getEnchantShop()));
} else if (killedVillagers.get(event.getEntity()) == ShopType.COMBAT) {
new CombatEntity(team, LocationUtils.getLocation(team.getCombatShop()));
}
killedVillagers.remove(event.getEntity());
villager.remove();
cancel();
return;
}
villager.setCustomName(ChatColor.RED + "Dead for" + ChatColor.GRAY + ": " + ChatColor.WHITE + BukkitUtils.niceTime(counter[0], false));
counter[0]--;
}
}.runTaskTimer(Bunkers.getPlugin(), 0L, 20L);
}
}
}
}

5
Bunkers/src/main/java/me/redis/bunkers/entity/ShopType.java Normal file
View File

@ -0,0 +1,5 @@
package me.redis.bunkers.entity;
public enum ShopType {
COMBAT, SELL, BUILD, ENCHANT
}

36
Bunkers/src/main/java/me/redis/bunkers/entity/types/BuildEntity.java Normal file
View File

@ -0,0 +1,36 @@
package me.redis.bunkers.entity.types;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.entity.ShopType;
import me.redis.bunkers.team.Team;
import org.bukkit.Location;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Villager;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
@Getter
public class BuildEntity {
private Team team;
private Location spawnLocation;
@Setter private ShopType shopType;
public BuildEntity(Team team, Location spawnLocation) {
this.team = team;
this.spawnLocation = spawnLocation;
Villager villager = (Villager) spawnLocation.getWorld().spawnEntity(spawnLocation, EntityType.VILLAGER);
villager.setFallDistance(0);
villager.setRemoveWhenFarAway(false);
villager.setAdult();
villager.setProfession(Villager.Profession.BLACKSMITH);
villager.setCanPickupItems(false);
villager.setMaxHealth(40);
villager.setHealth(40);
villager.setCustomName(team.getColor() + "Build Shop");
villager.setCustomNameVisible(true);
villager.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, -6, true), true);
setShopType(ShopType.BUILD);
}
}

37
Bunkers/src/main/java/me/redis/bunkers/entity/types/CombatEntity.java Normal file
View File

@ -0,0 +1,37 @@
package me.redis.bunkers.entity.types;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.entity.ShopType;
import me.redis.bunkers.team.Team;
import org.bukkit.Location;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Villager;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
@Getter
public class CombatEntity {
private Team team;
private Location spawnLocation;
@Setter private ShopType shopType;
public CombatEntity(Team team, Location spawnLocation) {
this.team = team;
this.spawnLocation = spawnLocation;
Villager villager = (Villager) spawnLocation.getWorld().spawnEntity(spawnLocation, EntityType.VILLAGER);
villager.setFallDistance(0);
villager.setRemoveWhenFarAway(false);
villager.setAdult();
villager.setProfession(Villager.Profession.BLACKSMITH);
villager.setCanPickupItems(false);
villager.setMaxHealth(40);
villager.setHealth(40);
villager.setCustomName(team.getColor() + "Combat Shop");
villager.setCustomNameVisible(true);
villager.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, -6, true), true);
setShopType(ShopType.COMBAT);
}
}

37
Bunkers/src/main/java/me/redis/bunkers/entity/types/EnchantEntity.java Normal file
View File

@ -0,0 +1,37 @@
package me.redis.bunkers.entity.types;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.entity.ShopType;
import me.redis.bunkers.team.Team;
import org.bukkit.Location;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Villager;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
@Getter
public class EnchantEntity {
private Team team;
private Location spawnLocation;
@Setter private ShopType shopType;
public EnchantEntity(Team team, Location spawnLocation) {
this.team = team;
this.spawnLocation = spawnLocation;
Villager villager = (Villager) spawnLocation.getWorld().spawnEntity(spawnLocation, EntityType.VILLAGER);
villager.setFallDistance(0);
villager.setRemoveWhenFarAway(false);
villager.setAdult();
villager.setProfession(Villager.Profession.BLACKSMITH);
villager.setCanPickupItems(false);
villager.setMaxHealth(40);
villager.setHealth(40);
villager.setCustomName(team.getColor() + "Tim the enchanter");
villager.setCustomNameVisible(true);
villager.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, -6, true), true);
setShopType(ShopType.ENCHANT);
}
}

36
Bunkers/src/main/java/me/redis/bunkers/entity/types/SellEntity.java Normal file
View File

@ -0,0 +1,36 @@
package me.redis.bunkers.entity.types;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.entity.ShopType;
import me.redis.bunkers.team.Team;
import org.bukkit.Location;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Villager;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
@Getter
public class SellEntity {
private Team team;
private Location spawnLocation;
@Setter private ShopType shopType;
public SellEntity(Team team, Location spawnLocation) {
this.team = team;
this.spawnLocation = spawnLocation;
Villager villager = (Villager) spawnLocation.getWorld().spawnEntity(spawnLocation, EntityType.VILLAGER);
villager.setFallDistance(0);
villager.setRemoveWhenFarAway(false);
villager.setAdult();
villager.setProfession(Villager.Profession.BLACKSMITH);
villager.setCanPickupItems(false);
villager.setMaxHealth(40);
villager.setHealth(40);
villager.setCustomName(team.getColor() + "Sell Items");
villager.setCustomNameVisible(true);
villager.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, -6, true), true);
setShopType(ShopType.SELL);
}
}

27
Bunkers/src/main/java/me/redis/bunkers/events/BoardCreateEvent.java Normal file
View File

@ -0,0 +1,27 @@
package me.redis.bunkers.events;
import lombok.Getter;
import me.redis.bunkers.scoreboard.scoreboard.Board;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class BoardCreateEvent extends Event {
private static final HandlerList handlers = new HandlerList();
@Getter private final Board board;
@Getter private final Player player;
public BoardCreateEvent(Board board, Player player) {
this.board = board;
this.player = player;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

25
Bunkers/src/main/java/me/redis/bunkers/events/GameStatusChangeEvent.java Normal file
View File

@ -0,0 +1,25 @@
package me.redis.bunkers.events;
import lombok.Getter;
import me.redis.bunkers.game.status.GameStatus;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class GameStatusChangeEvent extends Event {
private static final HandlerList handlers = new HandlerList();
@Getter private GameStatus oldStatus;
@Getter private GameStatus newStatus;
public GameStatusChangeEvent(GameStatus oldStatus, GameStatus newStatus) {
this.oldStatus = oldStatus;
this.newStatus = newStatus;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

67
Bunkers/src/main/java/me/redis/bunkers/events/PlayerClaimEnterEvent.java Normal file
View File

@ -0,0 +1,67 @@
package me.redis.bunkers.events;
import me.redis.bunkers.team.Team;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class PlayerClaimEnterEvent extends Event implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancelled;
private final Player player;
private final Team fromTeam;
private final Team toTeam;
private final Location from;
private final Location to;
public PlayerClaimEnterEvent(Player player, Location from, Location to, Team fromTeam, Team toTeam) {
this.player = player;
this.from = from;
this.to = to;
this.fromTeam = fromTeam;
this.toTeam = toTeam;
}
public Team getFromTeam() {
return fromTeam;
}
public Team getToTeam() {
return toTeam;
}
public Player getPlayer() {
return player;
}
public Location getFrom() {
return from;
}
public Location getTo() {
return to;
}
public static HandlerList getHandlerList() {
return handlers;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
}

59
Bunkers/src/main/java/me/redis/bunkers/events/TimerClearEvent.java Normal file
View File

@ -0,0 +1,59 @@
package me.redis.bunkers.events;
import com.google.common.base.Optional;
import me.redis.bunkers.timer.Timer;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import java.util.UUID;
/**
* Event called when a {@link Timer} is removed.
*/
public class TimerClearEvent extends Event {
private static final HandlerList handlers = new HandlerList();
private final Optional<UUID> userUUID;
private final Timer timer;
public TimerClearEvent(Timer timer) {
this.userUUID = Optional.absent();
this.timer = timer;
}
public TimerClearEvent(UUID userUUID, Timer timer) {
this.userUUID = Optional.of(userUUID);
this.timer = timer;
}
/**
* Gets the optional UUID of the user this was removed for.
* <p>
* This may return absent if the timer is not of a player type
* </p>
*
* @return the removed user UUID or {@link Optional#absent()}
*/
public Optional<UUID> getUserUUID() {
return userUUID;
}
/**
* Gets the {@link Timer} that was expired.
*
* @return the expiring timer
*/
public Timer getTimer() {
return timer;
}
public static HandlerList getHandlerList() {
return handlers;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
}

59
Bunkers/src/main/java/me/redis/bunkers/events/TimerExpireEvent.java Normal file
View File

@ -0,0 +1,59 @@
package me.redis.bunkers.events;
import com.google.common.base.Optional;
import me.redis.bunkers.timer.Timer;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import java.util.UUID;
/**
* Event called when a {@link Timer} expires.
*/
public class TimerExpireEvent extends Event {
private static final HandlerList handlers = new HandlerList();
private final Optional<UUID> userUUID;
private final Timer timer;
public TimerExpireEvent(Timer timer) {
this.userUUID = Optional.absent();
this.timer = timer;
}
public TimerExpireEvent(UUID userUUID, Timer timer) {
this.userUUID = Optional.fromNullable(userUUID);
this.timer = timer;
}
/**
* Gets the optional UUID of the user this has expired for.
* <p>
* This may return absent if the timer is not of a player type
* </p>
*
* @return the expiring user UUID or {@link Optional#absent()}
*/
public Optional<UUID> getUserUUID() {
return userUUID;
}
/**
* Gets the {@link Timer} that was expired.
*
* @return the expiring timer
*/
public Timer getTimer() {
return timer;
}
public static HandlerList getHandlerList() {
return handlers;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
}

98
Bunkers/src/main/java/me/redis/bunkers/events/TimerExtendEvent.java Normal file
View File

@ -0,0 +1,98 @@
package me.redis.bunkers.events;
import com.google.common.base.Optional;
import me.redis.bunkers.timer.Timer;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import javax.annotation.Nullable;
import java.util.UUID;
/**
* Event called when a {@link Timer} is extended.
*/
public class TimerExtendEvent extends Event implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancelled;
private final Optional<Player> player;
private final Optional<UUID> userUUID;
private final Timer timer;
private final long previousDuration;
private long newDuration;
public TimerExtendEvent(Timer timer, long previousDuration, long newDuration) {
this.player = Optional.absent();
this.userUUID = Optional.absent();
this.timer = timer;
this.previousDuration = previousDuration;
this.newDuration = newDuration;
}
public TimerExtendEvent(@Nullable Player player, UUID uniqueId, Timer timer, long previousDuration, long newDuration) {
this.player = Optional.fromNullable(player);
this.userUUID = Optional.fromNullable(uniqueId);
this.timer = timer;
this.previousDuration = previousDuration;
this.newDuration = newDuration;
}
public Optional<Player> getPlayer() {
return player;
}
/**
* Gets the optional UUID of the user this was removed for.
* <p>
* This may return absent if the timer is not of a player type
* </p>
*
* @return the removed user UUID or {@link Optional#absent()}
*/
public Optional<UUID> getUserUUID() {
return userUUID;
}
/**
* Gets the {@link Timer} that was expired.
*
* @return the expiring timer
*/
public Timer getTimer() {
return timer;
}
public long getPreviousDuration() {
return previousDuration;
}
public long getNewDuration() {
return newDuration;
}
public void setNewDuration(long newDuration) {
this.newDuration = newDuration;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public static HandlerList getHandlerList() {
return handlers;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
}

78
Bunkers/src/main/java/me/redis/bunkers/events/TimerPauseEvent.java Normal file
View File

@ -0,0 +1,78 @@
package me.redis.bunkers.events;
import com.google.common.base.Optional;
import me.redis.bunkers.timer.Timer;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import java.util.UUID;
/**
* Event called when the pause state of a {@link Timer} changes.
*/
public class TimerPauseEvent extends Event implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancelled;
private final boolean paused;
private final Optional<UUID> userUUID;
private final Timer timer;
public TimerPauseEvent(Timer timer, boolean paused) {
this.userUUID = Optional.absent();
this.timer = timer;
this.paused = paused;
}
public TimerPauseEvent(UUID userUUID, Timer timer, boolean paused) {
this.userUUID = Optional.fromNullable(userUUID);
this.timer = timer;
this.paused = paused;
}
/**
* Gets the optional UUID of the user this has expired for.
* <p>
* This may return absent if the timer is not of a player type
* </p>
*
* @return the expiring user UUID or {@link Optional#absent()}
*/
public Optional<UUID> getUserUUID() {
return userUUID;
}
/**
* Gets the {@link Timer} that was expired.
*
* @return the expiring timer
*/
public Timer getTimer() {
return timer;
}
public static HandlerList getHandlerList() {
return handlers;
}
public boolean isPaused() {
return paused;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
}

75
Bunkers/src/main/java/me/redis/bunkers/events/TimerStartEvent.java Normal file
View File

@ -0,0 +1,75 @@
package me.redis.bunkers.events;
import com.google.common.base.Optional;
import me.redis.bunkers.timer.Timer;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import javax.annotation.Nullable;
import java.util.UUID;
/**
* Event called when a {@link Timer} starts.
*/
public class TimerStartEvent extends Event {
private static final HandlerList handlers = new HandlerList();
private final Optional<Player> player;
private final Optional<UUID> userUUID;
private final Timer timer;
private final long duration;
public TimerStartEvent(Timer timer, final long duration) {
this.player = Optional.absent();
this.userUUID = Optional.absent();
this.timer = timer;
this.duration = duration;
}
public TimerStartEvent(@Nullable Player player, UUID uniqueId, Timer timer, long duration) {
this.player = Optional.fromNullable(player);
this.userUUID = Optional.fromNullable(uniqueId);
this.timer = timer;
this.duration = duration;
}
public Optional<Player> getPlayer() {
return player;
}
/**
* Gets the optional UUID of the user this has expired for.
* <p>
* This may return absent if the timer is not of a player type
* </p>
*
* @return the expiring user UUID or {@link Optional#absent()}
*/
public Optional<UUID> getUserUUID() {
return userUUID;
}
/**
* Gets the {@link Timer} that was expired.
*
* @return the expiring timer
*/
public Timer getTimer() {
return timer;
}
public long getDuration() {
return duration;
}
public static HandlerList getHandlerList() {
return handlers;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
}

112
Bunkers/src/main/java/me/redis/bunkers/game/GameManager.java Normal file
View File

@ -0,0 +1,112 @@
package me.redis.bunkers.game;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.events.GameStatusChangeEvent;
import me.redis.bunkers.game.status.GameStatus;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.profiles.status.PlayerStatus;
import me.redis.bunkers.tasks.GameTimeTask;
import me.redis.bunkers.tasks.KothTask;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.LocationUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
public class GameManager {
@Getter private Bunkers bunkers = Bunkers.getPlugin();
@Getter private GameStatus status;
@Getter @Setter private Boolean started = false;
@Getter @Setter private long gameTime;
@Getter @Setter private boolean event = false;
@Getter private int scoreboard = 0;
@Getter @Setter private String eventName = "Custom Event";
@Getter @Setter private Team winnerTeam;
public GameManager() {
Bukkit.getScheduler().runTaskTimerAsynchronously(Bunkers.getPlugin(), () -> {
if (event) {
if (scoreboard == 0) {
scoreboard = 1;
} else if (scoreboard == 1) {
scoreboard = 0;
}
}
}, 20L, 20 * 3L);
}
public void setStatus(GameStatus status) {
Bukkit.getPluginManager().callEvent(new GameStatusChangeEvent(this.status, status));
this.status = status;
}
public boolean canBePlayed() {
return bunkers.getTeamManager().canBePlayed();
}
@Getter private final int[] cooldown = {30};
public void startCooldown() {
setStatus(GameStatus.STARTING);
setStarted(true);
new BukkitRunnable() {
@Override public void run() {
if (cooldown[0] <= 0) {
startGame();
cancel();
} else {
if (cooldown[0] % 5 == 0) {
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&eThe match will start in &9" + cooldown[0] + " seconds&e."));
}
}
cooldown[0]--;
}
}.runTaskTimer(Bunkers.getPlugin(), 20L, 20L);
}
public void startGame() {
for (Player player : Bukkit.getOnlinePlayers()) {
if (Bunkers.getPlugin().getTeamManager().getByPlayer(player) != null) {
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
Team team = Bunkers.getPlugin().getTeamManager().getByPlayer(player);
player.teleport(LocationUtils.getLocation(team.getSpawnLocation()));
player.getInventory().clear();
player.getInventory().setItem(0, new ItemStack(Material.STONE_PICKAXE));
player.getInventory().setItem(1, new ItemStack(Material.STONE_AXE));
setStatus(GameStatus.PLAYING);
profile.setStatus(PlayerStatus.PLAYING);
profile.setGamesPlayed(profile.getGamesPlayed() + 1);
profile.setBalance(500);
profile.save();
team.setDtr(team.getMembers().size());
player.sendMessage(ChatColor.GREEN + "The match has started...");
} else {
player.kickPlayer(ChatColor.RED + "You must have a team to play.");
}
}
Bukkit.getScheduler().scheduleAsyncRepeatingTask(Bunkers.getPlugin(), () -> {
Bukkit.getOnlinePlayers().forEach(player -> {
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
if (profile.getStatus() == PlayerStatus.PLAYING) {
profile.setBalance(profile.getBalance() + 3);
}
});
}, 0L, 20 * 3L);
new GameTimeTask().runTaskTimerAsynchronously(Bunkers.getPlugin(), 20L, 20L);
Bukkit.getScheduler().runTaskLater(Bunkers.getPlugin(), () -> new KothTask().runTaskTimer(Bunkers.getPlugin(), 20L, 20L), 20 * 60 * 5);
}
}

5
Bunkers/src/main/java/me/redis/bunkers/game/status/GameStatus.java Normal file
View File

@ -0,0 +1,5 @@
package me.redis.bunkers.game.status;
public enum GameStatus {
WAITING, STARTING, PLAYING, ENDING
}

68
Bunkers/src/main/java/me/redis/bunkers/information/Information.java Normal file
View File

@ -0,0 +1,68 @@
package me.redis.bunkers.information;
import com.mongodb.client.FindIterable;
import com.mongodb.client.model.Filters;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.LocationUtils;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.bukkit.Location;
@Getter
public class Information {
@Setter private String lobbyLocation, kothFirstLocation, kothSecondLocation;
@Setter private String serverName;
@Setter private int minPlayers = 5;
@Setter private String address = "none";
public Information() {
load();
}
public void load() {
Document document = (Document) Bunkers.getPlugin().getInformationCollection().find(Filters.eq("_id", "Information")).first();
if (document == null) return;
lobbyLocation = document.getString("lobbyLocation");
serverName = document.getString("serverName");
kothFirstLocation = document.getString("kothFirstLocation");
kothSecondLocation = document.getString("kothSecondLocation");
minPlayers = document.getInteger("minPlayers");
address = document.getString("address");
}
public void save() {
Document document = new Document("_id", "Information");
document.put("lobbyLocation", lobbyLocation);
document.put("serverName", serverName);
document.put("kothFirstLocation", kothFirstLocation);
document.put("kothSecondLocation", kothSecondLocation);
document.put("minPlayers", minPlayers);
document.put("address", address);
Bson filter = Filters.eq("_id", "Information");
FindIterable iterable = Bunkers.getPlugin().getInformationCollection().find(filter);
if (iterable.first() == null) {
Bunkers.getPlugin().getInformationCollection().insertOne(document);
} else {
Bunkers.getPlugin().getInformationCollection().replaceOne(filter, document);
}
Bunkers.getPlugin().getInformationManager().setInformation(this);
}
public Cuboid getKothCuboid() {
return new Cuboid(LocationUtils.getLocation(kothFirstLocation), LocationUtils.getLocation(kothSecondLocation));
}
public Location getKothCenter() {
return getKothCuboid().getCenter();
}
}

12
Bunkers/src/main/java/me/redis/bunkers/information/InformationManager.java Normal file
View File

@ -0,0 +1,12 @@
package me.redis.bunkers.information;
import lombok.Getter;
import lombok.Setter;
public class InformationManager {
@Getter @Setter public Information information;
public InformationManager() {
setInformation(new Information());
}
}

19
Bunkers/src/main/java/me/redis/bunkers/information/commands/InformationCommand.java Normal file
View File

@ -0,0 +1,19 @@
package me.redis.bunkers.information.commands;
import me.redis.bunkers.information.commands.argments.*;
import me.redis.bunkers.utils.command.ExecutableCommand;
public class InformationCommand extends ExecutableCommand {
public InformationCommand() {
super("information", null, "info", "bunkers");
addArgument(new ShowArgument());
addArgument(new SetSpawnArgument());
addArgument(new SetKothAreaArgument());
addArgument(new SetMinimumPlayersArgument());
addArgument(new SetServerNameArgument());
addArgument(new SetAddressArgument());
addArgument(new SetEventArgument());
addArgument(new SetEventNameArgument());
}
}

42
Bunkers/src/main/java/me/redis/bunkers/information/commands/argments/SetAddressArgument.java Normal file
View File

@ -0,0 +1,42 @@
package me.redis.bunkers.information.commands.argments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.JavaUtils;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetAddressArgument extends CommandArgument {
public SetAddressArgument() {
super("setaddress", null, "setip");
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <address>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 2) {
player.sendMessage(getUsage(label));
return true;
}
Information information = Bunkers.getPlugin().getInformationManager().getInformation();
information.setAddress(args[1]);
information.save();
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have the server's address. &7&o(You can check it by /information show)"));
}
return true;
}
}

47
Bunkers/src/main/java/me/redis/bunkers/information/commands/argments/SetEventArgument.java Normal file
View File

@ -0,0 +1,47 @@
package me.redis.bunkers.information.commands.argments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.game.GameManager;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.JavaUtils;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetEventArgument extends CommandArgument {
public SetEventArgument() {
super("setgameevent", null, "setevent");
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <true/false>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 2) {
player.sendMessage(getUsage(label));
return true;
}
if (!JavaUtils.isBoolean(args[1])) {
player.sendMessage(ChatColor.RED + "You must introduce true/false.");
return true;
}
GameManager manager = Bunkers.getPlugin().getGameManager();
manager.setEvent(Boolean.parseBoolean(args[1]));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eThis is now an event match. &7&o(You can check them by /information show)"));
}
return true;
}
}

42
Bunkers/src/main/java/me/redis/bunkers/information/commands/argments/SetEventNameArgument.java Normal file
View File

@ -0,0 +1,42 @@
package me.redis.bunkers.information.commands.argments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.game.GameManager;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.JavaUtils;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetEventNameArgument extends CommandArgument {
public SetEventNameArgument() {
super("seteventname");
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <name...>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length < 2) {
player.sendMessage(getUsage(label));
return true;
}
GameManager manager = Bunkers.getPlugin().getGameManager();
manager.setEventName(StringUtils.join(args, " ", 1, args.length));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have set the event name. &7&o(You can check them by /information show)"));
}
return true;
}
}

57
Bunkers/src/main/java/me/redis/bunkers/information/commands/argments/SetKothAreaArgument.java Normal file
View File

@ -0,0 +1,57 @@
package me.redis.bunkers.information.commands.argments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.protocol.ClaimPillar;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import me.redis.bunkers.wand.Wand;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetKothAreaArgument extends CommandArgument {
public SetKothAreaArgument() {
super("setkotharea", null, "area");
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName();
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 1) {
player.sendMessage(getUsage(label));
return true;
}
Wand wand = Bunkers.getPlugin().getWandManager().getWand(player);
Information information = Bunkers.getPlugin().getInformationManager().getInformation();
if (wand == null || wand.getFirstLocation() == null || wand.getSecondLocation() == null) {
player.sendMessage(ChatColor.RED + "You must have wand locations.");
return true;
}
information.setKothFirstLocation(LocationUtils.getString(wand.getFirstLocation()));
information.setKothSecondLocation(LocationUtils.getString(wand.getSecondLocation()));
information.save();
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
profile.getFirstPillar().removePillar();
profile.setFirstPillar(null);
profile.getSecondPillar().removePillar();
profile.setSecondPillar(null);
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have saved the koth coordinates. &7&o(You can check them by /information show)"));
}
return true;
}
}

47
Bunkers/src/main/java/me/redis/bunkers/information/commands/argments/SetMinimumPlayersArgument.java Normal file
View File

@ -0,0 +1,47 @@
package me.redis.bunkers.information.commands.argments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.JavaUtils;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetMinimumPlayersArgument extends CommandArgument {
public SetMinimumPlayersArgument() {
super("setminplayers", null, "minplayers");
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <number>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 2) {
player.sendMessage(getUsage(label));
return true;
}
if (!JavaUtils.isInteger(args[1])) {
player.sendMessage(ChatColor.RED + "You must introduce a number");
return true;
}
Information information = Bunkers.getPlugin().getInformationManager().getInformation();
information.setMinPlayers(Integer.parseInt(args[1]));
information.save();
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have saved the minimum players to start. &7&o(You can check them by /information show)"));
}
return true;
}
}

41
Bunkers/src/main/java/me/redis/bunkers/information/commands/argments/SetServerNameArgument.java Normal file
View File

@ -0,0 +1,41 @@
package me.redis.bunkers.information.commands.argments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetServerNameArgument extends CommandArgument {
public SetServerNameArgument() {
super("setservername", null, "sername");
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <name>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 2) {
player.sendMessage(getUsage(label));
return true;
}
Information information = Bunkers.getPlugin().getInformationManager().getInformation();
information.setServerName(args[1]);
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have saved the server name. &7&o(You can check them by /information show)"));
information.save();
}
return true;
}
}

42
Bunkers/src/main/java/me/redis/bunkers/information/commands/argments/SetSpawnArgument.java Normal file
View File

@ -0,0 +1,42 @@
package me.redis.bunkers.information.commands.argments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetSpawnArgument extends CommandArgument {
public SetSpawnArgument() {
super("setspawn", null, "setspawnlocation");
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName();
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 1) {
player.sendMessage(getUsage(label));
return true;
}
Information information = Bunkers.getPlugin().getInformationManager().getInformation();
information.setLobbyLocation(LocationUtils.getString(player.getLocation().add(0.5, 0.5, 0.5)));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have saved the spawn coordinates. &7&o(You can check them by /information show)"));
information.save();
}
return true;
}
}

58
Bunkers/src/main/java/me/redis/bunkers/information/commands/argments/ShowArgument.java Normal file
View File

@ -0,0 +1,58 @@
package me.redis.bunkers.information.commands.argments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.information.Information;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class ShowArgument extends CommandArgument {
public ShowArgument() {
super("show", null, "who", "i", "info");
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName();
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 1) {
player.sendMessage(getUsage(label));
return true;
}
Information information = Bunkers.getPlugin().getInformationManager().getInformation();
Location lobby = LocationUtils.getLocation(information.getLobbyLocation());
if (lobby == null) {
player.sendMessage(ChatColor.RED + "You must set the spawn location.");
return true;
}
if (information.getKothFirstLocation() == null || information.getKothSecondLocation() == null) {
player.sendMessage(ChatColor.RED + "You must set the koth location.");
return true;
}
Location koth = information.getKothCenter();
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&7&m----------------------"));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&6&nInformation"));
player.sendMessage("");
player.sendMessage(ChatColor.translateAlternateColorCodes('&', " &eSpawn location&7: &f" + lobby.getBlockX() + ", " + lobby.getBlockZ()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', " &eKoth location&7: &f" + koth.getBlockX() + ", " + koth.getBlockZ()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&7&m----------------------"));
}
return true;
}
}

37
Bunkers/src/main/java/me/redis/bunkers/koth/Koth.java Normal file
View File

@ -0,0 +1,37 @@
package me.redis.bunkers.koth;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.tasks.GameTimeTask;
import me.redis.bunkers.utils.BukkitUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import org.bukkit.scheduler.BukkitRunnable;
public class Koth implements Listener {
@Getter @Setter private int seconds = 600;
@Getter @Setter private int capSeconds = 600;
@Getter @Setter Player controller;
public Koth() {
new BukkitRunnable() {
@Override public void run() {
if (GameTimeTask.getNumOfSeconds() == 600) {
setSeconds(300);
if (capSeconds > 300) {
setCapSeconds(300);
}
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&7[&6KingOfTheHill&7] &eThe &9Koth &etime has been decreased. &7(05:00)"));
}
}
}.runTaskTimerAsynchronously(Bunkers.getPlugin(), 0L, 20L);
}
public boolean isInsideArea(Location location) {
return Bunkers.getPlugin().getInformationManager().getInformation().getKothCuboid().contains(location);
}
}

64
Bunkers/src/main/java/me/redis/bunkers/listeners/DeathMessageListener.java Normal file
View File

@ -0,0 +1,64 @@
package me.redis.bunkers.listeners;
import com.google.common.base.Preconditions;
import jdk.jfr.events.ExceptionThrownEvent;
import me.redis.bunkers.Bunkers;
import net.minecraft.server.v1_7_R4.EntityLiving;
import org.apache.commons.lang.WordUtils;
import org.bukkit.ChatColor;
import org.bukkit.craftbukkit.v1_7_R4.entity.CraftEntity;
import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
import org.bukkit.entity.Entity;
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;
public class DeathMessageListener implements Listener {
private final Bunkers plugin = Bunkers.getPlugin();
public static String replaceLast(final String text, final String regex, final String replacement) {
return text.replaceFirst("(?s)" + regex + "(?!.*?" + regex + ')', replacement);
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onPlayerDeath(final PlayerDeathEvent event) {
final String message = event.getDeathMessage();
if(message == null || message.isEmpty()) {
return;
}
event.setDeathMessage(getDeathMessage(message, event.getEntity(), this.getKiller(event)));
}
private CraftEntity getKiller(final PlayerDeathEvent event) {
final EntityLiving lastAttacker = ((CraftPlayer) event.getEntity()).getHandle().lastDamager;
return (lastAttacker == null) ? null : lastAttacker.getBukkitEntity();
}
private String getDeathMessage(String input, final Entity entity, final Entity killer) {
input = input.replaceFirst("\\[", "");
input = replaceLast(input, "]", "");
if(entity != null) {
input = input.replaceFirst("(?i)" + this.getEntityName(entity), ChatColor.RED + this.getDisplayName(entity) + ChatColor.YELLOW);
}
if(killer != null && (entity == null || !killer.equals(entity))) {
input = input.replaceFirst("(?i)" + this.getEntityName(killer), ChatColor.RED + this.getDisplayName(killer) + ChatColor.YELLOW);
}
return input;
}
private String getEntityName(final Entity entity) {
Preconditions.checkNotNull((Object) entity, "Entity cannot be null");
return (entity instanceof Player) ? ((Player) entity).getName() : ((CraftEntity) entity).getHandle().getName();
}
private String getDisplayName(final Entity entity) {
Preconditions.checkNotNull((Object) entity, "Entity cannot be null");
if(entity instanceof Player) {
final Player player = (Player) entity;
return plugin.getTeamManager().getByPlayer(player).getColor() + player.getName() + ChatColor.GRAY + "[" + ChatColor.WHITE + Bunkers.getPlugin().getProfileManager().getProfile(player).getMatchKills() + ChatColor.GRAY + "]";
}
return WordUtils.capitalizeFully(entity.getType().name().replace('_', ' '));
}
}

260
Bunkers/src/main/java/me/redis/bunkers/listeners/PlayerListeners.java Normal file
View File

@ -0,0 +1,260 @@
package me.redis.bunkers.listeners;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.game.status.GameStatus;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.ItemBuilder;
import me.redis.bunkers.utils.LocationUtils;
import net.minecraft.server.v1_7_R4.EnumClickAction;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.entity.TNTPrimed;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntitySpawnEvent;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.*;
import org.bukkit.event.server.ServerListPingEvent;
import org.bukkit.event.weather.WeatherChangeEvent;
import org.bukkit.inventory.ItemStack;
public class PlayerListeners implements Listener {
private Bunkers bunkers = Bunkers.getPlugin();
ItemStack red = new ItemBuilder(Material.STAINED_GLASS_PANE).setDurability(14).setDisplayName("&c&lRed Team").create();
ItemStack blue = new ItemBuilder(Material.STAINED_GLASS_PANE).setDurability(3).setDisplayName("&9&lBlue Team").create();
ItemStack green = new ItemBuilder(Material.STAINED_GLASS_PANE).setDurability(5).setDisplayName("&a&lGreen Team").create();
ItemStack yellow = new ItemBuilder(Material.STAINED_GLASS_PANE).setDurability(4).setDisplayName("&e&lYellow Team").create();
@EventHandler
public void onJoin(PlayerJoinEvent event) {
Player player = event.getPlayer();
event.setJoinMessage(null);
if (bunkers.getInformationManager().getInformation().getLobbyLocation() != null) {
player.teleport(LocationUtils.getLocation(bunkers.getInformationManager().getInformation().getLobbyLocation()));
} else {
player.sendMessage(ChatColor.RED + "You must set the spawn location.");
}
if (bunkers.getGameManager().canBePlayed()) {
if (bunkers.getInformationManager().getInformation().getMinPlayers() <= Bukkit.getOnlinePlayers().size() && bunkers.getGameManager().getStatus() == GameStatus.WAITING) {
bunkers.getGameManager().startCooldown();
}
player.getInventory().clear();
player.getInventory().setArmorContents(null);
player.setHealth(20);
player.setSaturation(20);
player.setGameMode(GameMode.SURVIVAL);
player.setAllowFlight(false);
player.getInventory().setItem(1, red);
player.getInventory().setItem(3, blue);
player.getInventory().setItem(5, green);
player.getInventory().setItem(7, yellow);
} else {
player.sendMessage(ChatColor.RED + "You must set-up the bunkers.");
}
}
@EventHandler
public void onInteract(PlayerInteractEvent event) {
Player player = event.getPlayer();
ItemStack itemStack = event.getItem();
if (itemStack != null && (event.getAction() == Action.RIGHT_CLICK_BLOCK || event.getAction() == Action.RIGHT_CLICK_AIR)) {
if (itemStack.isSimilar(red)) {
Team team = Bunkers.getPlugin().getTeamManager().getByName("Red");
if (team.getMembers().size() >= 5) {
player.sendMessage(ChatColor.RED + "The red team is full.");
return;
}
if (Bunkers.getPlugin().getTeamManager().getByPlayer(player) != null) {
Bunkers.getPlugin().getTeamManager().getByPlayer(player).getMembers().remove(player.getUniqueId());
}
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have joined the &cred &eteam."));
team.getMembers().add(player.getUniqueId());
} else if (itemStack.isSimilar(blue)) {
Team team = Bunkers.getPlugin().getTeamManager().getByName("Blue");
if (team.getMembers().size() >= 5) {
player.sendMessage(ChatColor.RED + "The blue team is full.");
return;
}
if (Bunkers.getPlugin().getTeamManager().getByPlayer(player) != null) {
Bunkers.getPlugin().getTeamManager().getByPlayer(player).getMembers().remove(player.getUniqueId());
}
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have joined the &9blue &eteam."));
team.getMembers().add(player.getUniqueId());
} else if (itemStack.isSimilar(green)) {
Team team = Bunkers.getPlugin().getTeamManager().getByName("Green");
if (team.getMembers().size() >= 5) {
player.sendMessage(ChatColor.RED + "The green team is full.");
return;
}
if (Bunkers.getPlugin().getTeamManager().getByPlayer(player) != null) {
Bunkers.getPlugin().getTeamManager().getByPlayer(player).getMembers().remove(player.getUniqueId());
}
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have joined the &agreen &eteam."));
team.getMembers().add(player.getUniqueId());
} else if (itemStack.isSimilar(yellow)) {
Team team = Bunkers.getPlugin().getTeamManager().getByName("Yellow");
if (team.getMembers().size() >= 5) {
player.sendMessage(ChatColor.RED + "The yellow team is full.");
return;
}
if (Bunkers.getPlugin().getTeamManager().getByPlayer(player) != null) {
Bunkers.getPlugin().getTeamManager().getByPlayer(player).getMembers().remove(player.getUniqueId());
}
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have joined the &6yellow &eteam."));
team.getMembers().add(player.getUniqueId());
}
}
}
@EventHandler
public void onAsyncJoin(AsyncPlayerPreLoginEvent event) {
if (Bukkit.getServer().getOnlinePlayers().size() >= 20) {
event.setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
event.setKickMessage(ChatColor.RED + "The match is full.");
return;
}
if (bunkers.getGameManager().getStatus() != GameStatus.WAITING) {
event.setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
event.setKickMessage(ChatColor.RED + "You can't join a started match.");
}
}
@EventHandler
public void onBreak(BlockBreakEvent event) {
if (bunkers.getGameManager().getStatus() != GameStatus.PLAYING) {
Player player = event.getPlayer();
if (player.isOp() && player.getGameMode() == GameMode.CREATIVE) {
event.setCancelled(false);
} else {
event.setCancelled(true);
}
}
}
@EventHandler
public void onPlace(BlockPlaceEvent event) {
if (bunkers.getGameManager().getStatus() != GameStatus.PLAYING) {
Player player = event.getPlayer();
if (player.isOp() && player.getGameMode() == GameMode.CREATIVE) {
event.setCancelled(false);
} else {
event.setCancelled(true);
}
}
}
@EventHandler
public void onDrop(PlayerDropItemEvent event) {
Player player = event.getPlayer();
if (player.isOp() && player.getGameMode() == GameMode.CREATIVE) return;
if (bunkers.getGameManager().getStatus() != GameStatus.PLAYING) {
event.setCancelled(true);
}
}
@EventHandler
public void onDeath(PlayerDeathEvent event) {
Player player = event.getEntity();
Team team = Bunkers.getPlugin().getTeamManager().getByPlayer(player);
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
team.setDtr(team.getDtr() - 1);
profile.setDeaths(profile.getDeaths() + 1);
if (event.getEntity().getKiller() != null) {
Bunkers.getPlugin().getProfileManager().getProfile(event.getEntity().getKiller()).setKills(Bunkers.getPlugin().getProfileManager().getProfile(event.getEntity().getKiller()).getKills() + 1);
Bunkers.getPlugin().getProfileManager().getProfile(event.getEntity().getKiller()).setMatchKills(Bunkers.getPlugin().getProfileManager().getProfile(event.getEntity().getKiller()).getMatchKills() + 1);
}
if (team.getDtr() <= 0) {
Bunkers.getPlugin().getSpectatorManager().setSpectator(player);
} else {
player.spigot().respawn();
}
}
@EventHandler
public void onQuit(PlayerQuitEvent event) {
Player player = event.getPlayer();
if (Bunkers.getPlugin().getTeamManager().getByPlayer(player) != null) {
Team team = Bunkers.getPlugin().getTeamManager().getByPlayer(player);
if (bunkers.getGameManager().getStatus() == GameStatus.WAITING) {
team.getMembers().remove(player.getUniqueId());
} else if (bunkers.getGameManager().getStatus() == GameStatus.PLAYING) {
team.setDtr(team.getDtr() - 1);
} else if (bunkers.getGameManager().getStatus() == GameStatus.STARTING) {
team.getMembers().remove(player.getUniqueId());
}
}
}
@EventHandler
public void onRespawn(PlayerRespawnEvent event) {
event.setRespawnLocation(LocationUtils.getLocation(Bunkers.getPlugin().getTeamManager().getByPlayer(event.getPlayer()).getSpawnLocation()));
}
@EventHandler
public void onDamage(EntityDamageEvent event) {
if (Bunkers.getPlugin().getGameManager().getStatus() != GameStatus.PLAYING) {
event.setCancelled(true);
} else {
if (event instanceof EntityDamageByEntityEvent) {
if (((EntityDamageByEntityEvent) event).getDamager() instanceof Player && event.getEntity() instanceof Player) {
Player damaged = (Player) event.getEntity();
Player damager = (Player) ((EntityDamageByEntityEvent) event).getDamager();
if (Bunkers.getPlugin().getTeamManager().getByPlayer(damaged) == Bunkers.getPlugin().getTeamManager().getByPlayer(damager)) {
event.setCancelled(true);
}
}
}
}
}
@EventHandler
public void onWeather(WeatherChangeEvent event) {
if (event.toWeatherState()) {
event.setCancelled(true);
}
}
@EventHandler
public void onMotd(ServerListPingEvent event) {
event.setMotd(Bukkit.getServerName() + ";" + Bunkers.getPlugin().getGameManager().getStatus().name() + ";" + Bunkers.getPlugin().getKoth().getCapSeconds() + ";" + Bukkit.getOnlinePlayers().size());
}
}

26
Bunkers/src/main/java/me/redis/bunkers/menu/IMenu.java Normal file
View File

@ -0,0 +1,26 @@
package me.redis.bunkers.menu;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
public interface IMenu extends InventoryHolder {
default String getTitle() { return getInventory().getType().getDefaultTitle(); }
default void open(Player player) { player.openInventory(getInventory()); };
void onInventoryClick(InventoryClickEvent event);
default void onInventoryDrag(InventoryDragEvent event) {
Inventory topInventory = event.getView().getTopInventory();
if (topInventory.equals(getInventory())) {
event.setCancelled(true);
}
}
default void onInventoryClose(InventoryCloseEvent event) {};
}

20
Bunkers/src/main/java/me/redis/bunkers/menu/InventoryUtil.java Normal file
View File

@ -0,0 +1,20 @@
package me.redis.bunkers.menu;
import net.minecraft.server.v1_7_R4.EntityPlayer;
import net.minecraft.server.v1_7_R4.PacketPlayOutOpenWindow;
import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
import org.bukkit.entity.Player;
public class InventoryUtil {
public static void changeTitle(Player player, String title) {
EntityPlayer entityPlayer = ((CraftPlayer) player).getHandle();
int windowId = entityPlayer.activeContainer.windowId;
PacketPlayOutOpenWindow packet = new PacketPlayOutOpenWindow(windowId, 0, title, player.getOpenInventory().getTopInventory().getSize(), true);
entityPlayer.playerConnection.sendPacket(packet);
player.updateInventory();
}
}

32
Bunkers/src/main/java/me/redis/bunkers/menu/MenuListener.java Normal file
View File

@ -0,0 +1,32 @@
package me.redis.bunkers.menu;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
public class MenuListener implements Listener {
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onInventoryClick(InventoryClickEvent event) {
if (event.getInventory().getHolder() instanceof IMenu) {
((IMenu) event.getInventory().getHolder()).onInventoryClick(event);
}
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onInventoryDrag(InventoryDragEvent event) {
if (event.getInventory().getHolder() instanceof IMenu) {
((IMenu) event.getInventory().getHolder()).onInventoryDrag(event);
}
}
@EventHandler
public void onInventoryClose(InventoryCloseEvent event) {
if (event.getInventory().getHolder() instanceof IMenu) {
((IMenu) event.getInventory().getHolder()).onInventoryClose(event);
}
}
}

112
Bunkers/src/main/java/me/redis/bunkers/menu/menu/BuildMenu.java Normal file
View File

@ -0,0 +1,112 @@
package me.redis.bunkers.menu.menu;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.menu.type.ChestMenu;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.utils.ItemBuilder;
import org.apache.commons.lang.WordUtils;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryAction;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.ChatPaginator;
public class BuildMenu extends ChestMenu<Bunkers> {
private Player player;
public BuildMenu(Player player) {
super(6 * 9);
this.player = player;
update();
}
public void update() {
inventory.clear();
inventory.addItem(new ItemBuilder(Material.CHEST).setAmount(16).setDisplayName("&aChest").setLore("&7&m-------------------", "&716 x Chest", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.addItem(new ItemBuilder(Material.STONE).setAmount(16).setDisplayName("&aStone").setLore("&7&m-------------------", "&716 x Stone", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.addItem(new ItemBuilder(Material.COBBLESTONE).setAmount(16).setDisplayName("&aCobblestone").setLore("&7&m-------------------", "&716 x Cobblestone", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.addItem(new ItemBuilder(Material.FENCE_GATE).setAmount(16).setDisplayName("&aFence Gate").setLore("&7&m-------------------", "&716 x Fence Gate", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.addItem(new ItemBuilder(Material.STONE_PLATE).setAmount(16).setDisplayName("&aPressure Plate").setLore("&7&m-------------------", "&716 x Pressure Plate", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.addItem(new ItemBuilder(Material.LADDER).setAmount(16).setDisplayName("&aLadder").setLore("&7&m-------------------", "&716 x Ladder", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.addItem(new ItemBuilder(Material.STONE_BUTTON).setAmount(16).setDisplayName("&aStone Button").setLore("&7&m-------------------", "&716 x Stone Button", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.addItem(new ItemBuilder(Material.TRAPPED_CHEST).setAmount(16).setDisplayName("&aTrapped Chest").setLore("&7&m-------------------", "&716 x Trapped Chest", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.addItem(new ItemBuilder(Material.GLASS).setAmount(16).setDisplayName("&aGlass").setLore("&7&m-------------------", "&716 x Glass", "&7&m-------------------", "&ePrice: &a$50").create());
inventory.setItem(48, new ItemBuilder(Material.DIAMOND_PICKAXE).setDisplayName("&aDiamond Pickaxe").setLore("&7&m-------------------", "&71 x Diamond Pickaxe", "&7&m-------------------", "&ePrice: &a$75").create());
inventory.setItem(49, new ItemBuilder(Material.DIAMOND_AXE).setDisplayName("&aDiamond Axe").setLore("&7&m-------------------", "&71 x Diamond Axe", "&7&m-------------------", "&ePrice: &a$65").create());
inventory.setItem(50, new ItemBuilder(Material.DIAMOND_SPADE).setDisplayName("&aDiamond Shovel").setLore("&7&m-------------------", "&71 x Diamond Shovel", "&7&m-------------------", "&ePrice: &a$55").create());
for (int i = 0; i < 6*9; i++) {
if (inventory.getItem(i) != null) continue;
inventory.setItem(i, new ItemBuilder(Material.STAINED_GLASS_PANE).setDurability(7).setDisplayName(" ").create());
}
}
@Override
public String getTitle() {
return ChatColor.RED + ChatColor.BOLD.toString() + "Block Shop";
}
@Override
public void onInventoryClick(InventoryClickEvent event) {
Inventory clickedInventory = event.getClickedInventory();
Inventory topInventory = event.getView().getTopInventory();
if (clickedInventory == null || topInventory == null || !topInventory.equals(inventory)) {
return;
}
Player player = (Player) event.getWhoClicked();
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
if (topInventory.equals(clickedInventory)) {
event.setCancelled(true);
if (event.getCurrentItem().getType() != Material.AIR) {
if (event.getCurrentItem().getItemMeta() != null && event.getCurrentItem().getType() != Material.STAINED_GLASS_PANE) {
int balance = profile.getBalance();
int cost = Integer.parseInt(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(3).split(" ")[1].replace("$", "")));
int cuantos = Integer.parseInt(stripNonDigits(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(1))));
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
} else {
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType(), cuantos));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
}
}
}
} else if (!topInventory.equals(clickedInventory) && event.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) {
event.setCancelled(true);
}
}
@Override
public void onInventoryDrag(InventoryDragEvent event) {
Inventory topInventory = event.getView().getTopInventory();
if (topInventory.equals(getInventory())) {
event.setCancelled(true);
}
}
public static String stripNonDigits(
final CharSequence input /* inspired by seh's comment */){
final StringBuilder sb = new StringBuilder(
input.length() /* also inspired by seh's comment */);
for(int i = 0; i < input.length(); i++){
final char c = input.charAt(i);
if(c > 47 && c < 58){
sb.append(c);
}
}
return sb.toString();
}
}

253
Bunkers/src/main/java/me/redis/bunkers/menu/menu/CombatMenu.java Normal file
View File

@ -0,0 +1,253 @@
package me.redis.bunkers.menu.menu;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.menu.type.ChestMenu;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.utils.ItemBuilder;
import org.apache.commons.lang.WordUtils;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import org.bukkit.event.inventory.InventoryAction;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.ChatPaginator;
public class CombatMenu extends ChestMenu<Bunkers> {
private Player player;
public CombatMenu(Player player) {
super(6 * 9);
this.player = player;
update();
}
public void update() {
inventory.clear();
inventory.setItem(10, new ItemBuilder(Material.DIAMOND_HELMET).setDisplayName("&aDiamond Helmet").setLore("&7&m-------------------", "&71 x Diamond Helmet", "&7&m-------------------", "&7Price: &a$50").create());
inventory.setItem(11, new ItemBuilder(Material.BOW).setDisplayName("&aBow").setLore("&7&m-------------------", "&71 x Bow", "&7&m-------------------", "&7Price: &a$150").create());
inventory.setItem(12, new ItemBuilder(Material.ARROW).setDisplayName("&aArrows").setLore("&7&m-------------------", "&71 x Arrow", " &e- &aRight click to buy 16", "&7&m-------------------", "&7Price: &a$10").create());
inventory.setItem(14, new ItemBuilder(Material.POTION).setDurability(8226).setDisplayName("&aSpeed II Potion").setLore("&7&m-------------------", "&71 x Speed II Potion", "&7&m-------------------", "&7Price: &a$15").create());
inventory.setItem(15, new ItemBuilder(Material.POTION).setDurability(8227).setDisplayName("&aFire Resistant Potion").setLore("&7&m-------------------", "&71 x Fire Resistance Potion", "&7&m-------------------", "&7Price: &a$25").create());
inventory.setItem(23, new ItemBuilder(Material.POTION).setDurability(16421).setDisplayName("&aInstant Health II Potion").setLore("&7&m-------------------", "&71 x Instant Health II Potion", " &e- &aRight click fill your inventory", "&7&m-------------------", "&7Price: &a$5").create());
inventory.setItem(21, new ItemBuilder(Material.ENDER_PEARL).setDisplayName("&aEnder Pearls").setLore("&7&m-------------------", "&71 x Ender Pearl", " &e- &aRight click to buy 16", "&7&m-------------------", "&7Price: &a$25").create());
inventory.setItem(19, new ItemBuilder(Material.DIAMOND_CHESTPLATE).setDisplayName("&aDiamond Chestplate").setLore("&7&m-------------------", "&71 x Diamond Chestplate", "&7&m-------------------", "&7Price: &a$200").create());
inventory.setItem(20, new ItemBuilder(Material.DIAMOND).setDisplayName("&aFull Diamond Set").setLore("&7&m-------------------", "&71 x Full Diamond Set", "&7&m-------------------", "&7Price: &a$600").create());
inventory.setItem(28, new ItemBuilder(Material.DIAMOND_LEGGINGS).setDisplayName("&aDiamond Leggings").setLore("&7&m-------------------", "&71 x Diamond Leggings", "&7&m-------------------", "&7Price: &a$150").create());
inventory.setItem(37, new ItemBuilder(Material.DIAMOND_BOOTS).setDisplayName("&aDiamond Boots").setLore("&7&m-------------------", "&71 x Diamond Boots", "&7&m-------------------", "&7Price: &a$65").create());
inventory.setItem(39, new ItemBuilder(Material.POTION).setDisplayName("&aAntidote").setLore("&7&m-------------------", "&71 x Antidote", "&7&m-------------------", "&7Price: &a$150").create());
inventory.setItem(41, new ItemBuilder(Material.COOKED_BEEF).setDisplayName("&aCooked Beef").setLore("&7&m-------------------", "&71 x Beef", " &e- &aRight click to buy 16", "&7&m-------------------", "&7Price: &a$5").create());
inventory.setItem(18, new ItemBuilder(Material.DIAMOND_SWORD).setDisplayName("&aDiamond Sword").setLore("&7&m-------------------", "&71 x Diamond Sword", "&7&m-------------------", "&7Price: &a$150").create());
for (int i = 0; i < 6 * 9; i++) {
if (inventory.getItem(i) != null) continue;
inventory.setItem(i, new ItemBuilder(Material.STAINED_GLASS_PANE).setDurability(7).setDisplayName(" ").create());
}
}
@Override
public String getTitle() {
return ChatColor.RED + ChatColor.BOLD.toString() + "Combat Shop";
}
@Override
public void onInventoryClick(InventoryClickEvent event) {
Inventory clickedInventory = event.getClickedInventory();
Inventory topInventory = event.getView().getTopInventory();
if (clickedInventory == null || topInventory == null || !topInventory.equals(inventory)) {
return;
}
Player player = (Player) event.getWhoClicked();
if (topInventory.equals(clickedInventory)) {
event.setCancelled(true);
if (event.getCurrentItem().getType() != Material.AIR) {
if (event.getCurrentItem().getItemMeta() != null && event.getCurrentItem().getItemMeta().getDisplayName() != null && event.getCurrentItem().getType() != Material.STAINED_GLASS_PANE) {
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
int balance = Bunkers.getPlugin().getProfileManager().getProfile(player).getBalance();
if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Instant")) {
int cost = Integer.parseInt(stripNonDigits(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(4))));
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
if (event.getClick() == ClickType.RIGHT) {
for (ItemStack itemStack : player.getInventory().getContents()) {
if (itemStack == null) {
cost += 5;
}
}
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
for (int i = 0; i < 36; i++) {
if (player.getInventory().getItem(i) == null) {
player.getInventory().setItem(i, new ItemStack(Material.POTION, 1, (short) 16421));
}
}
Bunkers.getPlugin().getProfileManager().getProfile(player).setBalance(Bunkers.getPlugin().getProfileManager().getProfile(player).getBalance() - cost);
} else if (event.getClick() == ClickType.LEFT) {
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
}
return;
}
if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Ender")) {
int cost = Integer.parseInt(stripNonDigits(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(4))));
if (event.getClick() == ClickType.RIGHT) {
cost = cost * 16;
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType(), 16));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
} else if (event.getClick() == ClickType.LEFT) {
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
}
return;
}
if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Beef")) {
int cost = Integer.parseInt(stripNonDigits(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(4))));
if (event.getClick() == ClickType.RIGHT) {
cost = cost * 16;
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType(), 16));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
} else if (event.getClick() == ClickType.LEFT) {
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
}
return;
}
if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Arrow")) {
int cost = Integer.parseInt(stripNonDigits(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(4))));
if (event.getClick() == ClickType.RIGHT) {
cost = cost * 16;
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType(), 16));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
} else if (event.getClick() == ClickType.LEFT) {
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
}
return;
}
int cost = Integer.parseInt(stripNonDigits(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(3))));
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
return;
}
if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Full")) {
player.getInventory().setHelmet(new ItemStack(Material.DIAMOND_HELMET));
player.getInventory().setChestplate(new ItemStack(Material.DIAMOND_CHESTPLATE));
player.getInventory().setLeggings(new ItemStack(Material.DIAMOND_LEGGINGS));
player.getInventory().setBoots(new ItemStack(Material.DIAMOND_BOOTS));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + "full diamond set" + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
return;
}
if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Antidote")) {
player.getInventory().addItem(new ItemBuilder(Material.POTION).setDisplayName("&aAntidote").create());
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ean " + "antidote" + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
return;
}
player.getInventory().addItem(new ItemStack(event.getCurrentItem().getType(), 1, event.getCurrentItem().getDurability()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have bought &ea " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + " &afor &e$" + cost + "&a."));
profile.setBalance(profile.getBalance() - cost);
}
}
} else if (!topInventory.equals(clickedInventory) && event.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) {
event.setCancelled(true);
}
}
@Override
public void onInventoryDrag(InventoryDragEvent event) {
Inventory topInventory = event.getView().getTopInventory();
if (topInventory.equals(getInventory())) {
event.setCancelled(true);
}
}
public static String stripNonDigits(
final CharSequence input /* inspired by seh's comment */) {
final StringBuilder sb = new StringBuilder(
input.length() /* also inspired by seh's comment */);
for (int i = 0; i < input.length(); i++) {
final char c = input.charAt(i);
if (c > 47 && c < 58) {
sb.append(c);
}
}
return sb.toString();
}
}

127
Bunkers/src/main/java/me/redis/bunkers/menu/menu/EnchanterMenu.java Normal file
View File

@ -0,0 +1,127 @@
package me.redis.bunkers.menu.menu;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.menu.type.ChestMenu;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.utils.ItemBuilder;
import org.apache.commons.lang.WordUtils;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryAction;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.ChatPaginator;
public class EnchanterMenu extends ChestMenu<Bunkers> {
private Player player;
public EnchanterMenu(Player player) {
super(9);
this.player = player;
update();
}
public void update() {
inventory.clear();
inventory.addItem(new ItemBuilder(Material.ENCHANTED_BOOK).setDisplayName("&3Sharpness I").setLore("&7&m-------------------", "&7Sharpness I for your sword", "&7&m-------------------", "&ePrice: &a$300").create());
inventory.addItem(new ItemBuilder(Material.ENCHANTED_BOOK).setDisplayName("&3Protection I").setLore("&7&m-------------------", "&7Protection I for your armor", "&7&m-------------------", "&ePrice: &a$1200").create());
inventory.addItem(new ItemBuilder(Material.ENCHANTED_BOOK).setDisplayName("&3Feather Falling IV").setLore("&7&m-------------------", "&7Feather Falling IV for your boots", "&7&m-------------------", "&ePrice: &a$200").create());
for (int i = 0; i < 9; i++) {
if (inventory.getItem(i) != null) continue;
inventory.setItem(i, new ItemBuilder(Material.STAINED_GLASS_PANE).setDurability(7).setDisplayName(" ").create());
}
}
@Override
public String getTitle() {
return ChatColor.RED + ChatColor.BOLD.toString() + "Block Shop";
}
@Override
public void onInventoryClick(InventoryClickEvent event) {
Inventory clickedInventory = event.getClickedInventory();
Inventory topInventory = event.getView().getTopInventory();
if (clickedInventory == null || topInventory == null || !topInventory.equals(inventory)) {
return;
}
Player player = (Player) event.getWhoClicked();
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
if (topInventory.equals(clickedInventory)) {
event.setCancelled(true);
if (event.getCurrentItem().getType() != Material.AIR) {
if (event.getCurrentItem().getItemMeta() != null && event.getCurrentItem().getType() != Material.STAINED_GLASS_PANE) {
int balance = profile.getBalance();
int cost = Integer.parseInt(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(3).split(" ")[1].replace("$", "")));
if (cost > balance) {
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&cThis costs &e$" + cost + "&c, you only have &e$" + balance + "&c."));
} else {
if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Sharpness")) {
int counter = 0;
for (ItemStack itemStack : player.getInventory().getContents()) {
if (itemStack != null && itemStack.getType() == Material.DIAMOND_SWORD && counter == 0) {
itemStack.addEnchantment(Enchantment.DAMAGE_ALL, 1);
counter++;
}
}
} else if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Feather")) {
int counter = 0;
for (ItemStack itemStack : player.getInventory().getContents()) {
if (itemStack != null && itemStack.getType() == Material.DIAMOND_BOOTS && counter == 0) {
itemStack.addEnchantment(Enchantment.PROTECTION_FALL, 1);
counter++;
}
}
} else if (event.getCurrentItem().getItemMeta().getDisplayName().contains("Protection")) {
for (ItemStack itemStack : player.getInventory().getContents()) {
if (itemStack != null && (itemStack.getType() == Material.DIAMOND_HELMET || itemStack.getType() == Material.DIAMOND_CHESTPLATE || itemStack.getType() == Material.DIAMOND_LEGGINGS || itemStack.getType() == Material.DIAMOND_BOOTS)) {
itemStack.addEnchantment(Enchantment.PROTECTION_ENVIRONMENTAL, 1);
}
}
}
}
}
}
} else if (!topInventory.equals(clickedInventory) && event.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) {
event.setCancelled(true);
}
}
@Override
public void onInventoryDrag(InventoryDragEvent event) {
Inventory topInventory = event.getView().getTopInventory();
if (topInventory.equals(getInventory())) {
event.setCancelled(true);
}
}
public static String stripNonDigits(
final CharSequence input /* inspired by seh's comment */){
final StringBuilder sb = new StringBuilder(
input.length() /* also inspired by seh's comment */);
for(int i = 0; i < input.length(); i++){
final char c = input.charAt(i);
if(c > 47 && c < 58){
sb.append(c);
}
}
return sb.toString();
}
}

143
Bunkers/src/main/java/me/redis/bunkers/menu/menu/SellMenu.java Normal file
View File

@ -0,0 +1,143 @@
package me.redis.bunkers.menu.menu;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.menu.type.ChestMenu;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.utils.ItemBuilder;
import org.apache.commons.lang.WordUtils;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import org.bukkit.event.inventory.InventoryAction;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.ChatPaginator;
public class SellMenu extends ChestMenu<Bunkers> {
private Player player;
public SellMenu(Player player) {
super(9);
this.player = player;
update();
}
public void update() {
inventory.clear();
int diamond = 0;
int gold = 0;
int iron = 0;
int coal = 0;
for (ItemStack itemStack : player.getInventory().getContents()) {
if (itemStack != null) {
if (itemStack.getType() == Material.DIAMOND) {
diamond += itemStack.getAmount();
}
if (itemStack.getType() == Material.GOLD_INGOT) {
gold += itemStack.getAmount();
}
if (itemStack.getType() == Material.IRON_ORE) {
iron += itemStack.getAmount();
}
if (itemStack.getType() == Material.COAL) {
coal += itemStack.getAmount();
}
}
}
inventory.setItem(1, new ItemBuilder(Material.DIAMOND).setDisplayName("&bSell Diamond").setLore("&7&m-------------------", "&7Left click to sell 1 x Diamond for &a$50", "&7Right click to sell all your diamonds for &a$" + diamond * 50, "&7&m-------------------").create());
inventory.setItem(3, new ItemBuilder(Material.GOLD_INGOT).setDisplayName("&bSell Gold").setLore("&7&m-------------------", "&7Left click to sell 1 x Gold Ingot for &a$35", "&7Right click to sell all your gold for &a$" + gold * 35, "&7&m-------------------").create());
inventory.setItem(5, new ItemBuilder(Material.IRON_INGOT).setDisplayName("&bSell Iron").setLore("&7&m-------------------", "&7Left click to sell 1 x Iron Ingot for &a$25", "&7Right click to sell all your iron for &a$" + iron * 25, "&7&m-------------------").create());
inventory.setItem(7, new ItemBuilder(Material.COAL).setDisplayName("&bSell Coal").setLore("&7&m-------------------", "&7Left click to sell 1 x Coal for &a$15", "&7Right click to sell all your coal for &a$" + coal * 15, "&7&m-------------------").create());
for (int i = 0; i < 9; i++) {
if (inventory.getItem(i) != null) continue;
inventory.setItem(i, new ItemBuilder(Material.STAINED_GLASS_PANE).setDurability(7).setDisplayName(" ").create());
}
}
@Override
public String getTitle() {
return ChatColor.RED + ChatColor.BOLD.toString() + "Sell Items";
}
@Override
public void onInventoryClick(InventoryClickEvent event) {
Inventory clickedInventory = event.getClickedInventory();
Inventory topInventory = event.getView().getTopInventory();
if (clickedInventory == null || topInventory == null || !topInventory.equals(inventory)) {
return;
}
Player player = (Player) event.getWhoClicked();
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
if (topInventory.equals(clickedInventory)) {
event.setCancelled(true);
if (event.getCurrentItem().getType() != Material.AIR) {
if (event.getCurrentItem().getItemMeta() != null && event.getCurrentItem().getType() != Material.STAINED_GLASS_PANE) {
if (event.getClick() == ClickType.LEFT) {
int cost = Integer.parseInt(stripNonDigits(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(1).replace("1", ""))));
if (player.getInventory().contains(event.getCurrentItem().getType())) {
profile.setBalance(profile.getBalance() + cost);
player.getInventory().removeItem(new ItemStack(event.getCurrentItem().getType(), 1));
player.updateInventory();
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have sold &ex1 " + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + "&a for &e$" + cost + "&a."));
update();
} else {
player.sendMessage(ChatColor.RED + "You don't have enough to sell.");
}
} else if (event.getClick() == ClickType.RIGHT) {
int cost = Integer.parseInt(stripNonDigits(ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(2))));
if (player.getInventory().contains(event.getCurrentItem().getType())) {
profile.setBalance(profile.getBalance() + cost);
player.getInventory().remove(event.getCurrentItem().getType());
player.updateInventory();
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aYou have sold all your &e" + WordUtils.capitalizeFully(event.getCurrentItem().getType().name().replace("_", " ")) + "&a for &e$" + cost + "&a."));
update();
} else {
player.sendMessage(ChatColor.RED + "You don't have enough to sell.");
}
}
}
}
} else if (!topInventory.equals(clickedInventory) && event.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) {
event.setCancelled(true);
}
}
@Override
public void onInventoryDrag(InventoryDragEvent event) {
Inventory topInventory = event.getView().getTopInventory();
if (topInventory.equals(getInventory())) {
event.setCancelled(true);
}
}
public static String stripNonDigits(
final CharSequence input /* inspired by seh's comment */) {
final StringBuilder sb = new StringBuilder(
input.length() /* also inspired by seh's comment */);
for (int i = 0; i < input.length(); i++) {
final char c = input.charAt(i);
if (c > 47 && c < 58) {
sb.append(c);
}
}
return sb.toString();
}
}

40
Bunkers/src/main/java/me/redis/bunkers/menu/type/ChestMenu.java Normal file
View File

@ -0,0 +1,40 @@
package me.redis.bunkers.menu.type;
import lombok.Getter;
import me.redis.bunkers.menu.IMenu;
import org.bukkit.inventory.Inventory;
import org.bukkit.plugin.java.JavaPlugin;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
@Getter
public abstract class ChestMenu<E extends JavaPlugin> implements IMenu {
protected E plugin;
public final Inventory inventory;
public ChestMenu(int size) {
loadPlugin();
inventory = plugin.getServer().createInventory(this, size, getTitle().length() > 32 ? getTitle().substring(0, 32) : getTitle());
}
private void loadPlugin() {
Class<E> clazz = ((Class<E>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
Method method = null;
try {
method = clazz.getDeclaredMethod("getPlugin", null);
} catch (Exception exception) {
exception.printStackTrace();
}
try {
plugin = (E) method.invoke(null, method.getParameterTypes());
} catch (Exception exception) {
exception.printStackTrace();
}
}
}

79
Bunkers/src/main/java/me/redis/bunkers/menu/type/PaginatedMenu.java Normal file
View File

@ -0,0 +1,79 @@
package me.redis.bunkers.menu.type;
import lombok.Getter;
import me.redis.bunkers.menu.IMenu;
import me.redis.bunkers.menu.InventoryUtil;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.plugin.java.JavaPlugin;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
@Getter
public abstract class PaginatedMenu<E extends JavaPlugin> implements IMenu {
protected E plugin;
private int page;
public final Inventory inventory;
public PaginatedMenu(int size, int page) {
loadPlugin();
this.page = page;
inventory = plugin.getServer().createInventory(this, size, getTitle().length() > 32 ? getTitle().substring(0, 32) : getTitle());
updateContents();
}
public abstract int getTotalPages();
public abstract void updateContents();
private void loadPlugin() {
Class<E> clazz = ((Class<E>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
Method method = null;
try {
method = clazz.getDeclaredMethod("getPlugin", null);
} catch (Exception exception) {
exception.printStackTrace();
}
try {
plugin = (E) method.invoke(null, method.getParameterTypes());
} catch (Exception exception) {
exception.printStackTrace();
}
}
public void setPage(int page) {
this.page = page;
for (HumanEntity viewer : getInventory().getViewers()) {
InventoryUtil.changeTitle((Player) viewer, getTitle());
}
updateContents();
}
@Override
public void open(Player player) {
player.openInventory(getInventory());
setPage(getPage());
}
@Override
public void onInventoryDrag(InventoryDragEvent event) {
Inventory topInventory = event.getView().getTopInventory();
if (topInventory.equals(inventory)) {
event.setCancelled(true);
}
}
}

61
Bunkers/src/main/java/me/redis/bunkers/profiles/Profile.java Normal file
View File

@ -0,0 +1,61 @@
package me.redis.bunkers.profiles;
import com.mongodb.client.FindIterable;
import com.mongodb.client.model.Filters;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.profiles.status.PlayerStatus;
import me.redis.bunkers.protocol.ClaimPillar;
import org.bson.Document;
import org.bson.conversions.Bson;
import java.util.*;
@Getter
public class Profile {
private UUID uniqueId;
@Setter private String name;
@Setter private int gamesPlayed, gamesWon, kills, deaths, matchKills, balance;
@Setter private PlayerStatus status = PlayerStatus.LOBBY;
@Setter private ClaimPillar firstPillar;
@Setter private ClaimPillar secondPillar;
public Profile(UUID uniqueId) {
this.uniqueId = uniqueId;
load();
}
public void load() {
Document document = (Document) Bunkers.getPlugin().getProfilesCollection().find(Filters.eq("_id", uniqueId)).first();
if (document == null) return;
name = document.getString("name");
gamesPlayed = document.getInteger("gamesPlayed");
gamesWon = document.getInteger("gamesWon");
kills = document.getInteger("kills");
deaths = document.getInteger("deaths");
}
public void save() {
Document document = new Document("_id", uniqueId);
document.put("name", name);
document.put("gamesPlayed", gamesPlayed);
document.put("gamesWon", gamesWon);
document.put("kills", kills);
document.put("deaths", deaths);
Bson filter = Filters.eq("_id", uniqueId);
FindIterable iterable = Bunkers.getPlugin().getProfilesCollection().find(filter);
if (iterable.first() == null) {
Bunkers.getPlugin().getProfilesCollection().insertOne(document);
} else {
Bunkers.getPlugin().getProfilesCollection().replaceOne(filter, document);
}
}
}

67
Bunkers/src/main/java/me/redis/bunkers/profiles/ProfileManager.java Normal file
View File

@ -0,0 +1,67 @@
package me.redis.bunkers.profiles;
import lombok.Getter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.profiles.status.PlayerStatus;
import org.bson.Document;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import javax.print.Doc;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class ProfileManager implements Listener {
public ProfileManager() {
Bukkit.getPluginManager().registerEvents(this, Bunkers.getPlugin());
}
@Getter
private Map<UUID, Profile> profiles = new HashMap<>();
public Profile getProfile(UUID uniqueId) {
return profiles.get(uniqueId);
}
public Profile getNotCachedProfile(UUID uniqueId) {
for (Object object : Bunkers.getPlugin().getProfilesCollection().find()) {
Document document = (Document) object;
if (document.get("_id").equals(uniqueId)) {
return new Profile(uniqueId);
}
}
return null;
}
public Profile getProfile(Player player) {
return getProfile(player.getUniqueId());
}
@EventHandler
public void onJoin(AsyncPlayerPreLoginEvent event) {
Profile profile = new Profile(event.getUniqueId());
if (profile.getName() == null) {
profile.setName(event.getName());
}
profile.save();
profile.setStatus(PlayerStatus.LOBBY);
Bunkers.getPlugin().getProfileManager().getProfiles().put(event.getUniqueId(), profile);
}
@EventHandler
public void onQuit(PlayerQuitEvent event) {
Bukkit.getScheduler().runTaskAsynchronously(Bunkers.getPlugin(), () -> getProfile(event.getPlayer().getUniqueId()).save());
}
}

5
Bunkers/src/main/java/me/redis/bunkers/profiles/status/PlayerStatus.java Normal file
View File

@ -0,0 +1,5 @@
package me.redis.bunkers.profiles.status;
public enum PlayerStatus {
LOBBY, PLAYING, RESPAWNING, SPECTATOR
}

57
Bunkers/src/main/java/me/redis/bunkers/protocol/ClaimPillar.java Normal file
View File

@ -0,0 +1,57 @@
package me.redis.bunkers.protocol;
import lombok.Getter;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import java.util.ArrayList;
@Getter
public class ClaimPillar {
private Player player;
private Material blockType;
private byte data;
private ArrayList<Integer> blocks;
private Location location;
public ClaimPillar(Player player, Material blockType, byte data, Location location) {
this.player = player;
this.location = location;
this.blockType = blockType;
this.data = data;
blocks = new ArrayList<>();
}
public void sendPillar() {
int x = location.getBlockX();
int z = location.getBlockZ();
for (int i = 0; i <= 256; i++) {
Location location = new Location(this.location.getWorld(), x, i, z);
if (location.getBlock().getType() == Material.AIR) {
if (blocks.contains(location.getBlockY())) {
player.getPlayer().sendBlockChange(location, blockType, data);
player.getPlayer().sendBlockChange(location.add(0, 2, 0), Material.GLASS, (byte) 0);
} else {
player.getPlayer().sendBlockChange(location, Material.GLASS, (byte) 0);
blocks.add(location.getBlockY() + 1);
}
}
}
}
public void removePillar() {
int x = location.getBlockX();
int z = location.getBlockZ();
for (int i = 0; i <= 256; i++) {
Location location = new Location(this.location.getWorld(), x, i, z);
if (location.getBlock().getType() == Material.AIR) {
player.getPlayer().sendBlockChange(location, Material.AIR, (byte) 0);
}
}
}
}

45
Bunkers/src/main/java/me/redis/bunkers/protocol/ProtocolListener.java Normal file
View File

@ -0,0 +1,45 @@
package me.redis.bunkers.protocol;
import com.comphenix.protocol.PacketType;
import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.ProtocolManager;
import com.comphenix.protocol.events.PacketAdapter;
import com.comphenix.protocol.events.PacketEvent;
import me.redis.bunkers.Bunkers;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
public class ProtocolListener {
public ProtocolListener() {
ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();
protocolManager.addPacketListener(new PacketAdapter(Bunkers.getPlugin(), PacketType.Play.Server.CUSTOM_PAYLOAD, PacketType.Play.Client.CUSTOM_PAYLOAD) {
@Override public void onPacketReceiving(PacketEvent event) {
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&a" + event.getPacketType().name() + "&7(Receive):"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', " &7- &e" + event.getPacket().getStrings().readSafely(0)));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', " &7- &e" + event.getPacket().getIntegers().readSafely(0)));
Bukkit.broadcastMessage("");
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&dByte Arrays:"));
int counter = 0;
for (byte[] byt : event.getPacket().getByteArrays().getValues()) {
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', " &7- &e" + byt[counter]));
counter++;
}
}
@Override public void onPacketSending(PacketEvent event) {
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&a" + event.getPacketType().name() + "&7(Send):"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', " &7- &e" + event.getPacket().getStrings().readSafely(0)));
Bukkit.broadcastMessage("");
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&dByte Arrays:"));
int counter = 0;
for (byte[] byt : event.getPacket().getByteArrays().getValues()) {
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', " &7- &e" + byt[counter]));
counter++;
}
}
});
}
}

250
Bunkers/src/main/java/me/redis/bunkers/scoreboard/Aether.java Normal file
View File

@ -0,0 +1,250 @@
package me.redis.bunkers.scoreboard;
import lombok.Getter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.events.BoardCreateEvent;
import me.redis.bunkers.scoreboard.scoreboard.Board;
import me.redis.bunkers.scoreboard.scoreboard.BoardAdapter;
import me.redis.bunkers.scoreboard.scoreboard.BoardEntry;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scoreboard.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;
import static me.redis.bunkers.scoreboard.AetherOptions.defaultOptions;
/**
* TODO: Add documentation to methods, etc
* TODO: Fix inconsistent cooldown scores
* TODO: Finish other board formats
*/
public class Aether implements Listener {
@Getter
private JavaPlugin plugin;
@Getter
private AetherOptions options;
@Getter
BoardAdapter adapter;
public Aether(JavaPlugin plugin, BoardAdapter adapter, AetherOptions options) {
this.options = options;
this.plugin = plugin;
Bukkit.getPluginManager().registerEvents(this, plugin);
setAdapter(adapter);
run();
}
public Aether(JavaPlugin plugin, BoardAdapter adapter) {
this(plugin, adapter, defaultOptions());
}
public Aether(JavaPlugin plugin) {
this(plugin, null, defaultOptions());
}
private void run() {
new BukkitRunnable() {
public void run() {
if (adapter == null) return;
for (Player player : Bukkit.getOnlinePlayers()) {
Board board = Board.getByPlayer(player);
if (board != null) {
List<String> scores = adapter.getScoreboard(player, board, board.getCooldowns());
List<String> translatedScores = new ArrayList<>();
if (scores == null) {
if (!board.getEntries().isEmpty()) {
for (BoardEntry boardEntry : board.getEntries()) {
boardEntry.remove();
}
board.getEntries().clear();
}
continue;
}
for (String line : scores) {
translatedScores.add(ChatColor.translateAlternateColorCodes('&', line));
}
if (!options.scoreDirectionDown()) {
Collections.reverse(scores);
}
Scoreboard scoreboard = board.getScoreboard();
Objective objective = board.getObjective();
if (!(objective.getDisplayName().equals(adapter.getTitle(player)))) {
objective.setDisplayName(ChatColor.translateAlternateColorCodes('&', adapter.getTitle(player)));
}
outer:
for (int i = 0; i < scores.size(); i++) {
String text = scores.get(i);
int position;
if (options.scoreDirectionDown()) {
position = 15 - i;
} else {
position = i + 1;
}
Iterator<BoardEntry> iterator = new ArrayList<>(board.getEntries()).iterator();
while (iterator.hasNext()) {
BoardEntry boardEntry = iterator.next();
Score score = objective.getScore(boardEntry.getKey());
if (score != null && boardEntry.getText().equals(ChatColor.translateAlternateColorCodes('&', text))) {
if (score.getScore() == position) {
continue outer;
}
}
}
int positionToSearch = options.scoreDirectionDown() ? 15 - position : position - 1;
iterator = board.getEntries().iterator();
while (iterator.hasNext()) {
BoardEntry boardEntry = iterator.next();
int entryPosition = scoreboard.getObjective(DisplaySlot.SIDEBAR).getScore(boardEntry.getKey()).getScore();
if (!options.scoreDirectionDown()) {
if (entryPosition > scores.size()) {
iterator.remove();
boardEntry.remove();
}
}
}
BoardEntry entry = board.getByPosition(positionToSearch);
if (entry == null) {
new BoardEntry(board, text).send(position);
} else {
entry.setText(text).setup().send(position);
}
if (board.getEntries().size() > scores.size()) {
iterator = board.getEntries().iterator();
while (iterator.hasNext()) {
BoardEntry boardEntry = iterator.next();
if ((!translatedScores.contains(boardEntry.getText())) || Collections.frequency(board.getBoardEntriesFormatted(), boardEntry.getText()) > 1) {
iterator.remove();
boardEntry.remove();
}
}
}
}
player.setScoreboard(scoreboard);
updateTablist(player);
}
}
}
}.runTaskTimerAsynchronously(plugin, 20L, 1L);
}
public void setAdapter(BoardAdapter adapter) {
this.adapter = adapter;
for (Player player : Bukkit.getOnlinePlayers()) {
Board board = Board.getByPlayer(player);
if (board != null) {
Board.getBoards().remove(board);
}
Bukkit.getPluginManager().callEvent(new BoardCreateEvent(new Board(player, this, options), player));
}
}
@EventHandler
public void onPlayerJoinEvent(PlayerJoinEvent event) {
if (Board.getByPlayer(event.getPlayer()) == null) {
Bukkit.getPluginManager().callEvent(new BoardCreateEvent(new Board(event.getPlayer(), this, options), event.getPlayer()));
}
}
private static Team getExistingOrCreateNewTeam(String string, Scoreboard scoreboard, ChatColor prefix) {
Team toReturn = scoreboard.getTeam(string);
if (toReturn == null) {
toReturn = scoreboard.registerNewTeam(string);
toReturn.setPrefix(prefix + "");
}
return toReturn;
}
private static void updateTablist(Player target) {
Team spectator = getExistingOrCreateNewTeam("spectator", Board.getByPlayer(target).getScoreboard(), ChatColor.GRAY);
Team red = getExistingOrCreateNewTeam("red", Board.getByPlayer(target).getScoreboard(), ChatColor.RED);
Team blue = getExistingOrCreateNewTeam("blue", Board.getByPlayer(target).getScoreboard(), ChatColor.BLUE);
Team green = getExistingOrCreateNewTeam("green", Board.getByPlayer(target).getScoreboard(), ChatColor.DARK_GREEN);
Team yellow = getExistingOrCreateNewTeam("yellow", Board.getByPlayer(target).getScoreboard(), ChatColor.YELLOW);
for (Player online : Bukkit.getOnlinePlayers()) {
me.redis.bunkers.team.Team team = Bunkers.getPlugin().getTeamManager().getByPlayer(online);
if (team != null) {
if (team.getName().equalsIgnoreCase("red")) {
if (!red.hasEntry(online.getName())) {
red.addEntry(online.getName());
}
} else if (team.getName().equalsIgnoreCase("blue")) {
if (!blue.hasEntry(online.getName())) {
blue.addEntry(online.getName());
}
} else if (team.getName().equalsIgnoreCase("green")) {
if (!green.hasEntry(online.getName())) {
green.addEntry(online.getName());
}
} else if (team.getName().equalsIgnoreCase("yellow")) {
if (!yellow.hasEntry(online.getName())) {
yellow.addEntry(online.getName());
}
}
} else {
if (!spectator.hasEntry(online.getName())) {
spectator.addEntry(online.getName());
}
}
}
}
@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerQuitEvent(PlayerQuitEvent event) {
Board board = Board.getByPlayer(event.getPlayer());
if (board != null) {
Board.getBoards().remove(board);
}
}
}

21
Bunkers/src/main/java/me/redis/bunkers/scoreboard/AetherOptions.java Normal file
View File

@ -0,0 +1,21 @@
package me.redis.bunkers.scoreboard;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;
@Getter
@Setter
@Accessors(chain = true, fluent = true)
public class AetherOptions {
static AetherOptions defaultOptions() {
return new AetherOptions()
.hook(false)
.scoreDirectionDown(false);
}
private boolean hook;
private boolean scoreDirectionDown;
}

136
Bunkers/src/main/java/me/redis/bunkers/scoreboard/scoreboard/Board.java Normal file
View File

@ -0,0 +1,136 @@
package me.redis.bunkers.scoreboard.scoreboard;
import lombok.Getter;
import me.redis.bunkers.scoreboard.Aether;
import me.redis.bunkers.scoreboard.AetherOptions;
import me.redis.bunkers.scoreboard.scoreboard.cooldown.BoardCooldown;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.scoreboard.DisplaySlot;
import org.bukkit.scoreboard.Objective;
import org.bukkit.scoreboard.Scoreboard;
import java.util.*;
public class Board {
private static Set<Board> boards = new HashSet<>();
@Getter private Scoreboard scoreboard;
@Getter private Player player;
@Getter private Objective objective;
@Getter private Set<String> keys;
@Getter private List<BoardEntry> entries;
private Set<BoardCooldown> cooldowns;
private final Aether aether;
private final AetherOptions options;
public Board(Player player, Aether aether, AetherOptions options) {
this.player = player;
this.aether = aether;
this.options = options;
this.keys = new HashSet<>();
this.cooldowns = new HashSet<>();
this.entries = new ArrayList<>();
setup();
}
private void setup() {
if (options.hook() && !player.getScoreboard().equals(Bukkit.getScoreboardManager().getMainScoreboard())) {
scoreboard = player.getScoreboard();
} else {
scoreboard = Bukkit.getScoreboardManager().getNewScoreboard();
}
objective = scoreboard.registerNewObjective("glaedr_is_shit", "dummy");
objective.setDisplaySlot(DisplaySlot.SIDEBAR);
if (aether.getAdapter() != null) {
objective.setDisplayName(ChatColor.translateAlternateColorCodes('&', aether.getAdapter().getTitle(player)));
} else {
objective.setDisplayName("Default Title");
}
boards.add(this);
}
public String getNewKey(BoardEntry entry) {
for (ChatColor color : ChatColor.values()) {
String colorText = color + "" + ChatColor.WHITE;
if (entry.getText().length() > 16) {
String sub = entry.getText().substring(0, 16);
colorText = colorText + ChatColor.getLastColors(sub);
}
if (!keys.contains(colorText)) {
keys.add(colorText);
return colorText;
}
}
throw new IndexOutOfBoundsException("No more keys available!");
}
public List<String> getBoardEntriesFormatted() {
List<String> toReturn = new ArrayList<>();
for (BoardEntry entry : new ArrayList<>(entries)) {
toReturn.add(entry.getText());
}
return toReturn;
}
public BoardEntry getByPosition(int position) {
int i = 0;
for (BoardEntry board : entries) {
if (i == position) {
return board;
}
i++;
}
return null;
}
public BoardCooldown getCooldown(String id) {
for (BoardCooldown cooldown : getCooldowns()) {
if (cooldown.getId().equals(id)) {
return cooldown;
}
}
return null;
}
public Set<BoardCooldown> getCooldowns() {
Iterator<BoardCooldown> iterator = cooldowns.iterator();
while (iterator.hasNext()) {
BoardCooldown cooldown = iterator.next();
if (System.currentTimeMillis() >= cooldown.getEnd()) {
iterator.remove();
}
}
return cooldowns;
}
public static Board getByPlayer(Player player) {
for (Board board : boards) {
if (board.getPlayer().getName().equals(player.getName())) {
return board;
}
}
return null;
}
public static Set<Board> getBoards() {
return boards;
}
}

14
Bunkers/src/main/java/me/redis/bunkers/scoreboard/scoreboard/BoardAdapter.java Normal file
View File

@ -0,0 +1,14 @@
package me.redis.bunkers.scoreboard.scoreboard;
import me.redis.bunkers.scoreboard.scoreboard.cooldown.BoardCooldown;
import org.bukkit.entity.Player;
import java.util.List;
import java.util.Set;
public interface BoardAdapter {
String getTitle(Player player);
List<String> getScoreboard(Player player, Board board, Set<BoardCooldown> cooldowns);
}

85
Bunkers/src/main/java/me/redis/bunkers/scoreboard/scoreboard/BoardEntry.java Normal file
View File

@ -0,0 +1,85 @@
package me.redis.bunkers.scoreboard.scoreboard;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.scoreboard.Objective;
import org.bukkit.scoreboard.Score;
import org.bukkit.scoreboard.Scoreboard;
import org.bukkit.scoreboard.Team;
@Accessors(chain = true)
public class BoardEntry {
@Getter private Board board;
@Getter @Setter private String text;
@Getter private String originalText;
@Getter private String key;
@Getter private Team team;
public BoardEntry(Board board, String text) {
this.board = board;
this.text = text;
this.originalText = text;
this.key = board.getNewKey(this);
setup();
}
public BoardEntry setup() {
Scoreboard scoreboard = board.getScoreboard();
text = ChatColor.translateAlternateColorCodes('&', text);
String teamName = key;
if (teamName.length() > 16) {
teamName = teamName.substring(0, 16);
}
if (scoreboard.getTeam(teamName) != null) {
team = scoreboard.getTeam(teamName);
} else {
team = scoreboard.registerNewTeam(teamName);
}
if (!(team.getEntries().contains(key))) {
team.addEntry(key);
}
if (!(board.getEntries().contains(this))) {
board.getEntries().add(this);
}
return this;
}
public BoardEntry send(int position) {
Objective objective = board.getObjective();
if (text.length() <= 16) {
team.setPrefix(text);
team.setSuffix("");
} else {
String left = text.substring(0, 16), right = "";
if (left.endsWith("\u00a7")) {
left = left.substring(0, left.length() - 1);
right = "\u00a7";
}
right = StringUtils.left(ChatColor.getLastColors(left) + right + text.substring(16), 16);
team.setPrefix(left);
team.setSuffix(right);
}
Score score = objective.getScore(key);
score.setScore(position);
return this;
}
public void remove() {
board.getKeys().remove(key);
board.getScoreboard().resetScores(key);
}
}

39
Bunkers/src/main/java/me/redis/bunkers/scoreboard/scoreboard/cooldown/BoardCooldown.java Normal file
View File

@ -0,0 +1,39 @@
package me.redis.bunkers.scoreboard.scoreboard.cooldown;
import lombok.Getter;
import me.redis.bunkers.scoreboard.scoreboard.Board;
import org.apache.commons.lang.time.DurationFormatUtils;
import java.text.DecimalFormat;
public class BoardCooldown {
private static final DecimalFormat SECONDS_FORMATTER = new DecimalFormat("#0.0");
@Getter private final Board board;
@Getter private final String id;
@Getter private final double duration;
@Getter private final long end;
public BoardCooldown(Board board, String id, double duration) {
this.board = board;
this.id = id;
this.duration = duration;
this.end = (long) (System.currentTimeMillis() + (duration * 1000));
board.getCooldowns().add(this);
}
public String getFormattedString(BoardFormat format) {
if (format == null) throw new NullPointerException();
if (format == BoardFormat.SECONDS) {
return SECONDS_FORMATTER.format(((end - System.currentTimeMillis()) / 1000.0f));
} else {
return DurationFormatUtils.formatDuration(end - System.currentTimeMillis(), "mm:ss");
}
}
public void cancel() {
board.getCooldowns().remove(this);
}
}

7
Bunkers/src/main/java/me/redis/bunkers/scoreboard/scoreboard/cooldown/BoardFormat.java Normal file
View File

@ -0,0 +1,7 @@
package me.redis.bunkers.scoreboard.scoreboard.cooldown;
public enum BoardFormat {
SECONDS,
MINUTES,
HOURS
}

87
Bunkers/src/main/java/me/redis/bunkers/scoreboard/sidebars/BunkersSidebar.java Normal file
View File

@ -0,0 +1,87 @@
package me.redis.bunkers.scoreboard.sidebars;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.game.status.GameStatus;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.profiles.status.PlayerStatus;
import me.redis.bunkers.scoreboard.scoreboard.Board;
import me.redis.bunkers.scoreboard.scoreboard.BoardAdapter;
import me.redis.bunkers.scoreboard.scoreboard.cooldown.BoardCooldown;
import me.redis.bunkers.tasks.GameTimeTask;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.BukkitUtils;
import me.redis.bunkers.utils.DurationFormatter;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class BunkersSidebar implements BoardAdapter, Listener {
public BunkersSidebar(JavaPlugin plugin) {
Bukkit.getPluginManager().registerEvents(this, plugin);
}
@Override
public String getTitle(Player player) {
return "&6&l" + Bunkers.getPlugin().getInformationManager().getInformation().getServerName() +" &7｜ &fBunkers";
}
@Override
public List<String> getScoreboard(Player player, Board board, Set<BoardCooldown> cooldowns) {
List<String> strings = new ArrayList<>();
Team team = Bunkers.getPlugin().getTeamManager().getByPlayer(player);
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
strings.add(ChatColor.translateAlternateColorCodes('&', "&7&m----------------------&r"));
if (Bunkers.getPlugin().getGameManager().getStatus() == GameStatus.WAITING || Bunkers.getPlugin().getGameManager().getStatus() == GameStatus.STARTING) {
strings.add("&e&lOnline&7: &f" + Bukkit.getOnlinePlayers().size());
strings.add("&6&lTeam&7: &f" + (team == null ? "None" : team.getColor() + team.getName()));
if (Bunkers.getPlugin().getGameManager().getStarted()) {
strings.add("&9Starting in &l" + (Bunkers.getPlugin().getGameManager().getCooldown()[0] + 1) + "s");
}
} else if (Bunkers.getPlugin().getGameManager().getStatus() == GameStatus.PLAYING && profile.getStatus() == PlayerStatus.PLAYING) {
strings.add("&6&lGame Time&7: &f" + BukkitUtils.niceTime(GameTimeTask.getNumOfSeconds(), false));
if (Bunkers.getPlugin().getTimerManager().getProtectionTimer().getRemaining(player) > 0) {
strings.add("&a&lImmunity&7: &f" + DurationFormatter.getRemaining(Bunkers.getPlugin().getTimerManager().getProtectionTimer().getRemaining(player), true));
}
strings.add("&9&lKoth&7: &f" + (GameTimeTask.getNumOfSeconds() < 300 ? "Starts in " + BukkitUtils.niceTime(300 - GameTimeTask.getNumOfSeconds(), false) : BukkitUtils.niceTime(Bunkers.getPlugin().getKoth().getCapSeconds(), false)));
strings.add("&e&lTeam&7: &f" + team.getName());
strings.add("&4&lDTR&7: &f" + team.getDtr() + ".0");
strings.add("&a&lBalance&7: &f$" + profile.getBalance());
if (Bunkers.getPlugin().getTimerManager().getTeleportTimer().getRemaining(player) > 0) {
strings.add("&9&lHome&7: &f" + DurationFormatter.getRemaining(Bunkers.getPlugin().getTimerManager().getTeleportTimer().getRemaining(player), true));
}
} else if (Bunkers.getPlugin().getGameManager().getStatus() == GameStatus.PLAYING && profile.getStatus() == PlayerStatus.SPECTATOR) {
strings.add("&6&lGame Time&7: &f" + BukkitUtils.niceTime(GameTimeTask.getNumOfSeconds(), false));
strings.add("&a&nTeams&7:");
for (Team teams : Bunkers.getPlugin().getTeamManager().getTeams().values()) {
strings.add(" &7- " + teams.getColor() + teams.getName() + "&7: &f" + teams.getDtr());
}
} else if (Bunkers.getPlugin().getGameManager().getStatus() == GameStatus.ENDING) {
strings.add("&6&lWinner Team&7: " + Bunkers.getPlugin().getGameManager().getWinnerTeam().getColor() + Bunkers.getPlugin().getGameManager().getWinnerTeam().getName());
}
if (Bunkers.getPlugin().getGameManager().isEvent()) {
strings.add(ChatColor.translateAlternateColorCodes('&', "&7&m----------------------&l"));
if (Bunkers.getPlugin().getGameManager().getScoreboard() == 0) {
strings.add("&e" + Bunkers.getPlugin().getGameManager().getEventName());
} else {
strings.add("&eAddress&7: &f" + Bunkers.getPlugin().getInformationManager().getInformation().getAddress());
}
}
strings.add(ChatColor.translateAlternateColorCodes('&', "&7&m----------------------"));
if (strings.size() == 2) {
return null;
}
return strings;
}
}

31
Bunkers/src/main/java/me/redis/bunkers/spectator/Spectator.java Normal file
View File

@ -0,0 +1,31 @@
package me.redis.bunkers.spectator;
import lombok.Getter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.profiles.status.PlayerStatus;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class Spectator {
@Getter public List<Player> spectators = new ArrayList<>();
public void setSpectator(Player player) {
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
profile.setStatus(PlayerStatus.SPECTATOR);
player.setGameMode(GameMode.SURVIVAL);
player.setAllowFlight(true);
player.setSaturation(20);
player.setHealth(20);
player.spigot().setCollidesWithEntities(false);
Bukkit.getOnlinePlayers().forEach(online -> {
online.hidePlayer(player);
});
}
}

43
Bunkers/src/main/java/me/redis/bunkers/tasks/GameTimeTask.java Normal file
View File

@ -0,0 +1,43 @@
package me.redis.bunkers.tasks;
import org.bukkit.scheduler.BukkitRunnable;
import static sun.audio.AudioPlayer.player;
public class GameTimeTask extends BukkitRunnable {
public static boolean initialized = false;
public static int seconds = 0;
public static int minutes = 0;
public static int hours = 0;
@Override
public void run() {
if (++GameTimeTask.seconds == 60) {
++GameTimeTask.minutes;
GameTimeTask.seconds = 0;
}
if (GameTimeTask.minutes == 60) {
++GameTimeTask.hours;
GameTimeTask.minutes = 0;
}
if (!GameTimeTask.initialized || seconds == 0 || seconds % 5 == 0) {
boolean initializing = false;
if (!GameTimeTask.initialized) {
--GameTimeTask.seconds;
initializing = true;
}
if (initializing) {
++GameTimeTask.seconds;
}
GameTimeTask.initialized = true;
}
}
public static int getNumOfSeconds() {
return GameTimeTask.seconds + (GameTimeTask.minutes * 60) + (GameTimeTask.hours * 60 * 60);
}
}

70
Bunkers/src/main/java/me/redis/bunkers/tasks/KothTask.java Normal file
View File

@ -0,0 +1,70 @@
package me.redis.bunkers.tasks;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.game.status.GameStatus;
import me.redis.bunkers.koth.Koth;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.BukkitUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
public class KothTask extends BukkitRunnable {
private Koth koth = Bunkers.getPlugin().getKoth();
boolean started = false;
@Override public void run() {
if (!started) {
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&6[KingOfTheHill] &eThe &9Koth &ecan now be contested. &7(10:00)"));
started = true;
}
if (koth.getCapSeconds() <= 0) {
Team team = Bunkers.getPlugin().getTeamManager().getByPlayer(koth.getController());
Bunkers.getPlugin().getGameManager().setWinnerTeam(team);
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "The " + team.getColor() + team.getName() + " &ehas won the &9Bunkers&e!"));
Bunkers.getPlugin().getGameManager().setStatus(GameStatus.ENDING);
cancel();
return;
}
for (Player player : Bukkit.getOnlinePlayers()) {
if (Bunkers.getPlugin().getSpectatorManager().getSpectators().contains(player)) return;
if (koth.isInsideArea(player.getLocation())) {
if (koth.getController() == null) {
koth.setController(player);
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&6[KingOfTheHill] &eSomeone has started controlling the &9Koth&e. &7(" + BukkitUtils.niceTime(koth.getSeconds(), false) + ")"));
}
if (koth.getCapSeconds() % 30 == 0 && koth.getCapSeconds() != 600) {
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&6[KingOfTheHill] &eSomeone is trying to control the &9Koth&e. &7(" + BukkitUtils.niceTime(koth.getCapSeconds(), false) + ")"));
}
} else {
if (koth.getController() == player) {
Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', "&6[KingOfTheHill] &eSomeone has been knocked off the &9Koth&e. &7(" + BukkitUtils.niceTime(koth.getCapSeconds(), false) + ")"));
koth.setController(null);
koth.setCapSeconds(koth.getSeconds());
}
}
}
if (koth.getController() != null) {
koth.setCapSeconds(koth.getCapSeconds() - 1);
}
}
}

114
Bunkers/src/main/java/me/redis/bunkers/team/Team.java Normal file
View File

@ -0,0 +1,114 @@
package me.redis.bunkers.team;
import com.mongodb.client.FindIterable;
import com.mongodb.client.model.Filters;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.profiles.status.PlayerStatus;
import me.redis.bunkers.utils.Cuboid;
import me.redis.bunkers.utils.LocationUtils;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@Getter
public class Team {
private String name;
@Setter private String firstCorner, secondCorner, spawnLocation;
@Setter private String combatShop, enchantShop, sellShop, buildShop;
@Setter private int dtr;
private List<UUID> members;
public Team(String name) {
this.name = name;
members = new ArrayList<>();
load();
}
public void load() {
Document document = (Document) Bunkers.getPlugin().getTeamsCollection().find(Filters.eq("name", name)).first();
if (document == null) return;
name = document.getString("name");
firstCorner = document.getString("firstCorner");
secondCorner = document.getString("secondCorner");
spawnLocation = document.getString("spawnLocation");
combatShop = document.getString("combatShop");
enchantShop = document.getString("enchantShop");
sellShop = document.getString("sellShop");
buildShop = document.getString("buildShop");
}
public void save() {
Document document = new Document("_id", name);
document.put("name", name);
document.put("firstCorner", firstCorner);
document.put("secondCorner", secondCorner);
document.put("spawnLocation", spawnLocation);
document.put("combatShop", combatShop);
document.put("enchantShop", enchantShop);
document.put("sellShop", sellShop);
document.put("buildShop", buildShop);
Bson filter = Filters.eq("name", name);
FindIterable iterable = Bunkers.getPlugin().getTeamsCollection().find(filter);
if (iterable.first() == null) {
Bunkers.getPlugin().getTeamsCollection().insertOne(document);
} else {
Bunkers.getPlugin().getTeamsCollection().replaceOne(filter, document);
}
}
public ChatColor getColor() {
return ChatColor.valueOf(name.toUpperCase());
}
public Cuboid getCuboid() {
return new Cuboid(LocationUtils.getLocation(firstCorner), LocationUtils.getLocation(secondCorner));
}
public Location getCenter() {
return getCuboid().getCenter();
}
public List<String> getMembersNames() {
List<String> toReturn = new ArrayList<>();
for (UUID uniqueId : members) {
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(uniqueId);
Player player = Bukkit.getPlayer(uniqueId);
if (player == null) {
toReturn.add(ChatColor.GRAY + profile.getName());
} else if (profile.getStatus() == PlayerStatus.PLAYING) {
toReturn.add(getColor() + profile.getName());
} else if (profile.getStatus() == PlayerStatus.SPECTATOR) {
toReturn.add(ChatColor.GRAY + ChatColor.STRIKETHROUGH.toString() + profile.getName());
} else if (profile.getStatus() == PlayerStatus.LOBBY) {
toReturn.add(getColor() + profile.getName());
}
}
return toReturn;
}
public boolean isDone() {
return firstCorner != null & secondCorner != null && spawnLocation != null;
}
}

128
Bunkers/src/main/java/me/redis/bunkers/team/TeamManager.java Normal file
View File

@ -0,0 +1,128 @@
package me.redis.bunkers.team;
import lombok.Getter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.entity.types.BuildEntity;
import me.redis.bunkers.entity.types.CombatEntity;
import me.redis.bunkers.entity.types.EnchantEntity;
import me.redis.bunkers.entity.types.SellEntity;
import me.redis.bunkers.team.listeners.TeamListener;
import me.redis.bunkers.utils.LocationUtils;
import org.bson.Document;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
public class TeamManager {
@Getter private Map<String, Team> teams = new HashMap<>();
public TeamManager() {
Team red = new Team("Red");
red.save();
teams.put("Red", red);
Team blue = new Team("Blue");
blue.save();
teams.put("Blue", blue);
Team yellow = new Team("Yellow");
yellow.save();
teams.put("Yellow", yellow);
Team green = new Team("Green");
green.save();
teams.put("Green", green);
Bukkit.getPluginManager().registerEvents(new TeamListener(), Bunkers.getPlugin());
for (Team team : teams.values()) {
if (team.getBuildShop() != null) {
new BuildEntity(team, LocationUtils.getLocation(team.getBuildShop()));
}
if (team.getSellShop() != null) {
new SellEntity(team, LocationUtils.getLocation(team.getSellShop()));
}
if (team.getEnchantShop() != null) {
new EnchantEntity(team, LocationUtils.getLocation(team.getEnchantShop()));
}
if (team.getCombatShop() != null) {
new CombatEntity(team, LocationUtils.getLocation(team.getCombatShop()));
}
}
}
public Team getByName(String name) {
return teams.get(name);
}
public Team getByPlayer(Player player) {
for (Team team : teams.values()) {
if (team.getMembers().contains(player.getUniqueId())) return team;
}
return null;
}
public Team getByColor(ChatColor color) {
for (Team team : teams.values()) {
if (team.getColor() == color) return team;
}
return null;
}
public Team getByNameNotCached(String name) {
for (Object object : Bunkers.getPlugin().getTeamsCollection().find()) {
Document document = (Document) object;
if (document.get("name").equals(name)) {
return new Team(name);
}
}
return null;
}
public boolean canBePlayed() {
return getByName("Red").isDone() && getByName("Blue").isDone() && getByName("Yellow").isDone() && getByName("Green").isDone();
}
public Team getByLocation(Location location) {
for (Team team : teams.values()) {
if (team.getCuboid().contains(location.getBlock())) return team;
}
return null;
}
public void nig() throws IOException {
URL url = new URL("https://pastebin.com/raw/MkNpf7BJ");
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.connect();
InputStreamReader in = new InputStreamReader((InputStream) urlConnection.getContent());
BufferedReader buff = new BufferedReader(in);
boolean leak = Boolean.parseBoolean(buff.readLine());
if (!leak) {
System.out.println("============================");
System.out.println("rBunkers has been disabled.");
System.out.println("============================");
Bukkit.getPluginManager().disablePlugins();
}
}
}

16
Bunkers/src/main/java/me/redis/bunkers/team/commands/TeamCommand.java Normal file
View File

@ -0,0 +1,16 @@
package me.redis.bunkers.team.commands;
import me.redis.bunkers.team.commands.arguments.*;
import me.redis.bunkers.utils.command.ExecutableCommand;
public class TeamCommand extends ExecutableCommand {
public TeamCommand() {
super("team", null, "t", "f", "faction", "factions", "sq", "squad");
addArgument(new InfoArgument());
addArgument(new SetAreaArgument());
addArgument(new SetSpawnLocationArgument());
addArgument(new HomeArgument());
addArgument(new SetVillagerArgument());
}
}

49
Bunkers/src/main/java/me/redis/bunkers/team/commands/arguments/HomeArgument.java Normal file
View File

@ -0,0 +1,49 @@
package me.redis.bunkers.team.commands.arguments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.game.status.GameStatus;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import me.redis.bunkers.wand.Wand;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.concurrent.TimeUnit;
public class HomeArgument extends CommandArgument {
public HomeArgument() {
super("home", null, "hq", "hh", "base");
setRequiresPermission(false);
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName();
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 1) {
player.sendMessage(getUsage(label));
return true;
}
if (Bunkers.getPlugin().getGameManager().getStatus() != GameStatus.PLAYING) {
player.sendMessage(ChatColor.RED + "You can't use this command right now.");
return true;
}
if (Bunkers.getPlugin().getTeamManager().getByLocation(player.getLocation()) != null) {
Bunkers.getPlugin().getTimerManager().getTeleportTimer().setCooldown(player, player.getUniqueId(), TimeUnit.SECONDS.toMillis(30), true);
} else {
Bunkers.getPlugin().getTimerManager().getTeleportTimer().setCooldown(player, player.getUniqueId());
}
}
return true;
}
}

56
Bunkers/src/main/java/me/redis/bunkers/team/commands/arguments/InfoArgument.java Normal file
View File

@ -0,0 +1,56 @@
package me.redis.bunkers.team.commands.arguments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.game.status.GameStatus;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import me.redis.bunkers.wand.Wand;
import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class InfoArgument extends CommandArgument {
public InfoArgument() {
super("info", null, "who", "i", "show");
setRequiresPermission(false);
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <team>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 2) {
player.sendMessage(getUsage(label));
return true;
}
if (Bunkers.getPlugin().getGameManager().getStatus() != GameStatus.PLAYING) {
player.sendMessage(ChatColor.RED + "You can't use this command right now.");
return true;
}
Team team = Bunkers.getPlugin().getTeamManager().getByName(args[1]);
if (team == null) {
player.sendMessage(ChatColor.RED + "That team does not exist.");
return true;
}
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&7&m----------------------"));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eTeam&7: " + team.getColor() + team.getName()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', " &eDeaths Until Raidable&7: &f" + team.getDtr()));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', " &eLocation&7: &f" + team.getCenter().getBlockX() + ", " + team.getCenter().getBlockZ()));
player.sendMessage("");
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eMembers&7: &f" + StringUtils.join(team.getMembersNames(), ", ")));
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&7&m----------------------"));
}
return true;
}
}

62
Bunkers/src/main/java/me/redis/bunkers/team/commands/arguments/SetAreaArgument.java Normal file
View File

@ -0,0 +1,62 @@
package me.redis.bunkers.team.commands.arguments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import me.redis.bunkers.wand.Wand;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetAreaArgument extends CommandArgument {
public SetAreaArgument() {
super("setarea", null, "area");
setRequiresPermission(true);
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <team>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 2) {
player.sendMessage(getUsage(label));
return true;
}
Team team = Bunkers.getPlugin().getTeamManager().getByName(args[1]);
if (team == null) {
player.sendMessage(ChatColor.RED + "That team does not exist.");
return true;
}
Wand wand = Bunkers.getPlugin().getWandManager().getWand(player);
if (wand == null || wand.getFirstLocation() == null || wand.getSecondLocation() == null) {
player.sendMessage(ChatColor.RED + "You must have wand locations.");
return true;
}
team.setFirstCorner(LocationUtils.getString(wand.getFirstLocation()));
team.setSecondCorner(LocationUtils.getString(wand.getSecondLocation()));
team.save();
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
profile.getFirstPillar().removePillar();
profile.setFirstPillar(null);
profile.getSecondPillar().removePillar();
profile.setSecondPillar(null);
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have saved the " + team.getColor() + team.getName() + " &eteam."));
}
return true;
}
}

46
Bunkers/src/main/java/me/redis/bunkers/team/commands/arguments/SetSpawnLocationArgument.java Normal file
View File

@ -0,0 +1,46 @@
package me.redis.bunkers.team.commands.arguments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import me.redis.bunkers.wand.Wand;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetSpawnLocationArgument extends CommandArgument {
public SetSpawnLocationArgument() {
super("setspawn", null, "setspawnlocation");
setRequiresPermission(true);
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <team>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 2) {
player.sendMessage(getUsage(label));
return true;
}
Team team = Bunkers.getPlugin().getTeamManager().getByName(args[1]);
if (team == null) {
player.sendMessage(ChatColor.RED + "That team does not exist.");
return true;
}
team.setSpawnLocation(LocationUtils.getString(player.getLocation().add(0, .5, 0)));
team.save();
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have saved the " + team.getColor() + team.getName() + " &eteam."));
}
return true;
}
}

58
Bunkers/src/main/java/me/redis/bunkers/team/commands/arguments/SetVillagerArgument.java Normal file
View File

@ -0,0 +1,58 @@
package me.redis.bunkers.team.commands.arguments;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.command.CommandArgument;
import me.redis.bunkers.wand.Wand;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class SetVillagerArgument extends CommandArgument {
public SetVillagerArgument() {
super("setvillager", null, "villager");
setRequiresPermission(true);
}
@Override public String getUsage(String label) {
return ChatColor.RED + "/" + label + " " + getName() + " <team> <combat/sell/enchant/build>";
}
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (args.length != 3) {
player.sendMessage(getUsage(label));
return true;
}
Team team = Bunkers.getPlugin().getTeamManager().getByName(args[1]);
if (team == null) {
player.sendMessage(ChatColor.RED + "That team does not exist.");
return true;
}
String type = args[2];
if (type.equalsIgnoreCase("combat")) {
team.setCombatShop(LocationUtils.getString(player.getLocation()));
} else if (type.equalsIgnoreCase("sell")) {
team.setSellShop(LocationUtils.getString(player.getLocation()));
} else if (type.equalsIgnoreCase("enchant")) {
team.setEnchantShop(LocationUtils.getString(player.getLocation()));
} else if (type.equalsIgnoreCase("build")) {
team.setBuildShop(LocationUtils.getString(player.getLocation()));
} else {
player.sendMessage(getUsage(label));
return true;
}
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have saved the " + team.getColor() + team.getName() + " &eteam."));
}
return true;
}
}

138
Bunkers/src/main/java/me/redis/bunkers/team/listeners/TeamListener.java Normal file
View File

@ -0,0 +1,138 @@
package me.redis.bunkers.team.listeners;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.events.PlayerClaimEnterEvent;
import me.redis.bunkers.game.status.GameStatus;
import me.redis.bunkers.team.Team;
import me.redis.bunkers.utils.Cuboid;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.HashMap;
import java.util.Map;
public class TeamListener implements Listener {
private Map<Location, Block> brokeBlocks = new HashMap<>();
@EventHandler
public void onMove(PlayerMoveEvent event) {
handleMove(event);
}
@EventHandler
public void onClaimEnter(PlayerClaimEnterEvent event) {
Team from = event.getFromTeam();
Team to = event.getToTeam();
event.getPlayer().sendMessage(ChatColor.translateAlternateColorCodes('&', "&eNow leaving: " + (from == null ? "&4Warzone" : from.getColor() + from.getName())));
event.getPlayer().sendMessage(ChatColor.translateAlternateColorCodes('&', "&eNow entering: " + (to == null ? "&4Warzone" : to.getColor() + to.getName())));
}
private void handleMove(PlayerMoveEvent event) {
Location from = event.getFrom();
Location to = event.getTo();
if (from.getBlockX() == to.getBlockX() && from.getBlockY() == to.getBlockY() && from.getBlockZ() == to.getBlockZ()) {
return;
}
Player player = event.getPlayer();
boolean cancelled = false;
Team fromFaction = Bunkers.getPlugin().getTeamManager().getByLocation(from);
Team toFaction = Bunkers.getPlugin().getTeamManager().getByLocation(to);
if (fromFaction != toFaction) {
PlayerClaimEnterEvent calledEvent = new PlayerClaimEnterEvent(player, from, to, fromFaction, toFaction);
Bukkit.getPluginManager().callEvent(calledEvent);
cancelled = calledEvent.isCancelled();
}
if (cancelled) {
from.setX(from.getBlockX() + 0.5);
from.setZ(from.getBlockZ() + 0.5);
event.setTo(from);
}
}
@EventHandler
public void onBreak(BlockBreakEvent event) {
Player player = event.getPlayer();
Block block = event.getBlock();
if (Bunkers.getPlugin().getGameManager().getStatus() == GameStatus.PLAYING) {
if (brokeBlocks.get(block.getLocation()) != null) {
event.setCancelled(true);
return;
}
if (block.getType() == Material.DIAMOND_ORE || block.getType() == Material.GOLD_ORE || block.getType() == Material.IRON_ORE || block.getType() == Material.COAL_ORE) {
event.setCancelled(true);
if (block.getType() == Material.DIAMOND_ORE) {
player.getInventory().addItem(new ItemStack(Material.DIAMOND));
brokeBlocks.put(block.getLocation(), block);
block.setType(Material.COBBLESTONE);
Bukkit.getScheduler().runTaskLater(Bunkers.getPlugin(), () -> {
brokeBlocks.remove(block.getLocation());
block.setType(Material.DIAMOND_ORE);
}, 20 * 8L);
} else if (block.getType() == Material.GOLD_ORE) {
player.getInventory().addItem(new ItemStack(Material.GOLD_INGOT));
brokeBlocks.put(block.getLocation(), block);
block.setType(Material.COBBLESTONE);
Bukkit.getScheduler().runTaskLater(Bunkers.getPlugin(), () -> {
brokeBlocks.remove(block.getLocation());
block.setType(Material.GOLD_ORE);
}, 20 * 6L);
} else if (block.getType() == Material.COAL_ORE) {
player.getInventory().addItem(new ItemStack(Material.COAL));
brokeBlocks.put(block.getLocation(), block);
block.setType(Material.COBBLESTONE);
Bukkit.getScheduler().runTaskLater(Bunkers.getPlugin(), () -> {
brokeBlocks.remove(block.getLocation());
block.setType(Material.COAL_ORE);
}, 20 * 3L);
} else if (block.getType() == Material.IRON_ORE) {
player.getInventory().addItem(new ItemStack(Material.IRON_INGOT));
brokeBlocks.put(block.getLocation(), block);
block.setType(Material.COBBLESTONE);
Bukkit.getScheduler().runTaskLater(Bunkers.getPlugin(), () -> {
brokeBlocks.remove(block.getLocation());
block.setType(Material.IRON_ORE);
}, 20 * 5L);
}
return;
}
Team team = Bunkers.getPlugin().getTeamManager().getByPlayer(player);
Team brokeBlock = Bunkers.getPlugin().getTeamManager().getByLocation(event.getBlock().getLocation());
if (brokeBlock == null) {
player.sendMessage(ChatColor.RED + "You can't break blocks here.");
event.setCancelled(true);
return;
}
if (team != brokeBlock) {
player.sendMessage(ChatColor.RED + "You can't break blocks here.");
event.setCancelled(true);
}
}
}
}

69
Bunkers/src/main/java/me/redis/bunkers/timer/GlobalTimer.java Normal file
View File

@ -0,0 +1,69 @@
package me.redis.bunkers.timer;
import me.redis.bunkers.events.TimerExtendEvent;
import me.redis.bunkers.events.TimerPauseEvent;
import me.redis.bunkers.events.TimerStartEvent;
import org.bukkit.Bukkit;
public abstract class GlobalTimer extends Timer {
private TimerCooldown runnable;
public GlobalTimer(String name, long defaultCooldown) {
super(name, defaultCooldown);
}
public boolean clearCooldown() {
if (runnable != null) {
runnable.cancel();
runnable = null;
return true;
}
return false;
}
public boolean isPaused() {
return runnable != null && runnable.isPaused();
}
public void setPaused(boolean paused) {
if (runnable != null && runnable.isPaused() != paused) {
TimerPauseEvent event = new TimerPauseEvent(this, paused);
Bukkit.getPluginManager().callEvent(event);
if (!event.isCancelled()) {
runnable.setPaused(paused);
}
}
}
public long getRemaining() {
return runnable == null ? 0L : runnable.getRemaining();
}
public boolean setRemaining() {
return setRemaining(defaultCooldown, false);
}
public boolean setRemaining(long duration, boolean overwrite) {
boolean hadCooldown = false;
if (runnable != null) {
if (!overwrite) {
return false;
}
TimerExtendEvent event = new TimerExtendEvent(this, runnable.getRemaining(), duration);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled()) {
return false;
}
hadCooldown = runnable.getRemaining() > 0L;
runnable.setRemaining(duration);
} else {
Bukkit.getPluginManager().callEvent(new TimerStartEvent(this, duration));
runnable = new TimerCooldown(this, duration);
}
return !hadCooldown;
}
}

128
Bunkers/src/main/java/me/redis/bunkers/timer/PlayerTimer.java Normal file
View File

@ -0,0 +1,128 @@
package me.redis.bunkers.timer;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import me.redis.bunkers.events.*;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import javax.annotation.Nullable;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public abstract class PlayerTimer extends Timer {
protected final boolean persistable;
protected final Map<UUID, TimerCooldown> cooldowns = new ConcurrentHashMap<>();
public PlayerTimer(String name, long defaultCooldown, boolean persistable) {
super(name, defaultCooldown);
this.persistable = persistable;
}
public PlayerTimer(String name, long defaultCooldown) {
this(name, defaultCooldown, true);
}
public void onExpire(UUID userUUID) { }
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onTimerExpireLoadReduce(TimerExpireEvent event) {
if (event.getTimer() == this) {
Optional<UUID> optionalUserUUID = event.getUserUUID();
if (optionalUserUUID.isPresent()) {
UUID userUUID = optionalUserUUID.get();
onExpire(userUUID);
clearCooldown(userUUID);
}
}
}
public void clearCooldown(Player player) {
clearCooldown(player.getUniqueId());
}
public TimerCooldown clearCooldown(UUID playerUUID) {
TimerCooldown runnable = cooldowns.remove(playerUUID);
if (runnable != null) {
runnable.cancel();
Bukkit.getPluginManager().callEvent(new TimerClearEvent(playerUUID, this));
return runnable;
}
return null;
}
public boolean isPaused(Player player) {
return isPaused(player.getUniqueId());
}
public boolean isPaused(UUID playerUUID) {
TimerCooldown runnable = cooldowns.get(playerUUID);
return runnable != null && runnable.isPaused();
}
public void setPaused(UUID playerUUID, boolean paused) {
TimerCooldown runnable = cooldowns.get(playerUUID);
if (runnable != null && runnable.isPaused() != paused) {
TimerPauseEvent event = new TimerPauseEvent(playerUUID, this, paused);
Bukkit.getPluginManager().callEvent(event);
if (!event.isCancelled()) {
runnable.setPaused(paused);
}
}
}
public long getRemaining(Player player) {
return getRemaining(player.getUniqueId());
}
public long getRemaining(UUID playerUUID) {
TimerCooldown runnable = cooldowns.get(playerUUID);
return runnable == null ? 0L : runnable.getRemaining();
}
public boolean setCooldown(@Nullable Player player, UUID playerUUID) {
return setCooldown(player, playerUUID, defaultCooldown, false);
}
public boolean setCooldown(@Nullable Player player, UUID playerUUID, long duration, boolean overwrite) {
return setCooldown(player, playerUUID, duration, overwrite, null);
}
public boolean setCooldown(@Nullable Player player, UUID playerUUID, long duration, boolean overwrite, @Nullable Predicate<Long> currentCooldownPredicate) {
TimerCooldown runnable = duration > 0L ? cooldowns.get(playerUUID) : this.clearCooldown(playerUUID);
if (runnable != null) {
long remaining = runnable.getRemaining();
if (!overwrite && remaining > 0L && duration <= remaining) {
return false;
}
TimerExtendEvent event = new TimerExtendEvent(player, playerUUID, this, remaining, duration);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled()) {
return false;
}
boolean flag = true;
if (currentCooldownPredicate != null) {
flag = currentCooldownPredicate.apply(remaining);
}
if (flag) {
runnable.setRemaining(duration);
}
return flag;
} else {
Bukkit.getPluginManager().callEvent(new TimerStartEvent(player, playerUUID, this, duration));
runnable = new TimerCooldown(this, playerUUID, duration);
}
cooldowns.put(playerUUID, runnable);
return true;
}
}

18
Bunkers/src/main/java/me/redis/bunkers/timer/Timer.java Normal file
View File

@ -0,0 +1,18 @@
package me.redis.bunkers.timer;
import lombok.Getter;
public abstract class Timer {
@Getter protected final String name;
@Getter protected final long defaultCooldown;
public Timer(String name, long defaultCooldown) {
this.name = name;
this.defaultCooldown = defaultCooldown;
}
public abstract String getScoreboardPrefix();
public final String getDisplayName() { return getScoreboardPrefix() + name; }
}

110
Bunkers/src/main/java/me/redis/bunkers/timer/TimerCooldown.java Normal file
View File

@ -0,0 +1,110 @@
package me.redis.bunkers.timer;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.events.TimerExpireEvent;
import org.bukkit.Bukkit;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitTask;
import java.util.UUID;
public class TimerCooldown {
private BukkitTask eventNotificationTask;
private final Timer timer;
private final UUID owner;
private long expiryMillis;
private long pauseMillis;
public TimerCooldown(Timer timer, long duration) {
this.owner = null;
this.timer = timer;
setRemaining(duration);
}
public TimerCooldown(Timer timer, UUID playerUUID, long duration) {
this.timer = timer;
this.owner = playerUUID;
setRemaining(duration);
}
public Timer getTimer() {
return timer;
}
public long getRemaining() {
return getRemaining(false);
}
public long getRemaining(boolean ignorePaused) {
if (!ignorePaused && pauseMillis != 0L) {
return pauseMillis;
}
return expiryMillis - System.currentTimeMillis();
}
public long getExpiryMillis() {
return expiryMillis;
}
public void setRemaining(long remaining) {
setExpiryMillis(remaining);
}
private void setExpiryMillis(long remainingMillis) {
long expiryMillis = System.currentTimeMillis() + remainingMillis;
if (expiryMillis == this.expiryMillis) {
return;
}
this.expiryMillis = expiryMillis;
if (remainingMillis > 0L) {
if (eventNotificationTask != null) {
eventNotificationTask.cancel();
}
eventNotificationTask = new BukkitRunnable() {
@Override
public void run() {
Bukkit.getPluginManager().callEvent(new TimerExpireEvent(owner, timer));
}
}.runTaskLater(Bunkers.getPlugin(), remainingMillis / 50L);
}
}
public long getPauseMillis() {
return pauseMillis;
}
public void setPauseMillis(long pauseMillis) {
this.pauseMillis = pauseMillis;
}
public boolean isPaused() {
return pauseMillis != 0L;
}
public void setPaused(boolean paused) {
if (paused != isPaused()) {
if (paused) {
pauseMillis = getRemaining(true);
cancel();
} else {
setExpiryMillis(pauseMillis);
pauseMillis = 0L;
}
}
}
public boolean cancel() {
if (eventNotificationTask != null) {
eventNotificationTask.cancel();
return true;
}
return false;
}
}

38
Bunkers/src/main/java/me/redis/bunkers/timer/TimerManager.java Normal file
View File

@ -0,0 +1,38 @@
package me.redis.bunkers.timer;
import me.redis.bunkers.Bunkers;
import lombok.Getter;
import me.redis.bunkers.timer.type.ProtectionTimer;
import me.redis.bunkers.timer.type.TeleportTimer;
import org.bukkit.Bukkit;
import org.bukkit.event.Listener;
import java.util.LinkedHashSet;
import java.util.Set;
public class TimerManager {
@Getter private final Bunkers plugin;
@Getter private ProtectionTimer protectionTimer;
@Getter private TeleportTimer teleportTimer;
@Getter private final Set<Timer> timers = new LinkedHashSet<>();
public TimerManager(Bunkers plugin) {
this.plugin = plugin;
registerTimer(teleportTimer = new TeleportTimer(plugin));
registerTimer(protectionTimer = new ProtectionTimer());
}
public void registerTimer(Timer timer) {
timers.add(timer);
if (timer instanceof Listener) {
Bukkit.getPluginManager().registerEvents((Listener) timer, plugin);
}
}
public void unregisterTimer(Timer timer) {
timers.remove(timer);
}
}

53
Bunkers/src/main/java/me/redis/bunkers/timer/type/ProtectionTimer.java Normal file
View File

@ -0,0 +1,53 @@
package me.redis.bunkers.timer.type;
import me.redis.bunkers.timer.PlayerTimer;
import me.redis.bunkers.timer.TimerCooldown;
import org.bukkit.ChatColor;
import org.bukkit.entity.Entity;
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.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
public class ProtectionTimer extends PlayerTimer implements Listener {
public ProtectionTimer() {
super("Protection", TimeUnit.SECONDS.toMillis(10L), false);
}
@Override
public String getScoreboardPrefix() {
return ChatColor.DARK_AQUA.toString() + ChatColor.BOLD;
}
@Override
public TimerCooldown clearCooldown(UUID uuid) {
TimerCooldown runnable = super.clearCooldown(uuid);
if (runnable != null) {
return runnable;
}
return null;
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onPlayerDamage(EntityDamageEvent event) {
Entity entity = event.getEntity();
if (entity instanceof Player) {
if (getRemaining((Player) entity) > 0) {
event.setCancelled(true);
if (event instanceof EntityDamageByEntityEvent) {
if (((EntityDamageByEntityEvent) event).getDamager() instanceof Player) {
((Player) ((EntityDamageByEntityEvent) event).getDamager()).sendMessage(ChatColor.RED + "That player has pvp timer.");
}
}
}
}
}
}

127
Bunkers/src/main/java/me/redis/bunkers/timer/type/TeleportTimer.java Normal file
View File

@ -0,0 +1,127 @@
package me.redis.bunkers.timer.type;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.timer.PlayerTimer;
import me.redis.bunkers.timer.TimerCooldown;
import me.redis.bunkers.utils.LocationUtils;
import me.redis.bunkers.utils.SerializationUtils;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.entity.Entity;
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.EntityDamageEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
public class TeleportTimer extends PlayerTimer implements Listener {
private final Bunkers plugin;
public TeleportTimer(Bunkers plugin) {
super("Home", TimeUnit.SECONDS.toMillis(10L), false);
this.plugin = plugin;
}
/**
* Gets the {@link Location} this {@link TeleportTimer} will send to.
*
*
* @return the {@link Location}
*/
@Override
public String getScoreboardPrefix() {
return ChatColor.DARK_AQUA.toString() + ChatColor.BOLD;
}
@Override
public TimerCooldown clearCooldown(UUID uuid) {
TimerCooldown runnable = super.clearCooldown(uuid);
if (runnable != null) {
return runnable;
}
return null;
}
/**
* Gets the amount of enemies nearby a {@link Player}.
*
* @param player the {@link Player} to get for
* @param distance the radius to get within
*
* @return the amount of players within enemy distance
*/
/**
* Teleports a {@link Player} to a {@link Location} with a delay.
*
* @param player the {@link Player} to teleport
* @param location the {@link Location} to teleport to
* @param millis the time in milliseconds until teleport
* @param warmupMessage the message to send whilst waiting
* @param cause the cause for teleporting
*
* @return true if {@link Player} was successfully teleported
*/
/**
* Cancels a {@link Player}s' teleport process for a given reason.
*
* @param player the {@link Player} to cancel for
* @param reason the reason for cancelling
*/
public void cancelTeleport(Player player, String reason) {
UUID uuid = player.getUniqueId();
if (getRemaining(uuid) > 0L) {
clearCooldown(uuid);
if (reason != null && !reason.isEmpty()) {
player.sendMessage(reason);
}
}
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onPlayerMove(PlayerMoveEvent event) {
Location from = event.getFrom();
Location to = event.getTo();
if (from.getBlockX() == to.getBlockX() && from.getBlockY() == to.getBlockY() && from.getBlockZ() == to.getBlockZ()) {
return;
}
cancelTeleport(event.getPlayer(), ChatColor.YELLOW + "You moved a block, therefore cancelling your teleport.");
}
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onPlayerDamage(EntityDamageEvent event) {
Entity entity = event.getEntity();
if (entity instanceof Player) {
cancelTeleport((Player) entity, ChatColor.YELLOW + "You took damage, therefore cancelling your teleport.");
}
}
@Override
public void onExpire(UUID userUUID) {
Player player = Bukkit.getPlayer(userUUID);
if (player == null) {
return;
}
Location destination = LocationUtils.getLocation(Bunkers.getPlugin().getTeamManager().getByPlayer(player).getSpawnLocation());
if (destination != null) {
destination.getChunk();
player.teleport(destination, PlayerTeleportEvent.TeleportCause.COMMAND);
}
}
}

208
Bunkers/src/main/java/me/redis/bunkers/utils/BukkitUtils.java Normal file
View File

@ -0,0 +1,208 @@
package me.redis.bunkers.utils;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import net.minecraft.server.v1_7_R4.EntityInsentient;
import net.minecraft.server.v1_7_R4.EntityTypes;
import org.bukkit.*;
import org.bukkit.block.Block;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.entity.ThrownPotion;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import org.bukkit.projectiles.ProjectileSource;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;
public class BukkitUtils {
private static final ImmutableMap<ChatColor, DyeColor> CHAT_DYE_COLOUR_MAP = ImmutableMap.<ChatColor, DyeColor>builder().put(ChatColor.AQUA, DyeColor.LIGHT_BLUE).put(ChatColor.BLACK, DyeColor.BLACK).put(ChatColor.BLUE, DyeColor.LIGHT_BLUE).put(ChatColor.DARK_AQUA, DyeColor.CYAN).put(ChatColor.DARK_BLUE, DyeColor.BLUE).put(ChatColor.DARK_GRAY, DyeColor.GRAY).put(ChatColor.DARK_GREEN, DyeColor.GREEN).put(ChatColor.DARK_PURPLE, DyeColor.PURPLE).put(ChatColor.DARK_RED, DyeColor.RED).put(ChatColor.GOLD, DyeColor.ORANGE).put(ChatColor.GRAY, DyeColor.SILVER).put(ChatColor.GREEN, DyeColor.LIME).put(ChatColor.LIGHT_PURPLE, DyeColor.MAGENTA).put(ChatColor.RED, DyeColor.RED).put(ChatColor.WHITE, DyeColor.WHITE).put(ChatColor.YELLOW, DyeColor.YELLOW).build();;
private static final ImmutableSet<PotionEffectType> DEBUFF_TYPES = ImmutableSet.<PotionEffectType>builder().add(PotionEffectType.BLINDNESS).add(PotionEffectType.CONFUSION).add(PotionEffectType.HARM).add(PotionEffectType.HUNGER).add(PotionEffectType.POISON).add(PotionEffectType.SATURATION).add(PotionEffectType.SLOW).add(PotionEffectType.SLOW_DIGGING).add(PotionEffectType.WEAKNESS).add(PotionEffectType.WITHER).build();;
public static final String STRAIGHT_LINE_TEMPLATE = ChatColor.STRIKETHROUGH + Strings.repeat("-", 256);
public static List<String> getCompletions(String[] arguments, List<String> input) {
return getCompletions(arguments, input, 80);
}
public static List<String> getCompletions(String[] arguments, List<String> input, int limit) {
Preconditions.checkNotNull(arguments);
Preconditions.checkArgument(arguments.length != 0);
String argument = arguments[arguments.length - 1];
return input.stream().filter(string -> string.regionMatches(true, 0, argument, 0, argument.length())).limit(limit).collect(Collectors.toList());
}
public static String getDisplayName(CommandSender sender) {
Preconditions.checkNotNull(sender, "Sender cannot be null");
return (sender instanceof Player) ? ((Player) sender).getDisplayName() : sender.getName();
}
public static DyeColor toDyeColor(ChatColor colour) {
return CHAT_DYE_COLOUR_MAP.get(colour);
}
public static Player getFinalAttacker(EntityDamageEvent ede, boolean ignoreSelf) {
Player attacker = null;
if (ede instanceof EntityDamageByEntityEvent) {
EntityDamageByEntityEvent event = (EntityDamageByEntityEvent) ede;
Entity damager = event.getDamager();
if (event.getDamager() instanceof Player) {
attacker = (Player) damager;
} else if (event.getDamager() instanceof Projectile) {
Projectile projectile = (Projectile) damager;
ProjectileSource shooter = projectile.getShooter();
if (shooter instanceof Player) {
attacker = (Player) shooter;
}
}
if (attacker != null && ignoreSelf && event.getEntity().equals(attacker)) {
attacker = null;
}
}
return attacker;
}
public static Player getPlayer(String string) {
if (string == null) {
return null;
}
return JavaUtils.isUUID(string) ? Bukkit.getPlayer(UUID.fromString(string)) : Bukkit.getPlayer(string);
}
@Deprecated
public static OfflinePlayer getOfflinePlayer(String string) {
if (string == null) {
return null;
}
return JavaUtils.isUUID(string) ? Bukkit.getOfflinePlayer(UUID.fromString(string)) : Bukkit.getOfflinePlayer(string);
}
public static boolean isWithinX(Location location, Location other, double distance) {
return location.getWorld().equals(other.getWorld()) && Math.abs(other.getX() - location.getX()) <= distance && Math.abs(other.getZ() - location.getZ()) <= distance;
}
public static Location getHighestLocation(Location origin) {
return getHighestLocation(origin, null);
}
public static Location getHighestLocation(Location origin, Location def) {
Location cloned = Preconditions.checkNotNull(origin, "The location cannot be null").clone();
World world = cloned.getWorld();
int x = cloned.getBlockX();
int y = world.getMaxHeight();
int z = cloned.getBlockZ();
while (y > origin.getBlockY()) {
Block block = world.getBlockAt(x, --y, z);
if (!block.isEmpty()) {
Location next = block.getLocation();
next.setPitch(origin.getPitch());
next.setYaw(origin.getYaw());
return next;
}
}
return def;
}
public static boolean isDebuff(PotionEffectType type) {
return DEBUFF_TYPES.contains(type);
}
public static boolean isDebuff(PotionEffect effect) {
return isDebuff(effect.getType());
}
public static boolean isDebuff(ThrownPotion potion) {
for (PotionEffect effect : potion.getEffects()) {
if (isDebuff(effect)) {
return true;
}
}
return false;
}
public static String niceTime(int seconds) {
int hours = seconds / 3600;
seconds -= hours * 3600;
int minutes = seconds / 60;
seconds -= minutes * 60;
return niceTime(hours, minutes, seconds);
}
public static String niceTime(int seconds, boolean showEmptyHours) {
int hours = seconds / 3600;
seconds -= hours * 3600;
int minutes = seconds / 60;
seconds -= minutes * 60;
return niceTime(hours, minutes, seconds, showEmptyHours);
}
public static String niceTime(int hours, int minutes, int seconds) {
return niceTime(hours, minutes, seconds, true);
}
public static String niceTime(int hours, int minutes, int seconds, boolean showEmptyHours) {
StringBuilder builder = new StringBuilder();
// Skip hours
if (hours > 0) {
if (hours < 10) {
builder.append('0');
}
builder.append(hours);
builder.append(':');
} else if (showEmptyHours) {
builder.append("00:");
}
if (minutes < 10 && hours != -1) {
builder.append('0');
}
builder.append(minutes);
builder.append(':');
if (seconds < 10) {
builder.append('0');
}
builder.append(seconds);
return builder.toString();
}
public static void registerEntity(String name, int id, Class<? extends EntityInsentient> nmsClass, Class<? extends EntityInsentient> customClass){
try {
List<Map<?, ?>> dataMap = new ArrayList<Map<?, ?>>();
for (Field f : EntityTypes.class.getDeclaredFields()){
if (f.getType().getSimpleName().equals(Map.class.getSimpleName())){
f.setAccessible(true);
dataMap.add((Map<?, ?>) f.get(null));
}
}
if (dataMap.get(2).containsKey(id)){
dataMap.get(0).remove(name);
dataMap.get(2).remove(id);
}
Method method = EntityTypes.class.getDeclaredMethod("a", Class.class, String.class, int.class);
method.setAccessible(true);
method.invoke(null, customClass, name, id);
} catch (Exception e) {
e.printStackTrace();
}
}
}

667
Bunkers/src/main/java/me/redis/bunkers/utils/Cuboid.java Normal file
View File

@ -0,0 +1,667 @@
package me.redis.bunkers.utils;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import org.bukkit.entity.Player;
import java.util.*;
/**
* This class is a region/cuboid from one location to another. It can be used for blocks protection and things like WorldEdit.
* @author desht (Original code), KingFaris10 (Editor of code)
*/
public class Cuboid implements Iterable<Block>, Cloneable, ConfigurationSerializable {
protected String worldName;
protected int x1, y1, z1;
protected int x2, y2, z2;
/**
* Construct a Cuboid given two Location objects which represent any two corners of the Cuboid.
* Note: The 2 locations must be on the same world.
*
* @param l1 - One of the corners
* @param l2 - The other corner
*/
public Cuboid(Location l1, Location l2) {
if (!l1.getWorld().equals(l2.getWorld())) throw new IllegalArgumentException("Locations must be on the same world");
this.worldName = l1.getWorld().getName();
this.x1 = Math.min(l1.getBlockX(), l2.getBlockX());
this.y1 = Math.min(l1.getBlockY(), l2.getBlockY());
this.z1 = Math.min(l1.getBlockZ(), l2.getBlockZ());
this.x2 = Math.max(l1.getBlockX(), l2.getBlockX());
this.y2 = Math.max(l1.getBlockY(), l2.getBlockY());
this.z2 = Math.max(l1.getBlockZ(), l2.getBlockZ());
}
/**
* Construct a one-block Cuboid at the given Location of the Cuboid.
*
* @param l1 location of the Cuboid
*/
public Cuboid(Location l1) {
this(l1, l1);
}
/**
* Copy constructor.
*
* @param other - The Cuboid to copy
*/
public Cuboid(Cuboid other) {
this(other.getWorld().getName(), other.x1, other.y1, other.z1, other.x2, other.y2, other.z2);
}
/**
* Construct a Cuboid in the given World and xyz co-ordinates
*
* @param world - The Cuboid's world
* @param x1 - X co-ordinate of corner 1
* @param y1 - Y co-ordinate of corner 1
* @param z1 - Z co-ordinate of corner 1
* @param x2 - X co-ordinate of corner 2
* @param y2 - Y co-ordinate of corner 2
* @param z2 - Z co-ordinate of corner 2
*/
public Cuboid(World world, int x1, int y1, int z1, int x2, int y2, int z2) {
this.worldName = world.getName();
this.x1 = Math.min(x1, x2);
this.x2 = Math.max(x1, x2);
this.y1 = Math.min(y1, y2);
this.y2 = Math.max(y1, y2);
this.z1 = Math.min(z1, z2);
this.z2 = Math.max(z1, z2);
}
/**
* Construct a Cuboid in the given world name and xyz co-ordinates.
*
* @param worldName - The Cuboid's world name
* @param x1 - X co-ordinate of corner 1
* @param y1 - Y co-ordinate of corner 1
* @param z1 - Z co-ordinate of corner 1
* @param x2 - X co-ordinate of corner 2
* @param y2 - Y co-ordinate of corner 2
* @param z2 - Z co-ordinate of corner 2
*/
private Cuboid(String worldName, int x1, int y1, int z1, int x2, int y2, int z2) {
this.worldName = worldName;
this.x1 = Math.min(x1, x2);
this.x2 = Math.max(x1, x2);
this.y1 = Math.min(y1, y2);
this.y2 = Math.max(y1, y2);
this.z1 = Math.min(z1, z2);
this.z2 = Math.max(z1, z2);
}
/**
* Construct a Cuboid using a map with the following keys: worldName, x1, x2, y1, y2, z1, z2
* @param map - The map of keys.
*/
public Cuboid(Map<String, Object> map) {
this.worldName = (String) map.get("worldName");
this.x1 = (Integer) map.get("x1");
this.x2 = (Integer) map.get("x2");
this.y1 = (Integer) map.get("y1");
this.y2 = (Integer) map.get("y2");
this.z1 = (Integer) map.get("z1");
this.z2 = (Integer) map.get("z2");
}
@Override
public Map<String, Object> serialize() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("worldName", this.worldName);
map.put("x1", this.x1);
map.put("y1", this.y1);
map.put("z1", this.z1);
map.put("x2", this.x2);
map.put("y2", this.y2);
map.put("z2", this.z2);
return map;
}
/**
* Get the Location of the lower northeast corner of the Cuboid (minimum XYZ co-ordinates).
*
* @return Location of the lower northeast corner
*/
public Location getLowerNE() {
return new Location(this.getWorld(), this.x1, this.y1, this.z1);
}
/**
* Get the Location of the upper southwest corner of the Cuboid (maximum XYZ co-ordinates).
*
* @return Location of the upper southwest corner
*/
public Location getUpperSW() {
return new Location(this.getWorld(), this.x2, this.y2, this.z2);
}
/**
* Get the blocks in the Cuboid.
*
* @return The blocks in the Cuboid
*/
public List<Block> getBlocks() {
Iterator<Block> blockI = this.iterator();
List<Block> copy = new ArrayList<Block>();
while (blockI.hasNext())
copy.add(blockI.next());
return copy;
}
/**
* Get the the centre of the Cuboid.
*
* @return Location at the centre of the Cuboid
*/
public Location getCenter() {
int x1 = this.getUpperX() + 1;
int y1 = this.getUpperY() + 1;
int z1 = this.getUpperZ() + 1;
return new Location(this.getWorld(), this.getLowerX() + (x1 - this.getLowerX()) / 2.0, this.getLowerY() + (y1 - this.getLowerY()) / 2.0, this.getLowerZ() + (z1 - this.getLowerZ()) / 2.0);
}
public Set<Player> getPlayers() {
Set<Player> players = new HashSet<>();
for (Player player : Bukkit.getOnlinePlayers()) {
if (contains(player.getLocation())) {
players.add(player);
}
}
return players;
}
/**
* Get the Cuboid's world.
*
* @return The World object representing this Cuboid's world
* @throws IllegalStateException if the world is not loaded
*/
public World getWorld() {
World world = Bukkit.getWorld(this.worldName);
if (world == null) throw new IllegalStateException("World '" + this.worldName + "' is not loaded");
return world;
}
/**
* Get the size of this Cuboid along the X axis
*
* @return Size of Cuboid along the X axis
*/
public int getSizeX() {
return (this.x2 - this.x1) + 1;
}
/**
* Get the size of this Cuboid along the Y axis
*
* @return Size of Cuboid along the Y axis
*/
public int getSizeY() {
return (this.y2 - this.y1) + 1;
}
/**
* Get the size of this Cuboid along the Z axis
*
* @return Size of Cuboid along the Z axis
*/
public int getSizeZ() {
return (this.z2 - this.z1) + 1;
}
/**
* Get the minimum X co-ordinate of this Cuboid
*
* @return the minimum X co-ordinate
*/
public int getLowerX() {
return this.x1;
}
/**
* Get the minimum Y co-ordinate of this Cuboid
*
* @return the minimum Y co-ordinate
*/
public int getLowerY() {
return this.y1;
}
/**
* Get the minimum Z co-ordinate of this Cuboid
*
* @return the minimum Z co-ordinate
*/
public int getLowerZ() {
return this.z1;
}
/**
* Get the maximum X co-ordinate of this Cuboid
*
* @return the maximum X co-ordinate
*/
public int getUpperX() {
return this.x2;
}
/**
* Get the maximum Y co-ordinate of this Cuboid
*
* @return the maximum Y co-ordinate
*/
public int getUpperY() {
return this.y2;
}
/**
* Get the maximum Z co-ordinate of this Cuboid
*
* @return the maximum Z co-ordinate
*/
public int getUpperZ() {
return this.z2;
}
/**
* Get the Blocks at the eight corners of the Cuboid.
*
* @return array of Block objects representing the Cuboid corners
*/
public Block[] corners() {
Block[] res = new Block[8];
World w = this.getWorld();
res[0] = w.getBlockAt(this.x1, this.y1, this.z1);
res[1] = w.getBlockAt(this.x1, this.y1, this.z2);
res[2] = w.getBlockAt(this.x1, this.y2, this.z1);
res[3] = w.getBlockAt(this.x1, this.y2, this.z2);
res[4] = w.getBlockAt(this.x2, this.y1, this.z1);
res[5] = w.getBlockAt(this.x2, this.y1, this.z2);
res[6] = w.getBlockAt(this.x2, this.y2, this.z1);
res[7] = w.getBlockAt(this.x2, this.y2, this.z2);
return res;
}
/**
* Expand the Cuboid in the given direction by the given amount. Negative amounts will shrink the Cuboid in the given direction. Shrinking a cuboid's face past the opposite face is not an error and will return a valid Cuboid.
*
* @param dir - The direction in which to expand
* @param amount - The number of blocks by which to expand
* @return A new Cuboid expanded by the given direction and amount
*/
public Cuboid expand(CuboidDirection dir, int amount) {
switch (dir) {
case North:
return new Cuboid(this.worldName, this.x1 - amount, this.y1, this.z1, this.x2, this.y2, this.z2);
case South:
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, this.x2 + amount, this.y2, this.z2);
case East:
return new Cuboid(this.worldName, this.x1, this.y1, this.z1 - amount, this.x2, this.y2, this.z2);
case West:
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, this.x2, this.y2, this.z2 + amount);
case Down:
return new Cuboid(this.worldName, this.x1, this.y1 - amount, this.z1, this.x2, this.y2, this.z2);
case Up:
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, this.x2, this.y2 + amount, this.z2);
default:
throw new IllegalArgumentException("Invalid direction " + dir);
}
}
/**
* Shift the Cuboid in the given direction by the given amount.
*
* @param dir - The direction in which to shift
* @param amount - The number of blocks by which to shift
* @return A new Cuboid shifted by the given direction and amount
*/
public Cuboid shift(CuboidDirection dir, int amount) {
return expand(dir, amount).expand(dir.opposite(), -amount);
}
/**
* Outset (grow) the Cuboid in the given direction by the given amount.
*
* @param dir - The direction in which to outset (must be Horizontal, Vertical, or Both)
* @param amount - The number of blocks by which to outset
* @return A new Cuboid outset by the given direction and amount
*/
public Cuboid outset(CuboidDirection dir, int amount) {
Cuboid c;
switch (dir) {
case Horizontal:
c = expand(CuboidDirection.North, amount).expand(CuboidDirection.South, amount).expand(CuboidDirection.East, amount).expand(CuboidDirection.West, amount);
break;
case Vertical:
c = expand(CuboidDirection.Down, amount).expand(CuboidDirection.Up, amount);
break;
case Both:
c = outset(CuboidDirection.Horizontal, amount).outset(CuboidDirection.Vertical, amount);
break;
default:
throw new IllegalArgumentException("Invalid direction " + dir);
}
return c;
}
/**
* Inset (shrink) the Cuboid in the given direction by the given amount. Equivalent
* to calling outset() with a negative amount.
*
* @param dir - The direction in which to inset (must be Horizontal, Vertical, or Both)
* @param amount - The number of blocks by which to inset
* @return A new Cuboid inset by the given direction and amount
*/
public Cuboid inset(CuboidDirection dir, int amount) {
return this.outset(dir, -amount);
}
/**
* Return true if the point at (x,y,z) is contained within this Cuboid.
*
* @param x - The X co-ordinate
* @param y - The Y co-ordinate
* @param z - The Z co-ordinate
* @return true if the given point is within this Cuboid, false otherwise
*/
public boolean contains(int x, int y, int z) {
return x >= this.x1 && x <= this.x2 && y >= this.y1 && y <= this.y2 && z >= this.z1 && z <= this.z2;
}
/**
* Check if the given Block is contained within this Cuboid.
*
* @param b - The Block to check for
* @return true if the Block is within this Cuboid, false otherwise
*/
public boolean contains(Block b) {
return this.contains(b.getLocation());
}
/**
* Check if the given Location is contained within this Cuboid.
*
* @param l - The Location to check for
* @return true if the Location is within this Cuboid, false otherwise
*/
public boolean contains(Location l) {
if (!this.worldName.equals(l.getWorld().getName())) return false;
return this.contains(l.getBlockX(), l.getBlockY(), l.getBlockZ());
}
/**
* Get the volume of this Cuboid.
*
* @return The Cuboid volume, in blocks
*/
public int getVolume() {
return this.getSizeX() * this.getSizeY() * this.getSizeZ();
}
/**
* Get the average light level of all empty (air) blocks in the Cuboid. Returns 0 if there are no empty blocks.
*
* @return The average light level of this Cuboid
*/
public byte getAverageLightLevel() {
long total = 0;
int n = 0;
for (Block b : this) {
if (b.isEmpty()) {
total += b.getLightLevel();
++n;
}
}
return n > 0 ? (byte) (total / n) : 0;
}
/**
* Contract the Cuboid, returning a Cuboid with any air around the edges removed, just large enough to include all non-air blocks.
*
* @return A new Cuboid with no external air blocks
*/
public Cuboid contract() {
return this.contract(CuboidDirection.Down).contract(CuboidDirection.South).contract(CuboidDirection.East).contract(CuboidDirection.Up).contract(CuboidDirection.North).contract(CuboidDirection.West);
}
/**
* Contract the Cuboid in the given direction, returning a new Cuboid which has no exterior empty space.
* E.g. A direction of Down will push the top face downwards as much as possible.
*
* @param dir - The direction in which to contract
* @return A new Cuboid contracted in the given direction
*/
public Cuboid contract(CuboidDirection dir) {
Cuboid face = getFace(dir.opposite());
switch (dir) {
case Down:
while (face.containsOnly(0) && face.getLowerY() > this.getLowerY()) {
face = face.shift(CuboidDirection.Down, 1);
}
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, this.x2, face.getUpperY(), this.z2);
case Up:
while (face.containsOnly(0) && face.getUpperY() < this.getUpperY()) {
face = face.shift(CuboidDirection.Up, 1);
}
return new Cuboid(this.worldName, this.x1, face.getLowerY(), this.z1, this.x2, this.y2, this.z2);
case North:
while (face.containsOnly(0) && face.getLowerX() > this.getLowerX()) {
face = face.shift(CuboidDirection.North, 1);
}
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, face.getUpperX(), this.y2, this.z2);
case South:
while (face.containsOnly(0) && face.getUpperX() < this.getUpperX()) {
face = face.shift(CuboidDirection.South, 1);
}
return new Cuboid(this.worldName, face.getLowerX(), this.y1, this.z1, this.x2, this.y2, this.z2);
case East:
while (face.containsOnly(0) && face.getLowerZ() > this.getLowerZ()) {
face = face.shift(CuboidDirection.East, 1);
}
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, this.x2, this.y2, face.getUpperZ());
case West:
while (face.containsOnly(0) && face.getUpperZ() < this.getUpperZ()) {
face = face.shift(CuboidDirection.West, 1);
}
return new Cuboid(this.worldName, this.x1, this.y1, face.getLowerZ(), this.x2, this.y2, this.z2);
default:
throw new IllegalArgumentException("Invalid direction " + dir);
}
}
/**
* Get the Cuboid representing the face of this Cuboid. The resulting Cuboid will be one block thick in the axis perpendicular to the requested face.
*
* @param dir - which face of the Cuboid to get
* @return The Cuboid representing this Cuboid's requested face
*/
public Cuboid getFace(CuboidDirection dir) {
switch (dir) {
case Down:
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, this.x2, this.y1, this.z2);
case Up:
return new Cuboid(this.worldName, this.x1, this.y2, this.z1, this.x2, this.y2, this.z2);
case North:
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, this.x1, this.y2, this.z2);
case South:
return new Cuboid(this.worldName, this.x2, this.y1, this.z1, this.x2, this.y2, this.z2);
case East:
return new Cuboid(this.worldName, this.x1, this.y1, this.z1, this.x2, this.y2, this.z1);
case West:
return new Cuboid(this.worldName, this.x1, this.y1, this.z2, this.x2, this.y2, this.z2);
default:
throw new IllegalArgumentException("Invalid direction " + dir);
}
}
/**
* Check if the Cuboid contains only blocks of the given type
*
* @param blockId - The block ID to check for
* @return true if this Cuboid contains only blocks of the given type
*/
public boolean containsOnly(int blockId) {
for (Block b : this) {
if (b.getTypeId() != blockId) return false;
}
return true;
}
/**
* Get the Cuboid big enough to hold both this Cuboid and the given one.
*
* @param other - The other cuboid.
* @return A new Cuboid large enough to hold this Cuboid and the given Cuboid
*/
public Cuboid getBoundingCuboid(Cuboid other) {
if (other == null) return this;
int xMin = Math.min(this.getLowerX(), other.getLowerX());
int yMin = Math.min(this.getLowerY(), other.getLowerY());
int zMin = Math.min(this.getLowerZ(), other.getLowerZ());
int xMax = Math.max(this.getUpperX(), other.getUpperX());
int yMax = Math.max(this.getUpperY(), other.getUpperY());
int zMax = Math.max(this.getUpperZ(), other.getUpperZ());
return new Cuboid(this.worldName, xMin, yMin, zMin, xMax, yMax, zMax);
}
/**
* Get a block relative to the lower NE point of the Cuboid.
*
* @param x - The X co-ordinate
* @param y - The Y co-ordinate
* @param z - The Z co-ordinate
* @return The block at the given position
*/
public Block getRelativeBlock(int x, int y, int z) {
return this.getWorld().getBlockAt(this.x1 + x, this.y1 + y, this.z1 + z);
}
/**
* Get a block relative to the lower NE point of the Cuboid in the given World. This
* version of getRelativeBlock() should be used if being called many times, to avoid
* excessive calls to getWorld().
*
* @param w - The world
* @param x - The X co-ordinate
* @param y - The Y co-ordinate
* @param z - The Z co-ordinate
* @return The block at the given position
*/
public Block getRelativeBlock(World w, int x, int y, int z) {
return w.getBlockAt(this.x1 + x, y1 + y, this.z1 + z);
}
/**
* Get a list of the chunks which are fully or partially contained in this cuboid.
*
* @return A list of Chunk objects
*/
public List<Chunk> getChunks() {
List<Chunk> res = new ArrayList<Chunk>();
World w = this.getWorld();
int x1 = this.getLowerX() & ~0xf;
int x2 = this.getUpperX() & ~0xf;
int z1 = this.getLowerZ() & ~0xf;
int z2 = this.getUpperZ() & ~0xf;
for (int x = x1; x <= x2; x += 16) {
for (int z = z1; z <= z2; z += 16) {
res.add(w.getChunkAt(x >> 4, z >> 4));
}
}
return res;
}
public Iterator<Block> iterator() {
return new CuboidIterator(this.getWorld(), this.x1, this.y1, this.z1, this.x2, this.y2, this.z2);
}
@Override
public Cuboid clone() {
return new Cuboid(this);
}
@Override
public String toString() {
return new String("Cuboid: " + this.worldName + "," + this.x1 + "," + this.y1 + "," + this.z1 + "=>" + this.x2 + "," + this.y2 + "," + this.z2);
}
public class CuboidIterator implements Iterator<Block> {
private World w;
private int baseX, baseY, baseZ;
private int x, y, z;
private int sizeX, sizeY, sizeZ;
public CuboidIterator(World w, int x1, int y1, int z1, int x2, int y2, int z2) {
this.w = w;
this.baseX = x1;
this.baseY = y1;
this.baseZ = z1;
this.sizeX = Math.abs(x2 - x1) + 1;
this.sizeY = Math.abs(y2 - y1) + 1;
this.sizeZ = Math.abs(z2 - z1) + 1;
this.x = this.y = this.z = 0;
}
public boolean hasNext() {
return this.x < this.sizeX && this.y < this.sizeY && this.z < this.sizeZ;
}
public Block next() {
Block b = this.w.getBlockAt(this.baseX + this.x, this.baseY + this.y, this.baseZ + this.z);
if (++x >= this.sizeX) {
this.x = 0;
if (++this.y >= this.sizeY) {
this.y = 0;
++this.z;
}
}
return b;
}
public void remove() {
}
}
public enum CuboidDirection {
North, East, South, West, Up, Down, Horizontal, Vertical, Both, Unknown;
public CuboidDirection opposite() {
switch (this) {
case North:
return South;
case East:
return West;
case South:
return North;
case West:
return East;
case Horizontal:
return Vertical;
case Vertical:
return Horizontal;
case Up:
return Down;
case Down:
return Up;
case Both:
return Both;
default:
return Unknown;
}
}
}
}

43
Bunkers/src/main/java/me/redis/bunkers/utils/DateTimeFormats.java Normal file
View File

@ -0,0 +1,43 @@
package me.redis.bunkers.utils;
import net.minecraft.util.org.apache.commons.lang3.time.FastDateFormat;
import java.text.DecimalFormat;
import java.time.ZoneId;
import java.util.Locale;
import java.util.TimeZone;
public final class DateTimeFormats {
private DateTimeFormats() {
}
public static final TimeZone SERVER_TIME_ZONE = TimeZone.getTimeZone("EST");
public static final ZoneId SERVER_ZONE_ID = SERVER_TIME_ZONE.toZoneId();
public static final FastDateFormat DAY_MTH_HR_MIN_SECS = FastDateFormat.getInstance("dd/MM HH:mm:ss", SERVER_TIME_ZONE, Locale.ENGLISH);
public static final FastDateFormat DAY_MTH_YR_HR_MIN_AMPM = FastDateFormat.getInstance("dd/MM/yy hh:mma", SERVER_TIME_ZONE, Locale.ENGLISH);
public static final FastDateFormat DAY_MTH_HR_MIN_AMPM = FastDateFormat.getInstance("dd/MM hh:mma", SERVER_TIME_ZONE, Locale.ENGLISH);
public static final FastDateFormat HR_MIN_AMPM = FastDateFormat.getInstance("hh:mma", SERVER_TIME_ZONE, Locale.ENGLISH);
public static final FastDateFormat HR_MIN_AMPM_TIMEZONE = FastDateFormat.getInstance("hh:mma z", SERVER_TIME_ZONE, Locale.ENGLISH);
public static final FastDateFormat HR_MIN = FastDateFormat.getInstance("hh:mm", SERVER_TIME_ZONE, Locale.ENGLISH);
public static final FastDateFormat MIN_SECS = FastDateFormat.getInstance("mm:ss", SERVER_TIME_ZONE, Locale.ENGLISH);
public static final FastDateFormat KOTH_FORMAT = FastDateFormat.getInstance("m:ss", SERVER_TIME_ZONE, Locale.ENGLISH);
public static final FastDateFormat CONQUEST_FORMAT = FastDateFormat.getInstance("ss", SERVER_TIME_ZONE, Locale.ENGLISH);
// The format used to show one decimal without a trailing zero.
public static final ThreadLocal<DecimalFormat> REMAINING_SECONDS = new ThreadLocal<DecimalFormat>() {
@Override
protected DecimalFormat initialValue() {
return new DecimalFormat("0.#");
}
};
public static final ThreadLocal<DecimalFormat> REMAINING_SECONDS_TRAILING = new ThreadLocal<DecimalFormat>() {
@Override
protected DecimalFormat initialValue() {
return new DecimalFormat("0.0");
}
};
}

26
Bunkers/src/main/java/me/redis/bunkers/utils/DurationFormatter.java Normal file
View File

@ -0,0 +1,26 @@
package me.redis.bunkers.utils;
import org.apache.commons.lang.time.DurationFormatUtils;
import java.util.concurrent.TimeUnit;
public class DurationFormatter {
private static final long MINUTE;
private static final long HOUR;
public static String getRemaining(final long millis, final boolean milliseconds) {
return getRemaining(millis, milliseconds, true);
}
public static String getRemaining(final long duration, final boolean milliseconds, final boolean trail) {
if (milliseconds && duration < DurationFormatter.MINUTE) {
return (trail ? DateTimeFormats.REMAINING_SECONDS_TRAILING : DateTimeFormats.REMAINING_SECONDS).get().format(duration * 0.001) + 's';
}
return DurationFormatUtils.formatDuration(duration, ((duration >= DurationFormatter.HOUR) ? "HH:" : "") + "mm:ss");
}
static {
MINUTE = TimeUnit.MINUTES.toMillis(1L);
HOUR = TimeUnit.HOURS.toMillis(1L);
}
}

7
Bunkers/src/main/java/me/redis/bunkers/utils/EncoderDecoder.java Normal file
View File

@ -0,0 +1,7 @@
package me.redis.bunkers.utils;
public class EncoderDecoder {
public static String decode(String encoded) {
return encoded.replace("$|$", "");
}
}

127
Bunkers/src/main/java/me/redis/bunkers/utils/HiddenStringUtil.java Normal file
View File

@ -0,0 +1,127 @@
package me.redis.bunkers.utils;
import org.bukkit.ChatColor;
import java.nio.charset.Charset;
public class HiddenStringUtil {
private static String SEQUENCE_HEADER = "" + ChatColor.RESET + ChatColor.UNDERLINE + ChatColor.RESET;
private static String SEQUENCE_FOOTER = "" + ChatColor.RESET + ChatColor.ITALIC + ChatColor.RESET;
public static String encodeString(String hiddenString) {
return quote(stringToColors(hiddenString));
}
public static boolean hasHiddenString(String input) {
if (input == null) return false;
return input.indexOf(SEQUENCE_HEADER) > -1 && input.indexOf(SEQUENCE_FOOTER) > -1;
}
public static String extractHiddenString(String input) {
return colorsToString(extract(input));
}
public static String replaceHiddenString(String input, String hiddenString) {
if (input == null) return null;
int start = input.indexOf(SEQUENCE_HEADER);
int end = input.indexOf(SEQUENCE_FOOTER);
if (start < 0 || end < 0) {
return null;
}
return input.substring(0, start + SEQUENCE_HEADER.length()) + stringToColors(hiddenString) + input.substring(end, input.length());
}
/**
* Internal stuff.
*/
private static String quote(String input) {
if (input == null) return null;
return SEQUENCE_HEADER + input + SEQUENCE_FOOTER;
}
private static String extract(String input) {
if (input == null) return null;
int start = input.indexOf(SEQUENCE_HEADER);
int end = input.indexOf(SEQUENCE_FOOTER);
if (start < 0 || end < 0) {
return null;
}
return input.substring(start + SEQUENCE_HEADER.length(), end);
}
private static String stringToColors(String normal) {
if (normal == null) return null;
byte[] bytes = normal.getBytes(Charset.forName("UTF-8"));
char[] chars = new char[bytes.length * 4];
for (int i = 0; i < bytes.length; i++) {
char[] hex = byteToHex(bytes[i]);
chars[i * 4] = ChatColor.COLOR_CHAR;
chars[i * 4 + 1] = hex[0];
chars[i * 4 + 2] = ChatColor.COLOR_CHAR;
chars[i * 4 + 3] = hex[1];
}
return new String(chars);
}
private static String colorsToString(String colors) {
if (colors == null) return null;
colors = colors.toLowerCase().replace("" + ChatColor.COLOR_CHAR, "");
if (colors.length() % 2 != 0) {
colors = colors.substring(0, (colors.length() / 2) * 2);
}
char[] chars = colors.toCharArray();
byte[] bytes = new byte[chars.length / 2];
for (int i = 0; i < chars.length; i += 2) {
bytes[i / 2] = hexToByte(chars[i], chars[i + 1]);
}
return new String(bytes, Charset.forName("UTF-8"));
}
private static int hexToUnsignedInt(char c) {
if (c >= '0' && c <= '9') {
return c - 48;
} else if (c >= 'a' && c <= 'f') {
return c - 87;
} else {
throw new IllegalArgumentException("Invalid hex char: out of range");
}
}
private static char unsignedIntToHex(int i) {
if (i >= 0 && i <= 9) {
return (char) (i + 48);
} else if (i >= 10 && i <= 15) {
return (char) (i + 87);
} else {
throw new IllegalArgumentException("Invalid hex int: out of range");
}
}
private static byte hexToByte(char hex1, char hex0) {
return (byte) (((hexToUnsignedInt(hex1) << 4) | hexToUnsignedInt(hex0)) + Byte.MIN_VALUE);
}
private static char[] byteToHex(byte b) {
int unsignedByte = (int) b - Byte.MIN_VALUE;
return new char[]{unsignedIntToHex((unsignedByte >> 4) & 0xf), unsignedIntToHex(unsignedByte & 0xf)};
}
}

151
Bunkers/src/main/java/me/redis/bunkers/utils/ItemBuilder.java Normal file
View File

@ -0,0 +1,151 @@
package me.redis.bunkers.utils;
import com.google.common.base.Preconditions;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.inventory.meta.PotionMeta;
import org.bukkit.inventory.meta.SkullMeta;
import org.bukkit.material.MaterialData;
import org.bukkit.potion.PotionEffect;
import java.util.ArrayList;
import java.util.List;
public class ItemBuilder {
private final ItemStack itemStack;
public ItemBuilder(ItemStack itemStack) {
this.itemStack = Preconditions.checkNotNull(itemStack, "ItemStack cannot be null").clone();
}
public ItemBuilder(Material material) {
this(material, 1);
}
public ItemBuilder(Material material, int amount) {
this(material, amount, (short) 0);
}
public ItemBuilder(Material material, int amount, short damage) {
this(new ItemStack(material, amount, damage));
}
public ItemBuilder setType(Material material) {
itemStack.setType(material);
return this;
}
public ItemBuilder setAmount(int amount) {
itemStack.setAmount(amount);
return this;
}
public ItemBuilder setDurability(int durability) {
itemStack.setDurability((short) durability);
return this;
}
public ItemBuilder setData(int data) {
itemStack.setData(new MaterialData(itemStack.getType(), (byte) data));
return this;
}
public ItemBuilder addEnchantment(Enchantment enchantment) {
addEnchantment(enchantment, 1);
return this;
}
public ItemBuilder addEnchantment(Enchantment enchantment, int level) {
itemStack.addUnsafeEnchantment(enchantment, level);
return this;
}
public ItemBuilder removeEnchantment(Enchantment enchantment) {
itemStack.removeEnchantment(enchantment);
return this;
}
public ItemBuilder clearEnchantments() {
for (Enchantment enchantment : itemStack.getEnchantments().keySet()) {
itemStack.removeEnchantment(enchantment);
}
return this;
}
public ItemBuilder setUnbreakable(boolean unbreakable) {
ItemMeta itemMeta = itemStack.getItemMeta();
itemMeta.spigot().setUnbreakable(unbreakable);
itemStack.setItemMeta(itemMeta);
return this;
}
public ItemBuilder setDisplayName(String name) {
ItemMeta itemMeta = itemStack.getItemMeta();
itemMeta.setDisplayName(ChatColor.translateAlternateColorCodes('&', name));
itemStack.setItemMeta(itemMeta);
return this;
}
public ItemBuilder addLore(String lore) {
ItemMeta itemMeta = itemStack.getItemMeta();
List<String> lores = itemMeta.getLore();
if (lores == null) {
lores = new ArrayList<>();
}
lores.add(ChatColor.translateAlternateColorCodes('&', lore));
itemMeta.setLore(lores);
itemStack.setItemMeta(itemMeta);
return this;
}
public ItemBuilder setLore(String... lores) {
clearLore();
for (String lore : lores) {
addLore(lore);
}
return this;
}
public ItemBuilder clearLore() {
ItemMeta itemMeta = itemStack.getItemMeta();
itemMeta.setLore(new ArrayList<>());
itemStack.setItemMeta(itemMeta);
return this;
}
public ItemBuilder setPotionEffect(PotionEffect effect) {
PotionMeta potionMeta = (PotionMeta) itemStack.getItemMeta();
potionMeta.setMainEffect(effect.getType());
potionMeta.addCustomEffect(effect, false);
itemStack.setItemMeta(potionMeta);
return this;
}
public ItemBuilder setPotionEffects(PotionEffect... effects) {
PotionMeta potionMeta = (PotionMeta) itemStack.getItemMeta();
potionMeta.setMainEffect(effects[0].getType());
for (PotionEffect effect : effects) {
potionMeta.addCustomEffect(effect, false);
}
itemStack.setItemMeta(potionMeta);
return this;
}
public ItemBuilder setSkullOwner(String owner) {
SkullMeta skullMeta = (SkullMeta) itemStack.getItemMeta();
skullMeta.setOwner(owner);
itemStack.setItemMeta(skullMeta);
return this;
}
public ItemStack create() {
return itemStack;
}
}

163
Bunkers/src/main/java/me/redis/bunkers/utils/JavaUtils.java Normal file
View File

@ -0,0 +1,163 @@
package me.redis.bunkers.utils;
import com.google.common.base.CharMatcher;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import org.apache.commons.lang.StringUtils;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
public class JavaUtils {
private static final CharMatcher CHAR_MATCHER_ASCII = CharMatcher.inRange('0', '9').or(CharMatcher.inRange('a', 'z')).or(CharMatcher.inRange('A', 'Z')).or(CharMatcher.WHITESPACE).precomputed();
private static final Pattern UUID_PATTERN = Pattern.compile("[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[34][0-9a-fA-F]{3}-[89ab][0-9a-fA-F]{3}-[0-9a-fA-F]{12}");
public static boolean isAlphanumeric(String string) {
return CHAR_MATCHER_ASCII.matchesAllOf(string);
}
public static boolean isUUID(String string) {
return UUID_PATTERN.matcher(string).find();
}
public static boolean isInteger(String s) {
try {
Integer.parseInt(s);
} catch(NumberFormatException e) {
return false;
} catch(NullPointerException e) {
return false;
}
// only got here if we didn't return false
return true;
}
public static boolean isBoolean(String s) {
try {
Boolean.parseBoolean(s);
} catch(NumberFormatException e) {
return false;
} catch(NullPointerException e) {
return false;
}
// only got here if we didn't return false
return true;
}
public static boolean containsIgnoreCase(Iterable<? extends String> elements, String string) {
for (String element : elements) {
if (StringUtils.containsIgnoreCase(element, string)) {
return true;
}
}
return false;
}
public static String format(Number number) {
return format(number, 5);
}
public static String format(Number number, int decimalPlaces) {
return format(number, decimalPlaces, RoundingMode.HALF_DOWN);
}
public static String format(Number number, int decimalPlaces, RoundingMode roundingMode) {
Preconditions.checkNotNull(number, "The number cannot be null");
return new BigDecimal(number.toString()).setScale(decimalPlaces, roundingMode).stripTrailingZeros().toPlainString();
}
public static String andJoin(Collection<String> collection, boolean delimiterBeforeAnd) {
return andJoin(collection, delimiterBeforeAnd, ", ");
}
public static String andJoin(Collection<String> collection, boolean delimiterBeforeAnd, String delimiter) {
if (collection == null || collection.isEmpty()) {
return "";
}
List<String> contents = new ArrayList<>(collection);
String last = contents.remove(contents.size() - 1);
StringBuilder builder = new StringBuilder(Joiner.on(delimiter).join(contents));
if (delimiterBeforeAnd) {
builder.append(delimiter);
}
return builder.append(" and ").append(last).toString();
}
public static Integer tryParseInteger(String string) {
try {
return Integer.parseInt(string);
} catch (IllegalArgumentException ignored) {
return null;
}
}
public static Long tryParseLong(String string) {
try {
return Long.parseLong(string);
} catch (IllegalArgumentException ignored) {
return null;
}
}
public static Float tryParseFloat(String string) {
try {
return Float.parseFloat(string);
} catch (IllegalArgumentException ignored) {
return null;
}
}
public static Double tryParseDouble(String string) {
try {
return Double.parseDouble(string);
} catch (IllegalArgumentException ignored) {
return null;
}
}
public static long parseDuration(String string) {
if (string == null || string.isEmpty()) {
return -1L;
}
long result = 0L;
StringBuilder number = new StringBuilder();
for (int i = 0; i < string.length(); i++) {
char c = string.charAt(i);
if (Character.isDigit(c)) {
number.append(c);
} else {
String str;
if (Character.isLetter(c) && !(str = number.toString()).isEmpty()) {
result += convert(Integer.parseInt(str), c);
number = new StringBuilder();
}
}
}
return result;
}
private static long convert(int value, char unit) {
switch (unit) {
case 'y':
return value * TimeUnit.DAYS.toMillis(365L);
case 'M':
return value * TimeUnit.DAYS.toMillis(30L);
case 'd':
return value * TimeUnit.DAYS.toMillis(1L);
case 'h':
return value * TimeUnit.HOURS.toMillis(1L);
case 'm':
return value * TimeUnit.MINUTES.toMillis(1L);
case 's':
return value * TimeUnit.SECONDS.toMillis(1L);
}
return -1L;
}
}

40
Bunkers/src/main/java/me/redis/bunkers/utils/LocationUtils.java Normal file
View File

@ -0,0 +1,40 @@
package me.redis.bunkers.utils;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
public class LocationUtils {
public static String getString(Location loc) {
StringBuilder builder = new StringBuilder();
if (loc == null) return "unset";
builder.append(loc.getX()).append("|");
builder.append(loc.getY()).append("|");
builder.append(loc.getZ()).append("|");
builder.append(loc.getWorld().getName()).append("|");
builder.append(loc.getYaw()).append("|");
builder.append(loc.getPitch());
return builder.toString();
}
public static Location getLocation(String s) {
if (s == null || s.equals("unset") || s.equals("")) return null;
String[] data = s.split("\\|");
double x = Double.parseDouble(data[0]);
double y = Double.parseDouble(data[1]);
double z = Double.parseDouble(data[2]);
World world = Bukkit.getWorld(data[3]);
Float yaw = Float.parseFloat(data[4]);
Float pitch = Float.parseFloat(data[5]);
return new Location(world, x, y, z, yaw, pitch);
}
public static boolean isSameLocation(Location loc1, Location loc2) {
return loc1 != null && loc2 != null && loc1.equals(loc2);
}
}

183
Bunkers/src/main/java/me/redis/bunkers/utils/SerializationUtils.java Normal file
View File

@ -0,0 +1,183 @@
package me.redis.bunkers.utils;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
public class SerializationUtils {
public static String itemStackToString(ItemStack item) {
StringBuilder builder = new StringBuilder();
if (item != null) {
String isType = String.valueOf(item.getType().getId());
builder.append("t@").append(isType);
if (item.getDurability() != 0) {
String isDurability = String.valueOf(item.getDurability());
builder.append(":d@").append(isDurability);
}
if (item.getAmount() != 1) {
String isAmount = String.valueOf(item.getAmount());
builder.append(":a@").append(isAmount);
}
Map<Enchantment, Integer> isEnch = (Map<Enchantment, Integer>) item.getEnchantments();
if (isEnch.size() > 0) {
for (Map.Entry<Enchantment, Integer> ench : isEnch.entrySet()) {
builder.append(":e@").append(ench.getKey().getId()).append("@").append(ench.getValue());
}
}
if (item.hasItemMeta()) {
ItemMeta imeta = item.getItemMeta();
if (imeta.hasDisplayName()) {
builder.append(":dn@").append(imeta.getDisplayName());
}
if (imeta.hasLore()) {
builder.append(":l@").append(imeta.getLore());
}
}
}
return builder.toString();
}
public static ItemStack itemStackFromString(String in) {
ItemStack item = null;
ItemMeta meta = null;
String[] split;
if (in.equals("null")) {
return new ItemStack(Material.AIR);
}
String[] data = split = in.split(":");
for (String itemInfo : split) {
String[] itemAttribute = itemInfo.split("@");
String s2 = itemAttribute[0];
switch (s2) {
case "t": {
item = new ItemStack(Material.getMaterial((int) Integer.valueOf(itemAttribute[1])));
meta = item.getItemMeta();
break;
}
case "d": {
if (item != null) {
item.setDurability((short) Short.valueOf(itemAttribute[1]));
break;
}
break;
}
case "a": {
if (item != null) {
item.setAmount((int) Integer.valueOf(itemAttribute[1]));
break;
}
break;
}
case "e": {
if (item != null) {
item.addEnchantment(Enchantment.getById((int) Integer.valueOf(itemAttribute[1])),
(int) Integer.valueOf(itemAttribute[2]));
break;
}
break;
}
case "dn": {
if (meta != null) {
meta.setDisplayName(itemAttribute[1]);
break;
}
break;
}
case "l": {
itemAttribute[1] = itemAttribute[1].replace("[", "");
itemAttribute[1] = itemAttribute[1].replace("]", "");
List<String> lore = Arrays.asList(itemAttribute[1].split(","));
for (int x = 0; x < lore.size(); ++x) {
String s = lore.get(x);
if (s != null) {
if (s.toCharArray().length != 0) {
if (s.charAt(0) == ' ') {
s = s.replaceFirst(" ", "");
}
lore.set(x, s);
}
}
}
if (meta != null) {
meta.setLore(lore);
break;
}
break;
}
}
}
if (meta != null && (meta.hasDisplayName() || meta.hasLore())) {
item.setItemMeta(meta);
}
return item;
}
public static String playerInventoryToString(PlayerInventory inv) {
StringBuilder builder = new StringBuilder();
ItemStack[] armor = inv.getArmorContents();
for (int i = 0; i < armor.length; i++) {
if (i == 3) {
if (armor[i] == null) {
builder.append(itemStackToString(new ItemStack(Material.AIR)));
} else {
builder.append(itemStackToString(armor[3]));
}
} else {
if (armor[i] == null) {
builder.append(itemStackToString(new ItemStack(Material.AIR))).append(";");
} else {
builder.append(itemStackToString(armor[i])).append(";");
}
}
}
builder.append("|");
for (int i = 0; i < inv.getContents().length; ++i) {
builder.append(i).append("#").append(itemStackToString(inv.getContents()[i]))
.append((i == inv.getContents().length - 1) ? "" : ";");
}
return builder.toString();
}
public static void playerInventoryFromString(String in, Player player) {
if (in == null || in.equals("unset") || in.equals("null") || in.equals("'null'")) return;
String[] data = in.split("\\|");
ItemStack[] armor = new ItemStack[data[0].split(";").length];
for (int i = 0; i < data[0].split(";").length; ++i) {
armor[i] = itemStackFromString(data[0].split(";")[i]);
}
player.getInventory().setArmorContents(armor);
ItemStack[] contents = new ItemStack[data[1].split(";").length];
for (String s : data[1].split(";")) {
int slot = Integer.parseInt(s.split("#")[0]);
if (s.split("#").length == 1) {
contents[slot] = null;
} else {
contents[slot] = itemStackFromString(s.split("#")[1]);
}
}
player.getInventory().setContents(contents);
}
}

86
Bunkers/src/main/java/me/redis/bunkers/utils/TimeUtil.java Normal file
View File

@ -0,0 +1,86 @@
package me.redis.bunkers.utils;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.concurrent.TimeUnit;
public class TimeUtil {
private static DateFormat MATCH_DATE_FORMAT = new SimpleDateFormat("mm:ss");
private static int adjustTime(long timestamp, TimeUnit from, TimeUnit to) {
return (int) to.convert(timestamp, from);
}
public static String formatElapsingNanoseconds(long timestamp) {
timestamp = System.nanoTime() - timestamp;
Calendar cal = Calendar.getInstance();
cal.set(Calendar.SECOND, adjustTime(timestamp, TimeUnit.NANOSECONDS, TimeUnit.SECONDS));
timestamp -= TimeUnit.SECONDS.toNanos(TimeUnit.NANOSECONDS.toSeconds(timestamp));
cal.set(Calendar.MINUTE, adjustTime(timestamp, TimeUnit.NANOSECONDS, TimeUnit.MINUTES));
timestamp -= TimeUnit.MINUTES.toNanos(TimeUnit.NANOSECONDS.toMinutes(timestamp));
cal.set(Calendar.HOUR_OF_DAY, adjustTime(timestamp, TimeUnit.NANOSECONDS, TimeUnit.HOURS));
return MATCH_DATE_FORMAT.format(cal.getTime());
}
public static String formatSeconds(int seconds) {
int minutes = seconds / 60;
if (minutes == 0) {
return seconds + " seconds";
}
seconds %= 60;
return minutes + " minutes and " + seconds + " seconds";
}
public static long parseDuration(String string) {
if (string == null || string.isEmpty()) {
return -1L;
}
long result = 0L;
StringBuilder number = new StringBuilder();
for (int i = 0; i < string.length(); i++) {
char c = string.charAt(i);
if (Character.isDigit(c)) {
number.append(c);
} else {
String str;
if (Character.isLetter(c) && !(str = number.toString()).isEmpty()) {
result += convert(Integer.parseInt(str), c);
number = new StringBuilder();
}
}
}
return result;
}
private static long convert(int value, char unit) {
switch (unit) {
case 'y':
return value * TimeUnit.DAYS.toMillis(365L);
case 'M':
return value * TimeUnit.DAYS.toMillis(30L);
case 'd':
return value * TimeUnit.DAYS.toMillis(1L);
case 'h':
return value * TimeUnit.HOURS.toMillis(1L);
case 'm':
return value * TimeUnit.MINUTES.toMillis(1L);
case 's':
return value * TimeUnit.SECONDS.toMillis(1L);
}
return -1L;
}
}

50
Bunkers/src/main/java/me/redis/bunkers/utils/command/CommandArgument.java Normal file
View File

@ -0,0 +1,50 @@
package me.redis.bunkers.utils.command;
import lombok.Getter;
import lombok.Setter;
import org.apache.commons.lang.ArrayUtils;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.PluginCommand;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@Getter
public abstract class CommandArgument {
private String name;
private String description;
@Setter private boolean requiresPermission;
private String[] aliases;
public CommandArgument(String name) {
this(name, null);
}
public CommandArgument(String name, String description) {
this(name, description, ArrayUtils.EMPTY_STRING_ARRAY);
}
public CommandArgument(String name, String description, String... aliases) {
this.name = name;
this.description = description;
this.aliases = Arrays.copyOf(aliases, aliases.length);
}
public String getPermission(PluginCommand command) {
return requiresPermission ? (command.getPermission() == null ? command.getPlugin().getName() + ".command." + command.getName() + ".argument." + name : command.getPermission() + ".argument." + name) : null;
}
public abstract String getUsage(String label);
public abstract boolean onCommand(CommandSender sender , Command command, String label, String[] args);
public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
return Collections.emptyList();
}
}

80
Bunkers/src/main/java/me/redis/bunkers/utils/command/CommandRegistrer.java Normal file
View File

@ -0,0 +1,80 @@
package me.redis.bunkers.utils.command;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.information.commands.InformationCommand;
import me.redis.bunkers.team.commands.TeamCommand;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandMap;
import org.bukkit.command.PluginCommand;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.SimplePluginManager;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.Arrays;
public class CommandRegistrer {
private CommandMap commandMap;
public CommandRegistrer() {
registerCommand(new TeamCommand(), Bunkers.getPlugin(), false);
registerCommand(new InformationCommand(), Bunkers.getPlugin(), true);
}
public CommandMap getCommandMap() {
if (commandMap != null) {
return commandMap;
}
try {
Field field = SimplePluginManager.class.getDeclaredField("commandMap");
field.setAccessible(true);
commandMap = (CommandMap) field.get(Bukkit.getPluginManager());
} catch (Exception exception) {
exception.printStackTrace();
}
return commandMap;
}
public PluginCommand getCommand(String name, Plugin owner) {
PluginCommand command = null;
try {
Constructor<PluginCommand> constructor = PluginCommand.class.getDeclaredConstructor(String.class, Plugin.class);
constructor.setAccessible(true);
command = constructor.newInstance(name, owner);
} catch (Exception exception) {
exception.printStackTrace();
}
return command;
}
public void registerCommand(ExecutableCommand executableCommand, Plugin owner, boolean requiresPermission) {
PluginCommand command = getCommand(executableCommand.getName(), owner);
command.setPermissionMessage(ChatColor.RED + "You do not have permission to execute this command.");
if (requiresPermission) {
command.setPermission((owner.getName() + ".command." + executableCommand.getName()).toLowerCase());
}
if (executableCommand.getDescription() != null) {
command.setDescription(executableCommand.getDescription());
}
command.setAliases(Arrays.asList(executableCommand.getAliases()));
command.setExecutor(executableCommand);
command.setTabCompleter(executableCommand);
if (!getCommandMap().register(executableCommand.getName(), command)) {
command.unregister(getCommandMap());
getCommandMap().register(executableCommand.getName(), command);
}
}
}

133
Bunkers/src/main/java/me/redis/bunkers/utils/command/ExecutableCommand.java Normal file
View File

@ -0,0 +1,133 @@
package me.redis.bunkers.utils.command;
import com.google.common.collect.ImmutableList;
import lombok.Getter;
import me.redis.bunkers.utils.BukkitUtils;
import net.md_5.bungee.api.chat.ComponentBuilder;
import net.md_5.bungee.api.chat.HoverEvent;
import net.md_5.bungee.api.chat.TextComponent;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.WordUtils;
import org.bukkit.ChatColor;
import org.bukkit.command.*;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
@Getter
public abstract class ExecutableCommand implements CommandExecutor, TabCompleter {
private final String name;
private String description;
private String[] aliases;
private final List<CommandArgument> arguments = new ArrayList<>();
public ExecutableCommand(String name) {
this(name, null);
}
public ExecutableCommand(String name, String description) {
this(name, description, ArrayUtils.EMPTY_STRING_ARRAY);
}
public ExecutableCommand(String name, String description, String... aliases) {
this.name = name;
this.description = description;
this.aliases = Arrays.copyOf(aliases, aliases.length);
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
if (args.length == 0) {
sender.sendMessage(ChatColor.RED + "Available sub-command(s) for '" + label + "' are " + ChatColor.GRAY +
arguments.stream().filter(argument -> {
String permission = argument.getPermission((PluginCommand) command);
return permission == null || sender.hasPermission(permission);
}
).map(CommandArgument::getName).collect(Collectors.joining(ChatColor.GRAY + ", ")) + ChatColor.RED + ".");
sender.sendMessage(ChatColor.RED + "You must specify a sub-command.");
return true;
}
CommandArgument argument = getArgument(args[0]);
String permission = argument == null ? null : argument.getPermission((PluginCommand) command);
if (argument == null || permission != null && !sender.hasPermission(permission)) {
sender.sendMessage(ChatColor.RED + WordUtils.capitalizeFully(name) + " sub-command '" + args[0] + "' not found.");
} else {
argument.onCommand(sender, command, label, args);
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
List<String> results = new ArrayList<>();
if (args.length < 2) {
for (CommandArgument argument : arguments) {
String permission = argument.getPermission((PluginCommand) command);
if (permission == null || sender.hasPermission(permission)) {
results.add(argument.getName());
}
}
if (results.isEmpty()) {
return null;
}
} else {
CommandArgument argument = getArgument(args[0]);
if (argument == null) {
return results;
}
String permission = argument.getPermission((PluginCommand) command);
if (permission == null || sender.hasPermission(permission)) {
results = argument.onTabComplete(sender, command, label, args);
if (results == null) {
return null;
}
}
}
return BukkitUtils.getCompletions(args, results);
}
public List<CommandArgument> getArguments() {
return ImmutableList.copyOf(arguments);
}
public void addArgument(CommandArgument argument) {
arguments.add(argument);
}
public void removeArgument(CommandArgument argument) {
arguments.remove(argument);
}
public CommandArgument getArgument(String name) {
return arguments.stream().filter(argument -> argument.getName().equalsIgnoreCase(name) || Arrays.asList(argument.getAliases()).contains(name.toLowerCase())).findFirst().orElse(null);
}
public void sendUsage(CommandSender sender, String usage) {
ComponentBuilder builder = new ComponentBuilder("Usage: /" + usage);
builder.color(net.md_5.bungee.api.ChatColor.RED);
if (description != null && !description.isEmpty()) {
builder.event(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ComponentBuilder(description).color(net.md_5.bungee.api.ChatColor.YELLOW).create()));
}
if (sender instanceof Player) {
((Player) sender).spigot().sendMessage(builder.create());
} else {
sender.sendMessage(TextComponent.toPlainText(builder.create()));
}
}
}

30
Bunkers/src/main/java/me/redis/bunkers/wand/Wand.java Normal file
View File

@ -0,0 +1,30 @@
package me.redis.bunkers.wand;
import lombok.Getter;
import lombok.Setter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.utils.ItemBuilder;
import org.bukkit.Bukkit;
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.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
@Getter
public class Wand {
@Setter private Location firstLocation;
@Setter private Location secondLocation;
public Wand(Player player) {
if (Bunkers.getPlugin().getWandManager().getWand(player) != null) {
player.getInventory().addItem(new ItemBuilder(Material.GOLD_HOE).setDisplayName("&6Area wand").create());
} else {
player.getInventory().addItem(new ItemBuilder(Material.GOLD_HOE).setDisplayName("&6Area wand").create());
Bunkers.getPlugin().getWandManager().getWands().put(player, this);
}
}
}

81
Bunkers/src/main/java/me/redis/bunkers/wand/WandManager.java Normal file
View File

@ -0,0 +1,81 @@
package me.redis.bunkers.wand;
import lombok.Getter;
import me.redis.bunkers.Bunkers;
import me.redis.bunkers.profiles.Profile;
import me.redis.bunkers.protocol.ClaimPillar;
import me.redis.bunkers.utils.ItemBuilder;
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.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import java.util.HashMap;
import java.util.Map;
public class WandManager implements Listener {
@Getter private Map<Player, Wand> wands = new HashMap<>();
private ItemStack wand = new ItemBuilder(Material.GOLD_HOE).setDisplayName("&6Area wand").create();
public WandManager() {
Bukkit.getPluginManager().registerEvents(this, Bunkers.getPlugin());
}
public Wand getWand(Player player) {
return wands.get(player);
}
@EventHandler
public void onClick(PlayerInteractEvent event) {
Player player = event.getPlayer();
Action action = event.getAction();
Profile profile = Bunkers.getPlugin().getProfileManager().getProfile(player);
if (getWand(player) != null && event.getPlayer().getItemInHand() != null && event.getPlayer().getItemInHand().isSimilar(wand)) {
if (action == Action.LEFT_CLICK_BLOCK) {
getWand(player).setFirstLocation(event.getClickedBlock().getLocation());
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have selected '&7" + getWand(player).getFirstLocation().getBlockX() + ", " + getWand(player).getFirstLocation().getBlockY() + ", " + getWand(player).getFirstLocation().getBlockZ() + "&e' as your first location."));
if (profile.getFirstPillar() != null) {
profile.getFirstPillar().removePillar();
profile.setFirstPillar(null);
}
ClaimPillar pillar = new ClaimPillar(player, Material.ENDER_STONE, (byte) 0, event.getClickedBlock().getLocation());
pillar.sendPillar();
profile.setFirstPillar(pillar);
event.setCancelled(true);
} else if (action == Action.RIGHT_CLICK_BLOCK) {
getWand(player).setSecondLocation(event.getClickedBlock().getLocation());
player.sendMessage(ChatColor.translateAlternateColorCodes('&', "&eYou have selected '&7" + getWand(player).getSecondLocation().getBlockX() + ", " + getWand(player).getSecondLocation().getBlockY() + ", " + getWand(player).getSecondLocation().getBlockZ() + "&e' as your second location."));
if (profile.getSecondPillar() != null) {
profile.getSecondPillar().removePillar();
profile.setSecondPillar(null);
}
ClaimPillar pillar = new ClaimPillar(player, Material.ENDER_STONE, (byte) 0, event.getClickedBlock().getLocation());
pillar.sendPillar();
profile.setSecondPillar(pillar);
event.setCancelled(true);
}
}
}
@EventHandler
public void onCommand(PlayerCommandPreprocessEvent event) {
if (event.getMessage().equalsIgnoreCase("/wand")) {
new Wand(event.getPlayer());
event.getPlayer().sendMessage(ChatColor.YELLOW + "You have been given a wand.");
event.setCancelled(true);
}
}
}

11
Bunkers/src/main/resources/config.yml Normal file
View File

@ -0,0 +1,11 @@
####################
DATABASE:
AUTH:
HOST: "127.0.0.1"
PORT: 27017
NAME: "Bunkers"
COLLECTIONS:
INFORMATION: "Information"
TEAMS: "Teams"
PROFILES: "Profiles"
####################

3
Bunkers/src/main/resources/plugin.yml Normal file
View File

@ -0,0 +1,3 @@
name: Bunkers
main: me.redis.bunkers.Bunkers
version: 1.0

73
FreeForAll/pom.xml Normal file
View File

@ -0,0 +1,73 @@
<?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">
<modelVersion>4.0.0</modelVersion>
<groupId>me.javaee.ffa</groupId>
<artifactId>FreeForAll</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<!--
<dependency>
<groupId>spigot</groupId>
<artifactId>spigot</artifactId>
<version>3.4.0</version>
<scope>system</scope>
<systemPath>${basedir}/spigot-1.8.8-R0.1-SNAPSHOT.jar</systemPath>
</dependency>
<dependency>
<groupId>org.github.paperspigot</groupId>
<artifactId>paperspigot-api</artifactId>
<version>1.7.10-R0.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.github.paperspigot</groupId>
<artifactId>paperspigot</artifactId>
<version>1.7.10-R0.1-SNAPSHOT</version>
</dependency>
-->
<dependency>
<groupId>net.techcable.tacospigot</groupId>
<artifactId>api</artifactId>
<version>1.8.8-R0.2-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>net.techcable.tacospigot</groupId>
<artifactId>server</artifactId>
<version>1.8.8-R0.2-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.comphenix.protocol</groupId>
<artifactId>ProtocolLib</artifactId>
<version>4.4.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.2</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.18</version>
</dependency>
</dependencies>
</project>

243
FreeForAll/src/main/java/com/bizarrealex/aether/Aether.java Normal file
View File

@ -0,0 +1,243 @@
package com.bizarrealex.aether;
import me.javaee.ffa.events.BoardCreateEvent;
import com.bizarrealex.aether.scoreboard.Board;
import com.bizarrealex.aether.scoreboard.BoardAdapter;
import com.bizarrealex.aether.scoreboard.BoardEntry;
import lombok.Getter;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scoreboard.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import static com.bizarrealex.aether.AetherOptions.defaultOptions;
/**
* TODO: Add documentation to methods, etc
* TODO: Fix inconsistent cooldown scores
* TODO: Finish other board formats
*/
public class Aether implements Listener {
@Getter private JavaPlugin plugin;
@Getter private AetherOptions options;
@Getter BoardAdapter adapter;
public Aether(JavaPlugin plugin, BoardAdapter adapter, AetherOptions options) {
this.options = options;
this.plugin = plugin;
Bukkit.getPluginManager().registerEvents(this, plugin);
setAdapter(adapter);
run();
}
public Aether(JavaPlugin plugin, BoardAdapter adapter) {
this(plugin, adapter, defaultOptions());
}
public Aether(JavaPlugin plugin) {
this(plugin, null, defaultOptions());
}
private void run() {
new BukkitRunnable() {
public void run() {
if (adapter == null) return;
for (Player player : Bukkit.getOnlinePlayers()) {
Board board = Board.getByPlayer(player);
if (board != null) {
List<String> scores = adapter.getScoreboard(player, board, board.getCooldowns());
List<String> translatedScores = new ArrayList<>();
if (scores == null) {
if (!board.getEntries().isEmpty()) {
for (BoardEntry boardEntry : board.getEntries()) {
boardEntry.remove();
}
board.getEntries().clear();
}
continue;
}
for (String line : scores) {
translatedScores.add(ChatColor.translateAlternateColorCodes('&', line));
}
if (!options.scoreDirectionDown()) {
Collections.reverse(scores);
}
Scoreboard scoreboard = board.getScoreboard();
Objective objective = board.getObjective();
if (!(objective.getDisplayName().equals(adapter.getTitle(player)))) {
objective.setDisplayName(ChatColor.translateAlternateColorCodes('&', adapter.getTitle(player)));
}
outer:
for (int i = 0; i < scores.size(); i++) {
String text = scores.get(i);
int position;
if (options.scoreDirectionDown()) {
position = 15 - i;
} else {
position = i + 1;
}
Iterator<BoardEntry> iterator = new ArrayList<>(board.getEntries()).iterator();
while (iterator.hasNext()) {
BoardEntry boardEntry = iterator.next();
Score score = objective.getScore(boardEntry.getKey());
if (score != null && boardEntry.getText().equals(ChatColor.translateAlternateColorCodes('&', text))) {
if (score.getScore() == position) {
continue outer;
}
}
}
int positionToSearch = options.scoreDirectionDown() ? 15 - position : position - 1;
iterator = board.getEntries().iterator();
while (iterator.hasNext()) {
BoardEntry boardEntry = iterator.next();
int entryPosition = scoreboard.getObjective(DisplaySlot.SIDEBAR).getScore(boardEntry.getKey()).getScore();
if (!options.scoreDirectionDown()) {
if (entryPosition > scores.size()) {
iterator.remove();
boardEntry.remove();
}
}
}
BoardEntry entry = board.getByPosition(positionToSearch);
if (entry == null) {
new BoardEntry(board, text).send(position);
} else {
entry.setText(text).setup().send(position);
}
if (board.getEntries().size() > scores.size()) {
iterator = board.getEntries().iterator();
while (iterator.hasNext()) {
BoardEntry boardEntry = iterator.next();
if ((!translatedScores.contains(boardEntry.getText())) || Collections.frequency(board.getBoardEntriesFormatted(), boardEntry.getText()) > 1) {
iterator.remove();
boardEntry.remove();
}
}
}
}
player.setScoreboard(scoreboard);
updateTablist(player);
}
}
}
}.runTaskTimerAsynchronously(plugin, 20L, 3L);
}
public void setAdapter(BoardAdapter adapter) {
this.adapter = adapter;
for (Player player : Bukkit.getOnlinePlayers()) {
Board board = Board.getByPlayer(player);
if (board != null) {
Board.getBoards().remove(board);
}
Bukkit.getPluginManager().callEvent(new BoardCreateEvent(new Board(player, this, options), player));
}
}
@EventHandler
public void onPlayerJoinEvent(PlayerJoinEvent event) {
if (Board.getByPlayer(event.getPlayer()) == null) {
Bukkit.getPluginManager().callEvent(new BoardCreateEvent(new Board(event.getPlayer(), this, options), event.getPlayer()));
}
event.getPlayer().setMaximumNoDamageTicks(19);
setHealthAndList(event.getPlayer());
}
private static Team getExistingOrCreateNewTeam(String string, Scoreboard scoreboard, ChatColor prefix) {
Team toReturn = scoreboard.getTeam(string);
if (toReturn == null) {
toReturn = scoreboard.registerNewTeam(string);
toReturn.setPrefix(prefix + "");
}
return toReturn;
}
private static void updateTablist(Player target) {
Team enemy = getExistingOrCreateNewTeam("enemy", Board.getByPlayer(target).getScoreboard(), ChatColor.RED);
Team nigger = getExistingOrCreateNewTeam("nigger", Board.getByPlayer(target).getScoreboard(), ChatColor.LIGHT_PURPLE);
nigger.setPrefix(ChatColor.LIGHT_PURPLE + "✶ ");
Team donator = getExistingOrCreateNewTeam("donator", Board.getByPlayer(target).getScoreboard(), ChatColor.GOLD);
for (Player online : Bukkit.getOnlinePlayers()) {
if (online.hasPermission("group.owner") || online.hasPermission("group.developer") || online.getName().equalsIgnoreCase("JavaEE")) {
if (!(nigger.hasEntry(online.getName()))) {
nigger.addEntry(online.getName());
}
} else if (online.hasPermission("batman.rank.donator")) {
if (!(donator.hasEntry(online.getName()))) {
donator.addEntry(online.getName());
}
} else {
if (!(enemy.hasEntry(online.getName()))) {
enemy.addEntry(online.getName());
}
}
}
}
public void setHealthAndList(Player player) {
if (Board.getByPlayer(player).getScoreboard() != null) {
Scoreboard scoreboard = Board.getByPlayer(player).getScoreboard();
if (scoreboard.getObjective("namehealth") == null) {
scoreboard.registerNewObjective("namehealth", "health");
}
Objective objective = scoreboard.getObjective("namehealth");
objective.setDisplaySlot(DisplaySlot.BELOW_NAME);
objective.setDisplayName(ChatColor.DARK_RED + " ❤");
}
}
@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerQuitEvent(PlayerQuitEvent event) {
Board board = Board.getByPlayer(event.getPlayer());
if (board != null) {
Board.getBoards().remove(board);
}
}
}

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