JarvisBigBalls
/
Mineplex2018-withcommit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merging issues

This commit is contained in:
LCastr0 2017-03-06 17:10:29 -03:00
parent 3cc304d99c d072fc3c21
commit ec5de0ef12
157 changed files with 12358 additions and 1403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
Plugins/Mineplex.Bungee.Mineplexer/src/mineplex/bungee/lobbyBalancer/LobbyBalancer.java
View File

@ -2,33 +2,34 @@ package mineplex.bungee.lobbyBalancer;
import java.io.File;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import mineplex.serverdata.Region;
import mineplex.serverdata.data.MinecraftServer;
import mineplex.serverdata.servers.ServerManager;
import mineplex.serverdata.servers.ServerRepository;
import net.md_5.bungee.api.event.ServerConnectEvent;
import net.md_5.bungee.api.plugin.Listener;
import net.md_5.bungee.api.plugin.Plugin;
import net.md_5.bungee.event.EventHandler;
import com.google.common.collect.Lists;
import mineplex.serverdata.Region;
import mineplex.serverdata.data.MinecraftServer;
import mineplex.serverdata.servers.ServerManager;
import mineplex.serverdata.servers.ServerRepository;
public class LobbyBalancer implements Listener, Runnable
{
private Plugin _plugin;
private ServerRepository _repository;
private List<MinecraftServer> _sortedLobbies = Lists.newArrayList();
private List<MinecraftServer> _sortedClans = Lists.newArrayList();
private static Object _serverLock = new Object();
private int _lobbyIndex = 0;
private int _clansIndex = 0;
private final Map<LobbyType, List<MinecraftServer>> _sortedLobbyMap = new EnumMap<>(LobbyType.class);
private final Map<LobbyType, Integer> _nextIndexMap = new EnumMap<>(LobbyType.class);
private static final LobbySorter LOBBY_SORTER = new LobbySorter();
private static final Object _serverLock = new Object();
public LobbyBalancer(Plugin plugin)
{
@ -46,45 +47,42 @@ public class LobbyBalancer implements Listener, Runnable
@EventHandler
public void playerConnect(ServerConnectEvent event)
{
if (event.getTarget().getName().equalsIgnoreCase("Lobby"))
{
synchronized (_serverLock)
{
if (_lobbyIndex >= _sortedLobbies.size() || _sortedLobbies.get(_lobbyIndex).getPlayerCount() >= _sortedLobbies.get(_lobbyIndex).getMaxPlayerCount())
_lobbyIndex = 0;
Arrays.stream(LobbyType.values())
.filter(type -> type.getConnectName().equalsIgnoreCase(event.getTarget().getName()))
.findFirst()
.ifPresent(lobbyType ->
{
synchronized (_serverLock)
{
List<MinecraftServer> lobbies = _sortedLobbyMap.get(lobbyType);
event.setTarget(_plugin.getProxy().getServerInfo(_sortedLobbies.get(_lobbyIndex).getName()));
_sortedLobbies.get(_lobbyIndex).incrementPlayerCount(1);
System.out.println("Sending " + event.getPlayer().getName() + " to " + _sortedLobbies.get(_lobbyIndex).getName() + "(" + _sortedLobbies.get(_lobbyIndex).getPublicAddress() + ")");
_lobbyIndex++;
}
}
if (event.getTarget().getName().equalsIgnoreCase("ClansHub"))
{
synchronized (_serverLock)
{
if (_clansIndex >= _sortedClans.size() || _sortedClans.get(_clansIndex).getPlayerCount() >= _sortedClans.get(_clansIndex).getMaxPlayerCount())
_clansIndex = 0;
int nextIndex = _nextIndexMap.getOrDefault(lobbyType, 0);
if (nextIndex >= lobbies.size())
{
nextIndex = 0;
}
event.setTarget(_plugin.getProxy().getServerInfo(_sortedClans.get(_clansIndex).getName()));
_sortedClans.get(_clansIndex).incrementPlayerCount(1);
System.out.println("Sending " + event.getPlayer().getName() + " to " + _sortedClans.get(_clansIndex).getName() + "(" + _sortedClans.get(_clansIndex).getPublicAddress() + ")");
_clansIndex++;
}
}
MinecraftServer server = lobbies.get(nextIndex);
event.setTarget(_plugin.getProxy().getServerInfo(server.getName()));
server.incrementPlayerCount(1);
System.out.println("Sending " + event.getPlayer().getName() + " to " + server.getName() + "(" + server.getPublicAddress() + ")");
_nextIndexMap.put(lobbyType, ++nextIndex);
}
});
}
public void run()
{
loadServers();
if (!_plugin.getProxy().getServers().containsKey("ClansHub"))
for (LobbyType type : LobbyType.values())
{
_plugin.getProxy().getServers().put("ClansHub", _plugin.getProxy().constructServerInfo("ClansHub", new InetSocketAddress("lobby.mineplex.com", 25565), "LobbyBalancer", false));
}
if (!_plugin.getProxy().getServers().containsKey("Lobby"))
{
_plugin.getProxy().getServers().put("Lobby", _plugin.getProxy().constructServerInfo("Lobby", new InetSocketAddress("lobby.mineplex.com", 25565), "LobbyBalancer", false));
if (!_plugin.getProxy().getServers().containsKey(type.getConnectName()))
{
_plugin.getProxy().getServers().put(type.getConnectName(), _plugin.getProxy().constructServerInfo(type.getConnectName(), new InetSocketAddress("lobby.mineplex.com", 25565), "LobbyBalancer", false));
}
}
}
@ -95,9 +93,12 @@ public class LobbyBalancer implements Listener, Runnable
synchronized (_serverLock)
{
long startTime = System.currentTimeMillis();
_sortedLobbies.clear();
_sortedClans.clear();
_sortedLobbyMap.clear();
for (LobbyType type : LobbyType.values())
{
_sortedLobbyMap.put(type, new ArrayList<>());
}
for (MinecraftServer server : servers)
{
if (server.getName() == null)
@ -105,32 +106,26 @@ public class LobbyBalancer implements Listener, Runnable
InetSocketAddress socketAddress = new InetSocketAddress(server.getPublicAddress(), server.getPort());
_plugin.getProxy().getServers().put(server.getName(), _plugin.getProxy().constructServerInfo(server.getName(), socketAddress, "LobbyBalancer", false));
if (server.getName().toUpperCase().startsWith("LOBBY-"))
{
if (server.getMotd() == null || !server.getMotd().contains("Restarting"))
{
_sortedLobbies.add(server);
}
}
if (server.getName().toUpperCase().startsWith("CLANSHUB-"))
{
if (server.getMotd() == null || !server.getMotd().contains("Restarting"))
{
_sortedClans.add(server);
}
}
if (server.getMotd() != null && server.getMotd().contains("Restarting"))
{
continue;
}
Arrays.stream(LobbyType.values())
.filter(type -> server.getName().toUpperCase().startsWith(type.getUppercasePrefix()))
.findFirst()
.ifPresent(type -> _sortedLobbyMap.get(type).add(server));
}
Collections.sort(_sortedLobbies, new LobbySorter());
Collections.sort(_sortedClans, new LobbySorter());
_sortedLobbyMap.values().forEach(lobbies -> Collections.sort(lobbies, LOBBY_SORTER));
long timeSpentInLock = System.currentTimeMillis() - startTime;
if (timeSpentInLock > 50)
System.out.println("[==] TIMING [==] Locked loading servers for " + timeSpentInLock + "ms");
_lobbyIndex = 0;
_nextIndexMap.clear();
}
}
}

34
Plugins/Mineplex.Bungee.Mineplexer/src/mineplex/bungee/lobbyBalancer/LobbyType.java Normal file
View File

@ -0,0 +1,34 @@
package mineplex.bungee.lobbyBalancer;
public enum LobbyType
{
NORMAL("Lobby", "LOBBY-", "MainMotd"),
CLANS("ClansHub", "CLANSHUB-", "ClansMotd"),
BETA("BetaHub","BETAHUB-", "BetaMotd"),
;
private final String _connectName; // The name of the server the player is connecting to
private final String _uppercasePrefix; // The (toUpperCase()) prefix given to servers of this lobby type
private final String _redisMotdKey;
LobbyType(String connectName, String uppercasePrefix, String redisMotdKey)
{
_connectName = connectName;
_uppercasePrefix = uppercasePrefix;
_redisMotdKey = redisMotdKey;
}
public String getConnectName()
{
return _connectName;
}
public String getUppercasePrefix()
{
return _uppercasePrefix;
}
public String getRedisMotdKey()
{
return _redisMotdKey;
}
}

130
Plugins/Mineplex.Bungee.Mineplexer/src/mineplex/bungee/motd/MotdManager.java
View File

@ -1,138 +1,82 @@
package mineplex.bungee.motd;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.EnumMap;
import java.util.Map;
import java.util.Optional;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import mineplex.serverdata.Region;
import mineplex.serverdata.data.DataRepository;
import mineplex.serverdata.redis.RedisDataRepository;
import mineplex.serverdata.servers.ConnectionData;
import mineplex.serverdata.servers.ConnectionData.ConnectionType;
import mineplex.serverdata.servers.ServerManager;
import net.md_5.bungee.api.event.ProxyPingEvent;
import net.md_5.bungee.api.plugin.Listener;
import net.md_5.bungee.api.plugin.Plugin;
import net.md_5.bungee.event.EventHandler;
import mineplex.bungee.lobbyBalancer.LobbyType;
import mineplex.serverdata.Region;
import mineplex.serverdata.data.DataRepository;
import mineplex.serverdata.redis.RedisDataRepository;
import mineplex.serverdata.servers.ServerManager;
public class MotdManager implements Listener, Runnable
{
private Plugin _plugin;
private DataRepository<GlobalMotd> _repository;
private DataRepository<GlobalMotd> _secondRepository;
private Region _region;
private Random _random = new Random();
private String _firstLine = " §b§l§m §8§l§m[ §r §9§lMineplex§r §f§lGames§r §8§l§m ]§b§l§m §r";
private List<String> _motdLines;
private String _firstCLine = " §b§l§m §8§l§m[ §r §9§lMineplex§r §f§lGames§r §8§l§m ]§b§l§m §r";
private List<String> _motdCLines;
private static final String DEFAULT_HEADLINE = " §b§l§m §8§l§m[ §r §9§lMineplex§r §f§lGames§r §8§l§m ]§b§l§m §r";
private final DataRepository<GlobalMotd> _repository;
private final Random _random = new Random();
private final Map<LobbyType, GlobalMotd> motds = new EnumMap<>(LobbyType.class);
public MotdManager(Plugin plugin)
{
_plugin = plugin;
_region = !new File("eu.dat").exists() ? Region.US : Region.EU;
_plugin.getProxy().getScheduler().schedule(_plugin, this, 5L, 30L, TimeUnit.SECONDS);
_plugin.getProxy().getPluginManager().registerListener(_plugin, this);
plugin.getProxy().getScheduler().schedule(plugin, this, 5L, 30L, TimeUnit.SECONDS);
plugin.getProxy().getPluginManager().registerListener(plugin, this);
_repository = new RedisDataRepository<GlobalMotd>(ServerManager.getConnection(true, ServerManager.SERVER_STATUS_LABEL), ServerManager.getConnection(false, ServerManager.SERVER_STATUS_LABEL),
Region.ALL, GlobalMotd.class, "globalMotd");
run();
if (new File("updateMOTD.dat").exists())
{
if (_region == Region.US)
_secondRepository = new RedisDataRepository<GlobalMotd>(new ConnectionData("10.81.1.156", 6379, ConnectionType.MASTER, "ServerStatus"), new ConnectionData("10.81.1.156", 6377, ConnectionType.SLAVE, "ServerStatus"),
Region.ALL, GlobalMotd.class, "globalMotd");
else
_secondRepository = new RedisDataRepository<GlobalMotd>(new ConnectionData("10.33.53.16", 6379, ConnectionType.MASTER, "ServerStatus"), new ConnectionData("10.33.53.16", 6377, ConnectionType.SLAVE, "ServerStatus"),
Region.ALL, GlobalMotd.class, "globalMotd");
//String motdLine = "§f§l◄ §c§lMaintenance§f§l ►";
//String motdLine = "§f§l◄ §a§lCarl the Creeper§f§l ►";
// String motdLine = " §2§l§n M O N S T E R M A Z E B E T A §f";
String motdLine = " §f> §4§lCLANS BETA §f- §c§lOpen to Everyone §f<";
// String motdLine = " §f❄ §2§lServer Maintenance §f❄ §2§lBe Back Soon §f❄";
//String motdLine = " §d§lRank Sale §a§l40% Off");
//String motdLine = " §f§l◄§c§lMAINTENANCE§f§l►");
updateMainMotd(" §f§m §8§l§m[ §r §9§lMineplex§r §f§lGames§r §8§l§m ]§f§m §r", motdLine);
System.out.println("Updated Bungee MOTD");
}
}
@EventHandler
public void serverPing(ProxyPingEvent event)
{
net.md_5.bungee.api.ServerPing serverPing = event.getResponse();
if (event.getConnection().getListener() != null && event.getConnection().getListener().getDefaultServer().equalsIgnoreCase("ClansHub"))
Optional<LobbyType> maybeType = Optional.empty();
if (event.getConnection().getListener() != null)
{
String motd = _firstCLine;
if (_motdCLines != null && _motdCLines.size() > 0)
{
motd += "\n" + _motdCLines.get(_random.nextInt(_motdCLines.size()));
}
event.setResponse(new net.md_5.bungee.api.ServerPing(serverPing.getVersion(), serverPing.getPlayers(), motd, serverPing.getFaviconObject()));
maybeType = Arrays.stream(LobbyType.values())
.filter(type -> event.getConnection().getListener().getDefaultServer().equalsIgnoreCase(type.getConnectName()))
.findFirst();
}
else
LobbyType lobbyType = maybeType.orElse(LobbyType.NORMAL);
GlobalMotd globalMotd = motds.get(lobbyType);
String motd = DEFAULT_HEADLINE;
if (globalMotd != null && globalMotd.getHeadline() != null)
{
String motd = _firstLine;
if (_motdLines != null && _motdLines.size() > 0)
motd = globalMotd.getHeadline() == null ? DEFAULT_HEADLINE : globalMotd.getHeadline();
if (globalMotd.getMotd() != null)
{
motd += "\n" + _motdLines.get(_random.nextInt(_motdLines.size()));
motd += "\n" + globalMotd.getMotd().get(_random.nextInt(globalMotd.getMotd().size()));
}
event.setResponse(new net.md_5.bungee.api.ServerPing(serverPing.getVersion(), serverPing.getPlayers(), motd, serverPing.getFaviconObject()));
}
event.setResponse(new net.md_5.bungee.api.ServerPing(serverPing.getVersion(), serverPing.getPlayers(), motd, serverPing.getFaviconObject()));
}
@Override
public void run()
{
for (LobbyType type : LobbyType.values())
{
GlobalMotd motd = _repository.getElement("MainMotd");
GlobalMotd motd = _repository.getElement(type.getRedisMotdKey());
if (motd != null)
{
_motdLines = motd.getMotd();
_firstLine = motd.getHeadline();
}
}
{
GlobalMotd motd = _repository.getElement("ClansMotd");
if (motd != null)
{
_motdCLines = motd.getMotd();
_firstCLine = motd.getHeadline();
}
else
{
_repository.addElement(new GlobalMotd("ClansMotd", "§4§lMineplex Clans§r", Arrays.asList("Default MOTD")));
motds.put(type, motd);
}
}
}
/**
* Update the main {@link GlobalMotd} determining the MOTD for Bungee instances.
* @param motdLines - the lines to update the MOTD to.
*/
public void updateMainMotd(String headline, String motdLine)
{
List<String> motdLines = new ArrayList<String>();
motdLines.add(motdLine);
_repository.addElement(new GlobalMotd("MainMotd", headline, motdLines));
_secondRepository.addElement(new GlobalMotd("MainMotd", headline, motdLines));
}
public List<String> getMotdLines()
{
return _motdLines;
}
}

66
Plugins/Mineplex.Core.Common/pom.xml
View File

@ -1,40 +1,40 @@
<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>
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>
<parent>
<groupId>com.mineplex</groupId>
<artifactId>mineplex-parent</artifactId>
<version>dev-SNAPSHOT</version>
</parent>
<parent>
<groupId>com.mineplex</groupId>
<artifactId>mineplex-parent</artifactId>
<version>dev-SNAPSHOT</version>
</parent>
<artifactId>mineplex-core-common</artifactId>
<artifactId>mineplex-core-common</artifactId>
<dependencies>
<dependency>
<groupId>com.mineplex</groupId>
<artifactId>spigot</artifactId>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<dependency>
<groupId>com.mineplex</groupId>
<artifactId>mineplex-serverdata</artifactId>
<version>dev-SNAPSHOT</version>
</dependency>
</dependencies>
<dependencies>
<dependency>
<groupId>com.mineplex</groupId>
<artifactId>spigot</artifactId>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<dependency>
<groupId>com.mineplex</groupId>
<artifactId>mineplex-serverdata</artifactId>
<version>dev-SNAPSHOT</version>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory/>
<includes>
<include>ascii.png</include>
</includes>
</resource>
</resources>
</build>
<build>
<resources>
<resource>
<directory />
<includes>
<include>ascii.png</include>
</includes>
</resource>
</resources>
</build>
</project>

81
Plugins/Mineplex.Core.Common/src/mineplex/core/common/api/ApiHost.java
View File

@ -1,21 +1,80 @@
package mineplex.core.common.api;
/**
* TODO: Store this in a file instead of being hardcoded
*
* @author Shaun Bennett
*/
public enum ApiHost
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import org.bukkit.configuration.file.YamlConfiguration;
public class ApiHost
{
AMPLIFIERS("10.33.53.12", 7979),
ANTISPAM("10.33.53.12", 8181),
ENDERCHEST("10.33.53.10", 8010)
;
private static final String API_HOST_FILE = "api-config.dat";
private static final Object LOCK = new Object();
private static volatile boolean LOADED = false;
private static final Map<String, ApiHost> API_HOST_MAP = new HashMap<>();
public static ApiHost getAPIHost(String identifier)
{
if (!LOADED)
{
synchronized (LOCK)
{
if (!LOADED)
{
try
{
File configFile = new File(API_HOST_FILE);
YamlConfiguration configuration = YamlConfiguration.loadConfiguration(configFile);
for (String key : configuration.getKeys(false))
{
String ip = configuration.getConfigurationSection(key).getString("ip");
// Use parseInt to catch non-ints instead of a 0
int port = Integer.parseInt(configuration.getConfigurationSection(key).getString("port"));
if (ip == null)
{
throw new NullPointerException();
}
API_HOST_MAP.put(key, new ApiHost(ip, port));
}
}
catch (Throwable t)
{
t.printStackTrace();
}
finally
{
LOADED = true;
}
}
}
}
return API_HOST_MAP.get(identifier);
}
public static ApiHost getAmplifierService()
{
return getAPIHost("AMPLIFIERS");
}
public static ApiHost getAntispamService()
{
return getAPIHost("ANTISPAM");
}
public static ApiHost getEnderchestService()
{
return getAPIHost("ENDERCHEST");
}
private String _host;
private int _port;
ApiHost(String host, int port)
private ApiHost(String host, int port)
{
_host = host;
_port = port;

4
Plugins/Mineplex.Core.Common/src/mineplex/core/common/api/enderchest/EnderchestWorldLoader.java
View File

@ -18,7 +18,7 @@ public class EnderchestWorldLoader
public EnderchestWorldLoader()
{
String url = "http://" + ApiHost.ENDERCHEST.getHost() + ":" + ApiHost.ENDERCHEST.getPort() + "/";
String url = "http://" + ApiHost.getEnderchestService().getHost() + ":" + ApiHost.getEnderchestService().getPort() + "/";
_webCall = new ApiWebCall(url);
}
@ -26,7 +26,7 @@ public class EnderchestWorldLoader
{
TimingManager.start(TIMINGS_PREFIX + "DownloadMap");
String fileName = mapType + "_map.zip";
File f = _webCall.getFile("map/" + mapType + "/random", fileName);
File f = _webCall.getFile("map/" + mapType + "/next", fileName);
TimingManager.stop(TIMINGS_PREFIX + "DownloadMap");
TimingManager.start(TIMINGS_PREFIX + "CreateFolders");

55
Plugins/Mineplex.Core.Common/src/mineplex/core/common/util/UtilBlock.java
View File

@ -4,18 +4,9 @@ import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import net.minecraft.server.v1_8_R3.BlockPosition;
import net.minecraft.server.v1_8_R3.Blocks;
import net.minecraft.server.v1_8_R3.IBlockData;
import net.minecraft.server.v1_8_R3.Item;
import net.minecraft.server.v1_8_R3.MathHelper;
import net.minecraft.server.v1_8_R3.MinecraftKey;
import net.minecraft.server.v1_8_R3.NBTTagCompound;
import net.minecraft.server.v1_8_R3.TileEntityFlowerPot;
import net.minecraft.server.v1_8_R3.WorldServer;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.SkullType;
@ -41,8 +32,18 @@ import org.bukkit.material.Bed;
import com.mojang.authlib.GameProfile;
import mineplex.core.common.Pair;
import mineplex.core.common.block.MultiBlockUpdaterAgent;
import mineplex.core.common.skin.SkinData;
import net.minecraft.server.v1_8_R3.BlockPosition;
import net.minecraft.server.v1_8_R3.Blocks;
import net.minecraft.server.v1_8_R3.IBlockData;
import net.minecraft.server.v1_8_R3.Item;
import net.minecraft.server.v1_8_R3.MathHelper;
import net.minecraft.server.v1_8_R3.MinecraftKey;
import net.minecraft.server.v1_8_R3.NBTTagCompound;
import net.minecraft.server.v1_8_R3.TileEntityFlowerPot;
import net.minecraft.server.v1_8_R3.WorldServer;
public class UtilBlock
{
@ -1670,4 +1671,38 @@ public class UtilBlock
return null;
}
/**
* Returns a {@link Set} containing all the relevant data regarding beacon construction.
* Useful for adding them to block restore.
*
* @param surface
* The Location of the glass coloured block (at surface level). The beacon is placed one block below this.
* @param glassData
* The colour data value of glass that colours the beacon
*/
public static Set<Pair<Location, Pair<Material, Byte>>> getBeaconBlocks(Location surface, byte glassData)
{
Set<Pair<Location, Pair<Material, Byte>>> blocks = new HashSet<>();
for (int x = -1; x <= 1; x++)
{
for (int z = -1; z <= 1; z++)
{
blocks.add(Pair.create(surface.clone().add(x, -3, z), Pair.create(Material.IRON_BLOCK, (byte) 0)));
if (x == 0 && z == 0)
{
continue;
}
blocks.add(Pair.create(surface.clone().add(x, -1, z), Pair.create(Material.QUARTZ_BLOCK, (byte) 0)));
}
}
blocks.add(Pair.create(surface.clone().add(0, -2, 0), Pair.create(Material.BEACON, (byte) 0)));
blocks.add(Pair.create(surface.clone().add(0, -1, 0), Pair.create(Material.STAINED_GLASS, glassData)));
return blocks;
}
}

15
Plugins/Mineplex.Core.Common/src/mineplex/core/common/util/UtilInv.java
View File

@ -447,6 +447,21 @@ public class UtilInv
return false;
}
public static boolean hasSpace(Player player, int slots)
{
int slotsFree = 0;
for (int slot = 0; slot < player.getInventory().getSize(); slot++)
{
if (player.getInventory().getItem(slot) == null)
{
slotsFree++;
}
}
return slotsFree >= slots;
}
public static void give(Player player, Material material)
{

2
Plugins/Mineplex.Core/src/mineplex/core/antispam/repository/AntiSpamRepository.java
View File

@ -17,7 +17,7 @@ public class AntiSpamRepository extends ApiEndpoint
{
public AntiSpamRepository()
{
super(ApiHost.ANTISPAM, "/chat");
super(ApiHost.getAntispamService(), "/chat");
}
public AntiSpamApiResponse sendMessage(String source, ChatPayload payload)

68
Plugins/Mineplex.Core/src/mineplex/core/beta/BetaWhitelist.java Normal file
View File

@ -0,0 +1,68 @@
package mineplex.core.beta;
import java.util.Set;
import java.util.UUID;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerJoinEvent;
import com.google.common.collect.ImmutableSet;
import mineplex.core.MiniPlugin;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.Rank;
import mineplex.core.powerplayclub.PowerPlayClubRepository;
public class BetaWhitelist extends MiniPlugin
{
private static final Set<UUID> EXTRA_PLAYERS = ImmutableSet.<UUID>builder()
// GI Members
.add(UUID.fromString("8506533f-1da7-4d5c-a835-a483b5a18b54")) // Awquard
.add(UUID.fromString("a8526c97-95be-4cb7-ae58-7df5d3b108a6")) // ASlime
.add(UUID.fromString("ae6d71b7-3d49-429f-b31f-5cf5af136540")) // Cabob
.add(UUID.fromString("ea1f709c-031f-4028-8f7d-2073c5a37d1a")) // CharlieHacks
.add(UUID.fromString("d3c1457a-1084-43e1-846c-addc47393b90")) // Chocobutter
.add(UUID.fromString("6b60782e-f95b-4449-a39e-0ad7fa5fdab0")) // CosmoLink
.add(UUID.fromString("18697323-50d3-47ea-a5c2-e7ac1a0d9fa0")) // Danah
.add(UUID.fromString("1cc18d8d-ab28-4354-8cce-f93fb06423bf")) // Fetch
.add(UUID.fromString("c56e5b96-8dc3-46ca-b682-24cf8467e3a1")) // KingOfWizards
.add(UUID.fromString("ea30fe99-2044-438f-bfd8-97bcc639239e")) // Mauo
.add(UUID.fromString("933b2f93-806a-4f39-88a2-935442418ae5")) // Tier4Global
.add(UUID.fromString("ac239b94-3079-4a8a-a52f-7b81c8a87b4d")) // Paddi
.add(UUID.fromString("3ced328d-f079-45e4-ad71-8c721c4a699b")) // Smaland47
.add(UUID.fromString("d51fc65b-fce9-4464-9391-b259525dc6ca")) // SnitSays
.add(UUID.fromString("12bbeda2-567a-400a-9d66-f76fab832de0")) // StoneColdKiller
.add(UUID.fromString("2e0c1d88-7f44-44f5-85b4-9ad0b2cfddce")) // Tours
.add(UUID.fromString("32aff2d0-f68c-4eb9-b5d4-139fc48b7ca6")) // Trimzon
.add(UUID.fromString("3dcfe366-fcaa-48f7-abcc-b73fb62616e1")) // gamefish32
.add(UUID.fromString("6795643a-2b61-41bf-9429-c7549fd128a8")) // umGim
.add(UUID.fromString("47ba454a-4999-42f4-a269-2f4114ceb3c7")) // falconviii
.build();
private final CoreClientManager _clientManager;
private final PowerPlayClubRepository _powerPlayClubRepository;
public BetaWhitelist(CoreClientManager clientManager, PowerPlayClubRepository powerPlayRepository)
{
super("Beta Whitelist");
_clientManager = clientManager;
_powerPlayClubRepository = powerPlayRepository;
}
@EventHandler
public void onJoin(PlayerJoinEvent event)
{
Player player = event.getPlayer();
Rank rank = _clientManager.Get(player).GetRank(true);
if ((rank != Rank.MAPDEV && rank != Rank.MAPLEAD && rank.has(Rank.ETERNAL) // If this player is Eternal+ (and not a builder),
|| _powerPlayClubRepository.getCachedData(player).isSubscribed()) // a PPC subscriber,
|| EXTRA_PLAYERS.contains(player.getUniqueId())) // or explicitly whitelisted,
{
return; // allow them in
}
// Otherwise, kick them out
event.getPlayer().kickPlayer("Sorry, you aren't whitelisted on this beta server.\n\nSubscribe to " + ChatColor.GOLD + "Power Play Club " + ChatColor.WHITE + "at " + ChatColor.GREEN + "mineplex.com/shop" + ChatColor.WHITE + "!");
}
}

7
Plugins/Mineplex.Core/src/mineplex/core/blockrestore/BlockRestore.java
View File

@ -18,22 +18,23 @@ import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPistonExtendEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.world.ChunkUnloadEvent;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.common.util.UtilBlock;
import mineplex.core.common.util.UtilMath;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
@ReflectivelyCreateMiniPlugin
public class BlockRestore extends MiniPlugin
{
private HashMap<Block, BlockRestoreData> _blocks = new HashMap<Block, BlockRestoreData>();
private LinkedList<BlockRestoreMap> _restoreMaps;
public BlockRestore(JavaPlugin plugin)
private BlockRestore()
{
super("Block Restore", plugin);
super("Block Restore");
_restoreMaps = new LinkedList<BlockRestoreMap>();
}

4
Plugins/Mineplex.Core/src/mineplex/core/bonuses/BonusManager.java
View File

@ -236,11 +236,11 @@ public class BonusManager extends MiniClientPlugin<BonusClientData> implements I
if (event.getType() != UpdateType.TICK)
return;
_animation.itemClean();
if (!_enabled)
return;
_animation.itemClean();
if (!_animationRunning)
return;

3
Plugins/Mineplex.Core/src/mineplex/core/bonuses/gui/buttons/PowerPlayClubButton.java
View File

@ -170,7 +170,8 @@ public class PowerPlayClubButton implements GuiItem
public static boolean isAvailable(Player player, PowerPlayClubRepository repo)
{
return !repo.getCachedData(player).getUnclaimedMonths().isEmpty();
PowerPlayData data = repo.getCachedData(player);
return data != null && !data.getUnclaimedMonths().isEmpty();
}
}

2
Plugins/Mineplex.Core/src/mineplex/core/boosters/BoosterRepository.java
View File

@ -24,7 +24,7 @@ public class BoosterRepository extends ApiEndpoint
{
public BoosterRepository()
{
super(ApiHost.AMPLIFIERS, "/booster", new GsonBuilder().setFieldNamingStrategy(new ApiFieldNamingStrategy())
super(ApiHost.getAmplifierService(), "/booster", new GsonBuilder().setFieldNamingStrategy(new ApiFieldNamingStrategy())
// .registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer())
.setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX").create());
}

7
Plugins/Mineplex.Core/src/mineplex/core/chat/Chat.java
View File

@ -147,8 +147,11 @@ public class Chat extends MiniPlugin
|| event.getMessage().toLowerCase().startsWith("/bukkit")
|| event.getMessage().toLowerCase().startsWith("/minecraft"))
{
event.getPlayer().sendMessage(F.main(getName(), "Nope, not allowed!"));
event.setCancelled(true);
if (!event.getPlayer().isOp())
{
event.getPlayer().sendMessage(F.main(getName(), "Nope, not allowed!"));
event.setCancelled(true);
}
}
}

92
Plugins/Mineplex.Core/src/mineplex/core/communities/commands/CommunityJoinCommand.java
View File

@ -1,47 +1,47 @@
package mineplex.core.communities.commands;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.communities.Community;
import mineplex.core.communities.Community.PrivacySetting;
import mineplex.core.communities.CommunityManager;
public class CommunityJoinCommand extends CommandBase<CommunityManager>
{
public CommunityJoinCommand(CommunityManager plugin)
{
super(plugin, Rank.ALL, "join");
}
@Override
public void Execute(Player caller, String[] args)
{
if (args.length < 1)
{
UtilPlayer.message(caller, F.help("/com join <community>", "Joins a community that is open or you have been invited to", Rank.ALL, ChatColor.AQUA));
return;
}
Community c = Plugin.getLoadedCommunity(args[0]);
if (c == null)
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "That community was not found!"));
return;
}
if (c.getMembers().containsKey(caller.getUniqueId()))
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "You are already in " + F.name(c.getName()) + "!"));
return;
}
if (c.getPrivacySetting() != PrivacySetting.OPEN && !Plugin.Get(caller).Invites.contains(c.getId()))
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "You are have not been invited to " + F.name(c.getName()) + "!"));
return;
}
Plugin.handleJoin(caller, c, Plugin.Get(caller).Invites.contains(c.getId()));
}
package mineplex.core.communities.commands;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.communities.Community;
import mineplex.core.communities.Community.PrivacySetting;
import mineplex.core.communities.CommunityManager;
public class CommunityJoinCommand extends CommandBase<CommunityManager>
{
public CommunityJoinCommand(CommunityManager plugin)
{
super(plugin, Rank.ALL, "join");
}
@Override
public void Execute(Player caller, String[] args)
{
if (args.length < 1)
{
UtilPlayer.message(caller, F.help("/com join <community>", "Joins a community that is open or you have been invited to", Rank.ALL, ChatColor.AQUA));
return;
}
Community c = Plugin.getLoadedCommunity(args[0]);
if (c == null)
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "That community was not found!"));
return;
}
if (c.getMembers().containsKey(caller.getUniqueId()))
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "You are already in " + F.name(c.getName()) + "!"));
return;
}
if (c.getPrivacySetting() != PrivacySetting.OPEN && !Plugin.Get(caller).Invites.contains(c.getId()))
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "You are have not been invited to " + F.name(c.getName()) + "!"));
return;
}
Plugin.handleJoin(caller, c, Plugin.Get(caller).Invites.contains(c.getId()));
}
}

98
Plugins/Mineplex.Core/src/mineplex/core/communities/commands/CommunityMCSCommand.java
View File

@ -1,50 +1,50 @@
package mineplex.core.communities.commands;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import mineplex.core.Managers;
import mineplex.core.account.CoreClientManager;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.communities.Community;
import mineplex.core.communities.CommunityManager;
import mineplex.core.communities.CommunityMemberInfo;
import mineplex.core.communities.CommunityRole;
import mineplex.core.personalServer.PersonalServerManager;
public class CommunityMCSCommand extends CommandBase<CommunityManager>
{
public CommunityMCSCommand(CommunityManager plugin)
{
super(plugin, Rank.ALL, "mcs");
}
@Override
public void Execute(Player caller, String[] args)
{
if (args.length < 1)
{
UtilPlayer.message(caller, F.help("/com mcs <community>", "Opens the Mineplex Community Server of a community you manage", Rank.ALL, ChatColor.AQUA));
return;
}
Community c = Plugin.getLoadedCommunity(args[0]);
if (c == null)
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "That community was not found!"));
return;
}
if (c.getMembers().getOrDefault(caller.getUniqueId(), new CommunityMemberInfo(caller.getName(), caller.getUniqueId(), -1, CommunityRole.MEMBER, -1L)).Role.ordinal() > CommunityRole.COLEADER.ordinal())
{
if (!Managers.get(CoreClientManager.class).Get(caller).GetRank().has(Rank.ADMIN))
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "You are not a co-leader of " + F.name(c.getName()) + "!"));
return;
}
}
Managers.get(PersonalServerManager.class).hostCommunityServer(caller, c);
}
package mineplex.core.communities.commands;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import mineplex.core.Managers;
import mineplex.core.account.CoreClientManager;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.communities.Community;
import mineplex.core.communities.CommunityManager;
import mineplex.core.communities.CommunityMemberInfo;
import mineplex.core.communities.CommunityRole;
import mineplex.core.personalServer.PersonalServerManager;
public class CommunityMCSCommand extends CommandBase<CommunityManager>
{
public CommunityMCSCommand(CommunityManager plugin)
{
super(plugin, Rank.ALL, "mcs");
}
@Override
public void Execute(Player caller, String[] args)
{
if (args.length < 1)
{
UtilPlayer.message(caller, F.help("/com mcs <community>", "Opens the Mineplex Community Server of a community you manage", Rank.ALL, ChatColor.AQUA));
return;
}
Community c = Plugin.getLoadedCommunity(args[0]);
if (c == null)
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "That community was not found!"));
return;
}
if (c.getMembers().getOrDefault(caller.getUniqueId(), new CommunityMemberInfo(caller.getName(), caller.getUniqueId(), -1, CommunityRole.MEMBER, -1L)).Role.ordinal() > CommunityRole.COLEADER.ordinal())
{
if (!Managers.get(CoreClientManager.class).Get(caller).GetRank().has(Rank.ADMIN))
{
UtilPlayer.message(caller, F.main(Plugin.getName(), "You are not a co-leader of " + F.name(c.getName()) + "!"));
return;
}
}
Managers.get(PersonalServerManager.class).hostCommunityServer(caller, c);
}
}

98
Plugins/Mineplex.Core/src/mineplex/core/communities/mcs/MCSTheme.java
View File

@ -1,50 +1,50 @@
package mineplex.core.communities.mcs;
import org.bukkit.Material;
import mineplex.core.common.util.C;
public enum MCSTheme
{
CANDYLAND(1, C.cPurple + "Candyland", Material.COOKIE, 1000, "Lobby_MPS_Candyland.zip")
;
private final int _id;
private final String _displayName, _file;
private final Material _displayType;
private final int _cost;
private MCSTheme(int id, String displayName, Material displayType, int cost, String file)
{
_id = id;
_displayName = displayName;
_displayType = displayType;
_cost = cost;
_file = file;
}
public int getId()
{
return _id;
}
public String getDisplayName()
{
return _displayName;
}
public Material getDisplayType()
{
return _displayType;
}
public int getCost()
{
return _cost;
}
public String getFile()
{
return _file;
}
package mineplex.core.communities.mcs;
import org.bukkit.Material;
import mineplex.core.common.util.C;
public enum MCSTheme
{
CANDYLAND(1, C.cPurple + "Candyland", Material.COOKIE, 1000, "Lobby_MPS_Candyland.zip")
;
private final int _id;
private final String _displayName, _file;
private final Material _displayType;
private final int _cost;
private MCSTheme(int id, String displayName, Material displayType, int cost, String file)
{
_id = id;
_displayName = displayName;
_displayType = displayType;
_cost = cost;
_file = file;
}
public int getId()
{
return _id;
}
public String getDisplayName()
{
return _displayName;
}
public Material getDisplayType()
{
return _displayType;
}
public int getCost()
{
return _cost;
}
public String getFile()
{
return _file;
}
}

50
Plugins/Mineplex.Core/src/mineplex/core/communities/redis/PlayerJoinHandler.java
View File

@ -1,26 +1,26 @@
package mineplex.core.communities.redis;
import mineplex.core.communities.CommunityManager;
import mineplex.serverdata.commands.CommandCallback;
import mineplex.serverdata.commands.PlayerJoinCommand;
import mineplex.serverdata.commands.ServerCommand;
public class PlayerJoinHandler implements CommandCallback
{
private CommunityManager _communityManager;
public PlayerJoinHandler(CommunityManager communityManager)
{
_communityManager = communityManager;
}
@Override
public void run(ServerCommand command)
{
if (command instanceof PlayerJoinCommand)
{
PlayerJoinCommand joinCommand = (PlayerJoinCommand)command;
//_communityManager.updateAllMemberData(UUID.fromString(joinCommand.getUuid()), joinCommand.getName());
}
}
package mineplex.core.communities.redis;
import mineplex.core.communities.CommunityManager;
import mineplex.serverdata.commands.CommandCallback;
import mineplex.serverdata.commands.PlayerJoinCommand;
import mineplex.serverdata.commands.ServerCommand;
public class PlayerJoinHandler implements CommandCallback
{
private CommunityManager _communityManager;
public PlayerJoinHandler(CommunityManager communityManager)
{
_communityManager = communityManager;
}
@Override
public void run(ServerCommand command)
{
if (command instanceof PlayerJoinCommand)
{
PlayerJoinCommand joinCommand = (PlayerJoinCommand)command;
//_communityManager.updateAllMemberData(UUID.fromString(joinCommand.getUuid()), joinCommand.getName());
}
}
}

5
Plugins/Mineplex.Core/src/mineplex/core/cosmetic/CosmeticManager.java
View File

@ -242,6 +242,11 @@ public class CosmeticManager extends MiniPlugin
{
return _boosterManager;
}
public void displayUI(Player player)
{
_shop.attemptShopOpen(player);
}
public void disableTeamArmor()
{

40
Plugins/Mineplex.Core/src/mineplex/core/cosmetic/ui/button/open/OpenTaunts.java
View File

@ -1,21 +1,21 @@
package mineplex.core.cosmetic.ui.button.open;
import org.bukkit.entity.Player;
import mineplex.core.cosmetic.ui.page.Menu;
import mineplex.core.cosmetic.ui.page.TauntPage;
import mineplex.core.gadget.types.Gadget;
public class OpenTaunts extends OpenPageButton
{
public OpenTaunts(Menu menu, Gadget active)
{
super(menu, active);
}
@Override
protected void leftClick(Player player)
{
getMenu().getShop().openPageForPlayer(player, new TauntPage(getMenu().getPlugin(), getMenu().getShop(), getMenu().getClientManager(), getMenu().getDonationManager(), "Taunts", player));
}
package mineplex.core.cosmetic.ui.button.open;
import org.bukkit.entity.Player;
import mineplex.core.cosmetic.ui.page.Menu;
import mineplex.core.cosmetic.ui.page.TauntPage;
import mineplex.core.gadget.types.Gadget;
public class OpenTaunts extends OpenPageButton
{
public OpenTaunts(Menu menu, Gadget active)
{
super(menu, active);
}
@Override
protected void leftClick(Player player)
{
getMenu().getShop().openPageForPlayer(player, new TauntPage(getMenu().getPlugin(), getMenu().getShop(), getMenu().getClientManager(), getMenu().getDonationManager(), "Taunts", player));
}
}

116
Plugins/Mineplex.Core/src/mineplex/core/cosmetic/ui/page/TauntPage.java
View File

@ -1,59 +1,57 @@
package mineplex.core.cosmetic.ui.page;
import java.util.List;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.util.C;
import mineplex.core.cosmetic.CosmeticManager;
import mineplex.core.cosmetic.ui.CosmeticShop;
import mineplex.core.donation.DonationManager;
import mineplex.core.gadget.types.Gadget;
import mineplex.core.gadget.types.GadgetType;
import mineplex.core.shop.item.IButton;
import mineplex.core.shop.item.ShopItem;
public class TauntPage extends GadgetPage
{
public TauntPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name,
Player player)
{
super(plugin, shop, clientManager, donationManager, name, player);
}
@Override
protected void buildPage()
{
int slot = 10;
List<Gadget> list = getPlugin().getGadgetManager().getGadgets(GadgetType.TAUNT);
if(list != null)
for (Gadget gadget : list)
{
addGadget(gadget, slot);
if (gadget.isActive(getPlayer()))
{
addGlow(slot);
}
slot++;
if (slot == 26)
slot += 2;
}
addButton(4, new ShopItem(Material.BED, C.cGray + " \u21FD Go Back", new String[]{}, 1, false), new IButton()
{
public void onClick(Player player, ClickType clickType)
{
getShop().openPageForPlayer(getPlayer(), new Menu(getPlugin(), getShop(), getClientManager(), getDonationManager(), player));
}
});
}
}
package mineplex.core.cosmetic.ui.page;
import java.util.List;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.util.C;
import mineplex.core.cosmetic.CosmeticManager;
import mineplex.core.cosmetic.ui.CosmeticShop;
import mineplex.core.donation.DonationManager;
import mineplex.core.gadget.types.Gadget;
import mineplex.core.gadget.types.GadgetType;
import mineplex.core.shop.item.IButton;
import mineplex.core.shop.item.ShopItem;
public class TauntPage extends GadgetPage
{
public TauntPage(CosmeticManager plugin, CosmeticShop shop, CoreClientManager clientManager, DonationManager donationManager, String name,
Player player)
{
super(plugin, shop, clientManager, donationManager, name, player);
}
@Override
protected void buildPage()
{
int slot = 10;
List<Gadget> list = getPlugin().getGadgetManager().getGadgets(GadgetType.TAUNT);
if(list != null)
for (Gadget gadget : list)
{
addGadget(gadget, slot);
if (getPlugin().getGadgetManager().getActive(getPlayer(), GadgetType.TAUNT) == gadget)
addGlow(slot);
slot++;
if (slot == 26)
slot += 2;
}
addButton(4, new ShopItem(Material.BED, C.cGray + " \u21FD Go Back", new String[]{}, 1, false), new IButton()
{
public void onClick(Player player, ClickType clickType)
{
getShop().openPageForPlayer(getPlayer(), new Menu(getPlugin(), getShop(), getClientManager(), getDonationManager(), player));
}
});
}
}

13
Plugins/Mineplex.Core/src/mineplex/core/disguise/disguises/DisguiseBlock.java
View File

@ -5,6 +5,9 @@ import java.util.Random;
import net.minecraft.server.v1_8_R3.MathHelper;
import net.minecraft.server.v1_8_R3.Packet;
import net.minecraft.server.v1_8_R3.PacketPlayOutSpawnEntity;
import org.bukkit.Material;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
public class DisguiseBlock extends DisguiseBase
@ -14,7 +17,7 @@ public class DisguiseBlock extends DisguiseBase
private int _blockId;
private int _blockData;
public DisguiseBlock(org.bukkit.entity.Entity entity, int blockId, int blockData)
public DisguiseBlock(Entity entity, int blockId, int blockData)
{
super(EntityType.FALLING_BLOCK, entity);
@ -22,6 +25,14 @@ public class DisguiseBlock extends DisguiseBase
_blockData = blockData;
}
public DisguiseBlock(Entity entity, Material material, byte data)
{
super(EntityType.FALLING_BLOCK, entity);
_blockId = material.getId();
_blockData = (int) data;
}
public int GetBlockId()
{
return _blockId;

10
Plugins/Mineplex.Core/src/mineplex/core/gadget/GadgetManager.java
View File

@ -87,6 +87,8 @@ import mineplex.core.gadget.gadgets.doublejump.titan.DoubleJumpTitan;
import mineplex.core.gadget.gadgets.doublejump.vampire.DoubleJumpBlood;
import mineplex.core.gadget.gadgets.doublejump.wisdom.DoubleJumpEnchant;
import mineplex.core.gadget.gadgets.gamemodifiers.GameModifierType;
import mineplex.core.gadget.gadgets.gamemodifiers.gemhunters.GameModifierMount;
import mineplex.core.gadget.gadgets.gamemodifiers.gemhunters.MountType;
import mineplex.core.gadget.gadgets.gamemodifiers.kits.KitGameModifier;
import mineplex.core.gadget.gadgets.gamemodifiers.kits.KitModifier;
import mineplex.core.gadget.gadgets.gamemodifiers.kits.KitModifierType;
@ -121,6 +123,7 @@ import mineplex.core.gadget.gadgets.morph.MorphCow;
import mineplex.core.gadget.gadgets.morph.MorphCreeper;
import mineplex.core.gadget.gadgets.morph.MorphDinnerbone;
import mineplex.core.gadget.gadgets.morph.MorphEnderman;
import mineplex.core.gadget.gadgets.morph.MorphGoldPot;
import mineplex.core.gadget.gadgets.morph.MorphGrimReaper;
import mineplex.core.gadget.gadgets.morph.MorphLoveDoctor;
import mineplex.core.gadget.gadgets.morph.MorphMetalMan;
@ -418,6 +421,7 @@ public class GadgetManager extends MiniPlugin
addGadget(new MorphSanta(this));
addGadget(new MorphDinnerbone(this));
addGadget(new MorphLoveDoctor(this));
addGadget(new MorphGoldPot(this));
// Particles
addGadget(new ParticleFoot(this));
@ -574,6 +578,12 @@ public class GadgetManager extends MiniPlugin
addGadget(new BlowAKissTaunt(this));
addGadget(new RainbowTaunt(this));
// Gem Hunters Mounts
for (MountType mount : MountType.values())
{
addGadget(new GameModifierMount(this, mount));
}
for (GadgetType gadgetType : GadgetType.values())
{
if (!_gadgets.containsKey(gadgetType))

9
Plugins/Mineplex.Core/src/mineplex/core/gadget/commands/LockCosmeticsCommand.java
View File

@ -7,6 +7,7 @@ import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.common.util.UtilText;
import mineplex.core.donation.Donor;
import mineplex.core.gadget.GadgetManager;
@ -22,13 +23,19 @@ public class LockCosmeticsCommand extends CommandBase<GadgetManager>
public LockCosmeticsCommand(GadgetManager plugin)
{
super(plugin, Rank.JNR_DEV, "lockCosmetics");
super(plugin, Rank.SNR_MODERATOR, "lockCosmetics");
_plugin = plugin;
}
@Override
public void Execute(Player caller, String[] args)
{
if (!UtilServer.isTestServer())
{
UtilPlayer.message(caller, F.main("Lock Cosmetics", "This command requires a test server!"));
return;
}
// Adds all cosmetic types
if (args.length == 0)
{

7
Plugins/Mineplex.Core/src/mineplex/core/gadget/commands/UnlockCosmeticsCommand.java
View File

@ -7,6 +7,7 @@ import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.common.util.UtilText;
import mineplex.core.donation.Donor;
import mineplex.core.gadget.GadgetManager;
@ -29,6 +30,12 @@ public class UnlockCosmeticsCommand extends CommandBase<GadgetManager>
@Override
public void Execute(Player caller, String[] args)
{
if (!UtilServer.isTestServer())
{
UtilPlayer.message(caller, F.main("Unlock Cosmetics", "This command requires a test server!"));
return;
}
// Adds all cosmetic types
if (args.length == 0)
{

212
Plugins/Mineplex.Core/src/mineplex/core/gadget/event/TauntCommandEvent.java
View File

@ -1,106 +1,106 @@
package mineplex.core.gadget.event;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import mineplex.core.common.util.UtilTime;
import mineplex.core.gadget.gadgets.taunts.GameType;
public class TauntCommandEvent extends Event
{
private static final HandlerList handlers = new HandlerList();
private Player _player;
private boolean _gameInProgress;
private boolean _alive;
private boolean _spectator;
private long _lastPvp;
private TauntState _state = TauntState.NONE;
private GameType _gameType;
public TauntCommandEvent(Player player, boolean gameInProgress, boolean alive, boolean spectator, long lastPvp, GameType gameType)
{
_player = player;
_gameInProgress = gameInProgress;
_alive = alive;
_spectator = spectator;
_lastPvp = lastPvp;
_gameType = gameType;
}
public Player getPlayer()
{
return _player;
}
public boolean isGameInProgress()
{
return _gameInProgress;
}
public boolean isAlive()
{
return _alive;
}
public boolean isSpectator()
{
return _spectator;
}
public boolean isInPvp(long cooldown)
{
return !UtilTime.elapsed(_lastPvp, cooldown);
}
public TauntState getState()
{
return _state;
}
public GameType getGameType()
{
return _gameType;
}
public void setState(TauntState state)
{
_state = state;
}
public HandlerList getHandlers()
{
return handlers;
}
public static HandlerList getHandlerList()
{
return handlers;
}
public enum TauntState
{
NONE(""),
NO_TAUNT("You have no active taunts!"),
NOT_IN_GAME("You are not in a game!"),
NOT_ALIVE("You are not playing the game!"),
SPECTATOR("You can't run this as a spectator!"),
PVP("You can't run this while in pvp!"),
GAME_DISABLED("Taunts are disabled in this game!");
private String _message;
TauntState(String message)
{
_message = message;
}
public String getMessage()
{
return _message;
}
}
}
package mineplex.core.gadget.event;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import mineplex.core.common.util.UtilTime;
import mineplex.core.gadget.gadgets.taunts.GameType;
public class TauntCommandEvent extends Event
{
private static final HandlerList handlers = new HandlerList();
private Player _player;
private boolean _gameInProgress;
private boolean _alive;
private boolean _spectator;
private long _lastPvp;
private TauntState _state = TauntState.NONE;
private GameType _gameType;
public TauntCommandEvent(Player player, boolean gameInProgress, boolean alive, boolean spectator, long lastPvp, GameType gameType)
{
_player = player;
_gameInProgress = gameInProgress;
_alive = alive;
_spectator = spectator;
_lastPvp = lastPvp;
_gameType = gameType;
}
public Player getPlayer()
{
return _player;
}
public boolean isGameInProgress()
{
return _gameInProgress;
}
public boolean isAlive()
{
return _alive;
}
public boolean isSpectator()
{
return _spectator;
}
public boolean isInPvp(long cooldown)
{
return !UtilTime.elapsed(_lastPvp, cooldown);
}
public TauntState getState()
{
return _state;
}
public GameType getGameType()
{
return _gameType;
}
public void setState(TauntState state)
{
_state = state;
}
public HandlerList getHandlers()
{
return handlers;
}
public static HandlerList getHandlerList()
{
return handlers;
}
public enum TauntState
{
NONE(""),
NO_TAUNT("You have no active taunts!"),
NOT_IN_GAME("You are not in a game!"),
NOT_ALIVE("You are not playing the game!"),
SPECTATOR("You can't run this as a spectator!"),
PVP("You can't run this while in pvp!"),
GAME_DISABLED("Taunts are disabled in this game!");
private String _message;
TauntState(String message)
{
_message = message;
}
public String getMessage()
{
return _message;
}
}
}

6
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/gamemodifiers/GameModifierType.java
View File

@ -19,7 +19,11 @@ public enum GameModifierType
MineStrike("MineStrike", new String[]{"Apply custom gun models and skin to use ingame"}, Material.TNT, 0),
SurvivalGames("Survival Games", new String[]{"Placeholder"}, Material.DIAMOND_SWORD, 0, true),
Bridges("Bridges", new String[]{"Placeholder"}, Material.IRON_PICKAXE, 0, true);
Bridges("Bridges", new String[]{"Placeholder"}, Material.IRON_PICKAXE, 0, true),
GemHunters("Gem Hunters", new String[] { "" }, Material.EMERALD, 0)
;
private String _name;
private List<String> _desc;

23
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/gamemodifiers/gemhunters/GameModifierMount.java Normal file
View File

@ -0,0 +1,23 @@
package mineplex.core.gadget.gadgets.gamemodifiers.gemhunters;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.gadget.gadgets.gamemodifiers.GameModifierType;
import mineplex.core.gadget.types.GameModifierGadget;
public class GameModifierMount extends GameModifierGadget
{
private final MountType _mountType;
public GameModifierMount(GadgetManager manager, MountType mountType)
{
super(manager, GameModifierType.GemHunters, mountType.getName() + " Mount", mountType.getDescription(), -2, mountType.getMaterial(), mountType.getData(), false);
_mountType = mountType;
}
public final MountType getMountType()
{
return _mountType;
}
}

53
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/gamemodifiers/gemhunters/MountType.java Normal file
View File

@ -0,0 +1,53 @@
package mineplex.core.gadget.gadgets.gamemodifiers.gemhunters;
import org.bukkit.Material;
import org.bukkit.entity.EntityType;
public enum MountType
{
SKELETON(EntityType.HORSE, Material.BONE, (byte) 0, "Skeleton Horse", "Spooky")
;
private final EntityType _entityType;
private final Material _material;
private final byte _data;
private final String _name;
private final String[] _description;
private MountType(EntityType entityType, Material material, byte data, String name, String... description)
{
_entityType = entityType;
_material = material;
_data = data;
_name = name;
_description = description;
}
public final EntityType getEntityType()
{
return _entityType;
}
public final Material getMaterial()
{
return _material;
}
public byte getData()
{
return _data;
}
public final String getName()
{
return _name;
}
public final String[] getDescription()
{
return _description;
}
}

132
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/MorphGoldPot.java Normal file
View File

@ -0,0 +1,132 @@
package mineplex.core.gadget.gadgets.morph;
import java.time.Month;
import java.time.YearMonth;
import java.util.HashMap;
import java.util.Map;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import mineplex.core.common.util.C;
import mineplex.core.common.util.LineFormat;
import mineplex.core.common.util.UtilText;
import mineplex.core.disguise.disguises.DisguiseBlock;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.gadget.gadgets.morph.managers.GoldPotHelper;
import mineplex.core.gadget.gadgets.morph.managers.UtilMorph;
import mineplex.core.gadget.types.MorphGadget;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
public class MorphGoldPot extends MorphGadget
{
private Map<Player, GoldPotHelper> _helpers = new HashMap<>();
public MorphGoldPot(GadgetManager manager)
{
super(manager, "Gold Pot Morph", UtilText.splitLinesToArray(new String[]
{
C.cGray + "They say at the end of every rainbow a leprechaun has a pot filled with gold.",
C.blankLine,
C.cWhite + "Stand still to hide in place and fill up with treasure. Players who find you will earn a reward!",
}, LineFormat.LORE),
-14,
Material.CAULDRON_ITEM, (byte) 0, YearMonth.of(2017, Month.MARCH));
}
@Override
public void enableCustom(Player player, boolean message)
{
applyArmor(player, message);
_helpers.put(player, new GoldPotHelper(player, Manager, this));
DisguiseBlock disguiseBlock = new DisguiseBlock(player, Material.CAULDRON, (byte) 0);
UtilMorph.disguise(player, disguiseBlock, Manager);
}
@Override
public void disableCustom(Player player, boolean message)
{
removeArmor(player);
if (_helpers.containsKey(player))
{
_helpers.get(player).unsolidifyPlayer();
_helpers.get(player).cleanItems(true);
_helpers.remove(player);
}
UtilMorph.undisguise(player, Manager.getDisguiseManager());
}
@EventHandler
public void onUpdate(UpdateEvent event)
{ for (GoldPotHelper goldPotHelper : _helpers.values())
{
boolean solid = goldPotHelper.updatePlayer(event.getType() == UpdateType.SEC, event.getType() == UpdateType.TICK);
if (solid)
{
goldPotHelper.solififyPlayer();
}
}
}
@EventHandler
public void onRightClick(PlayerInteractEvent event)
{
if (event.getAction() == Action.RIGHT_CLICK_BLOCK)
{
for (GoldPotHelper goldPotHelper : _helpers.values())
{
goldPotHelper.performRightClick(event.getPlayer(), event.getClickedBlock());
}
}
}
@EventHandler
public void onItemPickup(PlayerPickupItemEvent event)
{
for (GoldPotHelper goldPotHelper : _helpers.values())
{
if (goldPotHelper.getItems().contains(event.getItem()))
{
event.setCancelled(true);
}
}
}
@EventHandler
public void onPlayerMove(PlayerMoveEvent event)
{
if (!isActive(event.getPlayer()))
return;
if (_helpers.containsKey(event.getPlayer()))
{
if (!_helpers.get(event.getPlayer()).isSolid())
return;
}
Location from = event.getFrom(), to = event.getTo();
double xFrom = from.getX(), yFrom = from.getY(), zFrom = from.getZ(),
xTo = to.getX(), yTo = to.getY(), zTo = to.getZ();
if (xFrom != xTo || yFrom != yTo || zFrom != zTo)
{
if (_helpers.containsKey(event.getPlayer()))
{
_helpers.get(event.getPlayer()).unsolidifyPlayer();
}
event.getPlayer().setExp(0f);
}
}
}

213
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/managers/GoldPotHelper.java Normal file
View File

@ -0,0 +1,213 @@
package mineplex.core.gadget.gadgets.morph.managers;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Item;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.util.Vector;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilMath;
import mineplex.core.common.util.UtilParticle;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.disguise.disguises.DisguiseBlock;
import mineplex.core.disguise.disguises.DisguiseCat;
import mineplex.core.disguise.disguises.DisguiseChicken;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.gadget.event.GadgetBlockEvent;
import mineplex.core.gadget.types.Gadget;
import mineplex.core.recharge.Recharge;
public class GoldPotHelper
{
private static final float EXP_INCREMENT = 0.2f;
private static final long COOLDOWN = 300000;
private static final int SHARDS = 250;
private static final int GEMS = 60;
private Player _player;
private GadgetManager _manager;
private Gadget _gadget;
private GoldPotStands _goldPotStands;
private Block _block;
private boolean _solid = false;
private boolean _nuggets = false;
private HashSet<Item> _items = new HashSet<>();
public GoldPotHelper(Player player, GadgetManager manager, Gadget gadget)
{
_player = player;
_manager = manager;
_gadget = gadget;
_goldPotStands = new GoldPotStands();
}
public void solififyPlayer()
{
if (_solid)
return;
Block block = _player.getLocation().getBlock();
GadgetBlockEvent event = new GadgetBlockEvent(_gadget, Collections.singletonList(block));
Bukkit.getServer().getPluginManager().callEvent(event);
if (event.isCancelled() || block.getType() != Material.AIR)
{
UtilPlayer.message(_player, F.main("Morph", "You cannot become a gold pot here!"));
return;
}
if (!Recharge.Instance.usable(_player, _gadget.getName(), true, "Your pot will be refilled with gold in %t"))
{
return;
}
UtilMorph.undisguise(_player, _manager.getDisguiseManager());
DisguiseChicken disguiseChicken = new DisguiseChicken(_player);
disguiseChicken.setSoundDisguise(new DisguiseCat(_player));
disguiseChicken.setInvisible(true);
UtilMorph.disguise(_player, disguiseChicken, _manager);
block.setType(Material.CAULDRON);
_block = block;
_goldPotStands.setBlock(_block);
_goldPotStands.createStands();
_solid = true;
UtilPlayer.message(_player, F.main("Gold Pot", "You're now filled with gold!"));
}
public void unsolidifyPlayer()
{
if (!_solid)
return;
_goldPotStands.removeStands();
UtilMorph.undisguise(_player, _manager.getDisguiseManager());
DisguiseBlock disguiseBlock = new DisguiseBlock(_player, Material.CAULDRON, (byte) 0);
UtilMorph.disguise(_player, disguiseBlock, _manager);
if (_block != null)
{
_block.setType(Material.AIR);
_block = null;
}
_solid = false;
UtilPlayer.message(_player, F.main("Gold Pot", "You're no longer filled with gold!"));
}
public boolean updatePlayer(boolean second, boolean tick)
{
boolean solidify = false;
if (second)
{
if (!_solid)
{
// Updates EXP Bar
_player.setExp(_player.getExp() + EXP_INCREMENT);
if (_player.getExp() == 1)
{
// Solidifies (or tries to)
solidify = true;
_player.setExp(0f);
}
if (_manager.isMoving(_player))
{
_player.setExp(0f);
solidify = false;
}
}
else
{
// Throws items in the air
for (int i = 1; i < 5; i++)
{
ItemStack itemStack = new ItemStack((_nuggets) ? Material.GOLD_NUGGET : Material.GOLD_INGOT);
ItemMeta itemMeta = itemStack.getItemMeta();
itemMeta.setDisplayName("DROPPED" + System.currentTimeMillis() + i);
itemStack.setItemMeta(itemMeta);
Item gold = _block.getWorld().dropItem(_block.getLocation().add(0.5, 1.5, 0.5), itemStack);
_items.add(gold);
gold.setVelocity(new Vector((Math.random()-0.5)*0.3, Math.random()-0.4, (Math.random()-0.5)*0.3));
}
_nuggets = !_nuggets;
}
}
if (tick)
{
UtilParticle.PlayParticleToAll(UtilParticle.ParticleType.ICON_CRACK.getParticle(Material.GOLD_BLOCK,
(byte) 0), _player.getLocation().add(0, 0.5, 0), 0.1f, 0.1f, 0.1f, 0.3f, 1, UtilParticle.ViewDist.LONG);
cleanItems(false);
}
return solidify;
}
public void performRightClick(Player clicked, Block block)
{
if (_block == null)
return;
if (!block.equals(_block))
return;
if (clicked.equals(_player))
return;
unsolidifyPlayer();
Recharge.Instance.use(_player, _gadget.getName(), COOLDOWN, false, false, "Cosmetics");
boolean shards = UtilMath.random.nextBoolean();
if (shards)
{
_manager.getDonationManager().rewardCurrency(GlobalCurrency.TREASURE_SHARD, clicked, _gadget.getName() + " Gold Pot Pickup Shards", SHARDS);
Bukkit.broadcastMessage(F.main("Gold Pot", F.name(clicked.getName()) + " found a gold pot worth " + F.currency(GlobalCurrency.TREASURE_SHARD, SHARDS) + "!"));
} else
{
_manager.getDonationManager().rewardCurrency(GlobalCurrency.GEM, clicked, _gadget.getName() + " Gold Pot Pickup Gems", GEMS);
Bukkit.broadcastMessage(F.main("Gold Pot", F.name(clicked.getName()) + " found a gold pot worth " + F.currency(GlobalCurrency.GEM, GEMS) + "!"));
}
}
public HashSet<Item> getItems()
{
return _items;
}
public void cleanItems(boolean force)
{
Iterator<Item> it = _items.iterator();
while (it.hasNext())
{
Item item = it.next();
if (item.getTicksLived() >= 20 || force)
{
item.remove();
it.remove();
}
}
}
public boolean isSolid()
{
return _solid;
}
}

98
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/morph/managers/GoldPotStands.java Normal file
View File

@ -0,0 +1,98 @@
package mineplex.core.gadget.gadgets.morph.managers;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.ArmorStand;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.EulerAngle;
public class GoldPotStands
{
private ArmorStand _helmet, _armsA, _armsB, _armsC;
private Block _block;
public void setBlock(Block block)
{
_block = block;
}
public void createStands()
{
if (_block == null)
{
return;
}
Location loc = _block.getLocation().clone().add(0.5, 0, 0.5);
// Spawns main armorstand
Location asHelmetGoldLoc = loc.clone().subtract(0, 1, 0);
ArmorStand asHelmetGold = loc.getWorld().spawn(asHelmetGoldLoc, ArmorStand.class);
asHelmetGold.setVisible(false);
asHelmetGold.setGravity(false);
asHelmetGold.setHelmet(new ItemStack(Material.GOLD_BLOCK));
// Spawns second armorstand
Location asArmsGoldALoc = asHelmetGoldLoc.clone();
ArmorStand asArmsGoldA = loc.getWorld().spawn(asArmsGoldALoc, ArmorStand.class);
asArmsGoldA.setVisible(false);
asArmsGoldA.setGravity(false);
asArmsGoldA.setItemInHand(new ItemStack(Material.GOLD_BLOCK));
double asArmsGoldAX = Math.toRadians(158), asArmsGoldAY = Math.toRadians(75);
EulerAngle asArmsGoldAEuler = new EulerAngle(asArmsGoldAX, asArmsGoldAY, 0);
asArmsGoldA.setRightArmPose(asArmsGoldAEuler);
// Spawns third armorstand
Location asArmsGoldBLoc = asHelmetGoldLoc.clone();
ArmorStand asArmsGoldB = loc.getWorld().spawn(asArmsGoldBLoc, ArmorStand.class);
asArmsGoldB.setVisible(false);
asArmsGoldB.setGravity(false);
asArmsGoldB.setItemInHand(new ItemStack(Material.GOLD_BLOCK));
double asArmsGoldBX = Math.toRadians(202), asArmsGoldBY = Math.toRadians(245);
EulerAngle asArmsGoldBEuler = new EulerAngle(asArmsGoldBX, asArmsGoldBY, 0);
asArmsGoldB.setRightArmPose(asArmsGoldBEuler);
// Spawns fourth armorstand
Location asArmsGoldCLoc = loc.clone().add(0.4, 0.1, 0.1);
ArmorStand asArmsGoldC = loc.getWorld().spawn(asArmsGoldCLoc, ArmorStand.class);
asArmsGoldC.setVisible(false);
asArmsGoldC.setGravity(false);
asArmsGoldC.setSmall(true);
asArmsGoldC.setItemInHand(new ItemStack(Material.GOLD_BLOCK));
double asArmsGoldCX = Math.toRadians(191), asArmsGoldCY = Math.toRadians(245);
EulerAngle asArmsGoldCEuler = new EulerAngle(asArmsGoldCX, asArmsGoldCY, 0);
asArmsGoldC.setRightArmPose(asArmsGoldCEuler);
_helmet = asHelmetGold;
_armsA = asArmsGoldA;
_armsB = asArmsGoldB;
_armsC = asArmsGoldC;
}
public void removeStands()
{
if (_helmet != null)
{
_helmet.remove();
_helmet = null;
}
if (_armsA != null)
{
_armsA.remove();
_armsA = null;
}
if (_armsB != null)
{
_armsB.remove();
_armsB = null;
}
if (_armsC != null)
{
_armsC.remove();
_armsC = null;
}
_block = null;
}
}

294
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/taunts/EternalTaunt.java
View File

@ -1,147 +1,147 @@
package mineplex.core.gadget.gadgets.taunts;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.Color;
import org.bukkit.FireworkEffect;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Item;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.util.Vector;
import mineplex.core.common.Rank;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.common.util.LineFormat;
import mineplex.core.common.util.UtilAction;
import mineplex.core.common.util.UtilFirework;
import mineplex.core.common.util.UtilText;
import mineplex.core.disguise.disguises.DisguiseSkeleton;
import mineplex.core.events.EnableArcadeSpawnEvent;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.gadget.gadgets.morph.managers.UtilMorph;
import mineplex.core.gadget.types.TauntGadget;
import mineplex.core.itemstack.ItemStackFactory;
import mineplex.core.recharge.Recharge;
import mineplex.core.updater.UpdateType;
public class EternalTaunt extends TauntGadget
{
private static final int COOLDOWN = 30000;
private static final int PVP_COOLDOWN = 10000;
private Map<UUID, List<Item>> _clocks = new HashMap<>();
public EternalTaunt(GadgetManager manager)
{
super(manager, "Eternal Taunt", UtilText.splitLinesToArray(new String[]{C.cGray + "Although the Eternal has been around forever, he waited too long for a worthy opponent and he turned to bones.",
"",
C.cWhite + "Use /taunt in game to show how long you've been waiting.",
C.cRed + "Cannot be used while in PvP!"}, LineFormat.LORE),
-15, Material.WATCH, (byte) 0);
setCanPlayWithPvp(false);
setPvpCooldown(PVP_COOLDOWN);
setShouldPlay(true);
setEventType(UpdateType.FAST);
addDisabledGames(GameType.SMASH, GameType.SMASHTEAMS, GameType.SMASHDOMINATION);
}
@Override
public void onStart(Player player)
{
if (!Recharge.Instance.use(player, getName(), COOLDOWN, true, false, "Cosmetics"))
return;
UtilFirework.playFirework(player.getLocation(), FireworkEffect.builder().with(FireworkEffect.Type.BALL_LARGE).withColor(Color.fromRGB(255, 175, 175)).withFade(Color.RED).build());
_clocks.put(player.getUniqueId(), new ArrayList<>());
Bukkit.broadcastMessage(F.main("Taunt", F.name(player.getName()) + " waited so long they turned to bones."));
DisguiseSkeleton disguiseSkeleton = new DisguiseSkeleton(player);
UtilMorph.disguise(player, disguiseSkeleton, Manager);
}
@Override
public void onPlay(Player player)
{
if (!_clocks.containsKey(player.getUniqueId()))
return;
int i = getPlayerTicks(player);
EnableArcadeSpawnEvent enableArcadeSpawnEvent = new EnableArcadeSpawnEvent(true);
Bukkit.getPluginManager().callEvent(enableArcadeSpawnEvent);
Item clock = player.getWorld().dropItem(player.getLocation().add(0.5, 1.5, 0.5),
ItemStackFactory.Instance.CreateStack(Material.WATCH, (byte) 0, 1, " " + i));
enableArcadeSpawnEvent = new EnableArcadeSpawnEvent(false);
Bukkit.getPluginManager().callEvent(enableArcadeSpawnEvent);
Vector vel = new Vector(Math.sin(i * 9/5d), 0, Math.cos(i * 9/5d));
UtilAction.velocity(clock, vel, Math.abs(Math.sin(i * 12/3000d)), false, 0, 0.2 + Math.abs(Math.cos(i * 12/3000d))*0.6, 1, false);
_clocks.get(player.getUniqueId()).add(clock);
if (_clocks.get(player.getUniqueId()).size() >= 5)
{
_clocks.get(player.getUniqueId()).get(0).remove();
_clocks.get(player.getUniqueId()).remove(0);
}
if (i % 2 == 0)
player.playSound(player.getLocation(), Sound.CLICK, 1f, 1f);
else
player.playSound(player.getLocation(), Sound.CLICK, 0.5f, 0.5f);
if (i >= 15)
{
finish(player);
}
}
@Override
public void onFinish(Player player)
{
UtilMorph.undisguise(player, Manager.getDisguiseManager());
if (_clocks.containsKey(player.getUniqueId()))
{
_clocks.get(player.getUniqueId()).forEach(c -> c.remove());
_clocks.get(player.getUniqueId()).clear();
_clocks.remove(player.getUniqueId());
}
}
@EventHandler
public void titanOwner(PlayerJoinEvent event)
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.ETERNAL))
{
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}
@EventHandler
public void onClockPickup(PlayerPickupItemEvent event)
{
for (List<Item> clocks : _clocks.values())
{
for (Item item : clocks)
{
if (event.getItem().equals(item))
event.setCancelled(true);
}
}
}
}
package mineplex.core.gadget.gadgets.taunts;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.Color;
import org.bukkit.FireworkEffect;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Item;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.util.Vector;
import mineplex.core.common.Rank;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.common.util.LineFormat;
import mineplex.core.common.util.UtilAction;
import mineplex.core.common.util.UtilFirework;
import mineplex.core.common.util.UtilText;
import mineplex.core.disguise.disguises.DisguiseSkeleton;
import mineplex.core.events.EnableArcadeSpawnEvent;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.gadget.gadgets.morph.managers.UtilMorph;
import mineplex.core.gadget.types.TauntGadget;
import mineplex.core.itemstack.ItemStackFactory;
import mineplex.core.recharge.Recharge;
import mineplex.core.updater.UpdateType;
public class EternalTaunt extends TauntGadget
{
private static final int COOLDOWN = 30000;
private static final int PVP_COOLDOWN = 10000;
private Map<UUID, List<Item>> _clocks = new HashMap<>();
public EternalTaunt(GadgetManager manager)
{
super(manager, "Eternal Taunt", UtilText.splitLinesToArray(new String[]{C.cGray + "Although the Eternal has been around forever, he waited too long for a worthy opponent and he turned to bones.",
"",
C.cWhite + "Use /taunt in game to show how long you've been waiting.",
C.cRed + "Cannot be used while in PvP!"}, LineFormat.LORE),
-15, Material.WATCH, (byte) 0);
setCanPlayWithPvp(false);
setPvpCooldown(PVP_COOLDOWN);
setShouldPlay(true);
setEventType(UpdateType.FAST);
addDisabledGames(GameType.SMASH, GameType.SMASHTEAMS, GameType.SMASHDOMINATION);
}
@Override
public void onStart(Player player)
{
if (!Recharge.Instance.use(player, getName(), COOLDOWN, true, false, "Cosmetics"))
return;
UtilFirework.playFirework(player.getLocation(), FireworkEffect.builder().with(FireworkEffect.Type.BALL_LARGE).withColor(Color.fromRGB(255, 175, 175)).withFade(Color.RED).build());
_clocks.put(player.getUniqueId(), new ArrayList<>());
Bukkit.broadcastMessage(F.main("Taunt", F.name(player.getName()) + " waited so long they turned to bones."));
DisguiseSkeleton disguiseSkeleton = new DisguiseSkeleton(player);
UtilMorph.disguise(player, disguiseSkeleton, Manager);
}
@Override
public void onPlay(Player player)
{
if (!_clocks.containsKey(player.getUniqueId()))
return;
int i = getPlayerTicks(player);
EnableArcadeSpawnEvent enableArcadeSpawnEvent = new EnableArcadeSpawnEvent(true);
Bukkit.getPluginManager().callEvent(enableArcadeSpawnEvent);
Item clock = player.getWorld().dropItem(player.getLocation().add(0.5, 1.5, 0.5),
ItemStackFactory.Instance.CreateStack(Material.WATCH, (byte) 0, 1, " " + i));
enableArcadeSpawnEvent = new EnableArcadeSpawnEvent(false);
Bukkit.getPluginManager().callEvent(enableArcadeSpawnEvent);
Vector vel = new Vector(Math.sin(i * 9/5d), 0, Math.cos(i * 9/5d));
UtilAction.velocity(clock, vel, Math.abs(Math.sin(i * 12/3000d)), false, 0, 0.2 + Math.abs(Math.cos(i * 12/3000d))*0.6, 1, false);
_clocks.get(player.getUniqueId()).add(clock);
if (_clocks.get(player.getUniqueId()).size() >= 5)
{
_clocks.get(player.getUniqueId()).get(0).remove();
_clocks.get(player.getUniqueId()).remove(0);
}
if (i % 2 == 0)
player.playSound(player.getLocation(), Sound.CLICK, 1f, 1f);
else
player.playSound(player.getLocation(), Sound.CLICK, 0.5f, 0.5f);
if (i >= 15)
{
finish(player);
}
}
@Override
public void onFinish(Player player)
{
UtilMorph.undisguise(player, Manager.getDisguiseManager());
if (_clocks.containsKey(player.getUniqueId()))
{
_clocks.get(player.getUniqueId()).forEach(c -> c.remove());
_clocks.get(player.getUniqueId()).clear();
_clocks.remove(player.getUniqueId());
}
}
@EventHandler
public void titanOwner(PlayerJoinEvent event)
{
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.ETERNAL))
{
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
}
}
@EventHandler
public void onClockPickup(PlayerPickupItemEvent event)
{
for (List<Item> clocks : _clocks.values())
{
for (Item item : clocks)
{
if (event.getItem().equals(item))
event.setCancelled(true);
}
}
}
}

168
Plugins/Mineplex.Core/src/mineplex/core/gadget/gadgets/taunts/GameType.java
View File

@ -1,84 +1,84 @@
package mineplex.core.gadget.gadgets.taunts;
public enum GameType
{
BACONBRAWL,
BARBARIANS,
BASKETBALL,
BOSSBATTLES,
BRIDGE,
CASTLESIEGE,
CHAMPIONSCTF,
CHAMPIONSDOMINATE,
CHAMPIONSTDM,
CHRISTMAS,
DEATHTAG,
DRAGONESCAPE,
DRAGONESCAPETEAMS,
DRAGONRIDERS,
DRAGONS,
DRAGONSTEAMS,
DRAW,
ELYTRARINGS,
EVOLUTION,
GRAVITY,
HALLOWEEN,
HALLOWEEN2016,
HIDESEEK,
HOLEINTHEWALL,
HORSE,
LOBBERS,
MICRO,
MILKCOW,
MINESTRIKE,
BAWKBAWKBATTLES,
MINECRAFTLEAGUE,
OLDMINEWARE,
PAINTBALL,
QUIVER,
QUIVERPAYLOAD,
QUIVERTEAMS,
RUNNER,
SEARCHANDDESTROY,
SHEEP,
TYPEWARS,
SMASH,
SMASHDOMINATION,
SMASHTEAMS,
SNAKE,
SNEAKYASSASSINS,
SNOWFIGHT,
SPEEDBUILDERS,
SPLEEF,
SPLEEFTEAMS,
SQUIDSHOOTER,
STACKER,
SURVIVALGAMES,
SURVIVALGAMESTEAMS,
TUG,
TURFWARS,
UHC,
UHCSOLO,
UHCSOLOSPEED,
UHCTEAMSSPEED,
WITHERASSAULT,
WIZARDS,
ZOMBIESURVIVAL,
BUILD,
BUILDMAVERICKS,
CARDS,
SKYWARS,
SKYWARSTEAMS,
MONSTERMAZE,
MONSTERLEAGUE,
GLADIATORS,
SKYFALL,
SKYFALLTEAMS,
BOUNCYBALLS,
VALENTINES,
EVENT,
BRAWL,
NONE
}
package mineplex.core.gadget.gadgets.taunts;
public enum GameType
{
BACONBRAWL,
BARBARIANS,
BASKETBALL,
BOSSBATTLES,
BRIDGE,
CASTLESIEGE,
CHAMPIONSCTF,
CHAMPIONSDOMINATE,
CHAMPIONSTDM,
CHRISTMAS,
DEATHTAG,
DRAGONESCAPE,
DRAGONESCAPETEAMS,
DRAGONRIDERS,
DRAGONS,
DRAGONSTEAMS,
DRAW,
ELYTRARINGS,
EVOLUTION,
GRAVITY,
HALLOWEEN,
HALLOWEEN2016,
HIDESEEK,
HOLEINTHEWALL,
HORSE,
LOBBERS,
MICRO,
MILKCOW,
MINESTRIKE,
BAWKBAWKBATTLES,
MINECRAFTLEAGUE,
OLDMINEWARE,
PAINTBALL,
QUIVER,
QUIVERPAYLOAD,
QUIVERTEAMS,
RUNNER,
SEARCHANDDESTROY,
SHEEP,
TYPEWARS,
SMASH,
SMASHDOMINATION,
SMASHTEAMS,
SNAKE,
SNEAKYASSASSINS,
SNOWFIGHT,
SPEEDBUILDERS,
SPLEEF,
SPLEEFTEAMS,
SQUIDSHOOTER,
STACKER,
SURVIVALGAMES,
SURVIVALGAMESTEAMS,
TUG,
TURFWARS,
UHC,
UHCSOLO,
UHCSOLOSPEED,
UHCTEAMSSPEED,
WITHERASSAULT,
WIZARDS,
ZOMBIESURVIVAL,
BUILD,
BUILDMAVERICKS,
CARDS,
SKYWARS,
SKYWARSTEAMS,
MONSTERMAZE,
MONSTERLEAGUE,
GLADIATORS,
SKYFALL,
SKYFALLTEAMS,
BOUNCYBALLS,
VALENTINES,
EVENT,
BRAWL,
NONE
}

326
Plugins/Mineplex.Core/src/mineplex/core/gadget/types/TauntGadget.java
View File

@ -1,163 +1,163 @@
package mineplex.core.gadget.types;
import java.time.YearMonth;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.gadget.gadgets.taunts.GameType;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
/**
* Handles Taunts
*/
public abstract class TauntGadget extends Gadget
{
/** Sets if this specific taunt can be used while in PvP */
private boolean _canPlayWithPvp = false;
/** Sets the cooldown for pvp */
private long _pvpCooldown = 0;
/** Sets if this taunt needs to run on updates */
private boolean _shouldPlay = false;
/** Sets when the taunt will run, if set above */
private UpdateType _updateType = UpdateType.TICK;
/** List of games where this item is disabled */
private List<GameType> _disabledGames = new ArrayList<>();
/** The ticks that passed since the player started the effect */
private Map<UUID, Integer> _ticksPerPlayer = new HashMap<>();
/**
* @param manager The normal GadgetManager
* @param name The name of the item
* @param desc The lore/description of the item
* @param cost The cost of the item
* @param mat The display material of the item
* @param data The display data of the item
* @param alternativeSalesPackageNames Possible alternative names for this package
*/
public TauntGadget(GadgetManager manager, String name, String[] desc, int cost, Material mat, byte data,
String... alternativeSalesPackageNames)
{
super(manager, GadgetType.TAUNT, name, desc, cost, mat, data, 1, alternativeSalesPackageNames);
}
/**
* @param manager The normal GadgetManager
* @param name The name of the item
* @param desc The lore/description of the item
* @param cost The cost of the item
* @param mat The display material of the item
* @param data The display data of the item
* @param yearMonth The year and month of this item, if it is a PPC item
* @param alternativeSalesPackageNames Possible alternative names for this package
*/
public TauntGadget(GadgetManager manager, String name, String[] desc, int cost, Material mat, byte data,
YearMonth yearMonth, String... alternativeSalesPackageNames)
{
super(manager, GadgetType.TAUNT, name, desc, cost, mat, data, yearMonth, 1, alternativeSalesPackageNames);
}
@Override
public void disableCustom(Player player, boolean message)
{
super.disableCustom(player, message);
finish(player);
}
public void start(Player player)
{
onStart(player);
_ticksPerPlayer.put(player.getUniqueId(), 0);
}
public abstract void onStart(Player player);
public void play(Player player)
{
onPlay(player);
int ticks = getPlayerTicks(player) + 1;
_ticksPerPlayer.put(player.getUniqueId(), ticks);
}
public abstract void onPlay(Player player);
public void finish(Player player)
{
onFinish(player);
_ticksPerPlayer.remove(player.getUniqueId());
}
public abstract void onFinish(Player player);
public void setCanPlayWithPvp(boolean canPlayWithPvp)
{
_canPlayWithPvp = canPlayWithPvp;
}
public void setPvpCooldown(long pvpCooldown)
{
_pvpCooldown = pvpCooldown;
}
public void setShouldPlay(boolean shouldPlay)
{
_shouldPlay = shouldPlay;
}
public void setEventType(UpdateType updateType)
{
_updateType = updateType;
}
public void addDisabledGames(GameType... disabledGames)
{
_disabledGames.addAll(Arrays.asList(disabledGames));
}
public boolean canPlayWithPvp()
{
return _canPlayWithPvp;
}
public boolean isGameDisabled(GameType gameType)
{
return _disabledGames.contains(gameType);
}
public long getPvpCooldown()
{
return _pvpCooldown;
}
public int getPlayerTicks(Player player)
{
return (_ticksPerPlayer.containsKey(player.getUniqueId())) ? _ticksPerPlayer.get(player.getUniqueId()) : -1;
}
@EventHandler
public void onUpdate(UpdateEvent event)
{
if (!_shouldPlay)
return;
if (event.getType() != _updateType)
return;
for (Player player : getActive())
{
if (_ticksPerPlayer.containsKey(player.getUniqueId()))
play(player);
}
}
}
package mineplex.core.gadget.types;
import java.time.YearMonth;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.gadget.gadgets.taunts.GameType;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
/**
* Handles Taunts
*/
public abstract class TauntGadget extends Gadget
{
/** Sets if this specific taunt can be used while in PvP */
private boolean _canPlayWithPvp = false;
/** Sets the cooldown for pvp */
private long _pvpCooldown = 0;
/** Sets if this taunt needs to run on updates */
private boolean _shouldPlay = false;
/** Sets when the taunt will run, if set above */
private UpdateType _updateType = UpdateType.TICK;
/** List of games where this item is disabled */
private List<GameType> _disabledGames = new ArrayList<>();
/** The ticks that passed since the player started the effect */
private Map<UUID, Integer> _ticksPerPlayer = new HashMap<>();
/**
* @param manager The normal GadgetManager
* @param name The name of the item
* @param desc The lore/description of the item
* @param cost The cost of the item
* @param mat The display material of the item
* @param data The display data of the item
* @param alternativeSalesPackageNames Possible alternative names for this package
*/
public TauntGadget(GadgetManager manager, String name, String[] desc, int cost, Material mat, byte data,
String... alternativeSalesPackageNames)
{
super(manager, GadgetType.TAUNT, name, desc, cost, mat, data, 1, alternativeSalesPackageNames);
}
/**
* @param manager The normal GadgetManager
* @param name The name of the item
* @param desc The lore/description of the item
* @param cost The cost of the item
* @param mat The display material of the item
* @param data The display data of the item
* @param yearMonth The year and month of this item, if it is a PPC item
* @param alternativeSalesPackageNames Possible alternative names for this package
*/
public TauntGadget(GadgetManager manager, String name, String[] desc, int cost, Material mat, byte data,
YearMonth yearMonth, String... alternativeSalesPackageNames)
{
super(manager, GadgetType.TAUNT, name, desc, cost, mat, data, yearMonth, 1, alternativeSalesPackageNames);
}
@Override
public void disableCustom(Player player, boolean message)
{
super.disableCustom(player, message);
finish(player);
}
public void start(Player player)
{
onStart(player);
_ticksPerPlayer.put(player.getUniqueId(), 0);
}
public abstract void onStart(Player player);
public void play(Player player)
{
onPlay(player);
int ticks = getPlayerTicks(player) + 1;
_ticksPerPlayer.put(player.getUniqueId(), ticks);
}
public abstract void onPlay(Player player);
public void finish(Player player)
{
onFinish(player);
_ticksPerPlayer.remove(player.getUniqueId());
}
public abstract void onFinish(Player player);
public void setCanPlayWithPvp(boolean canPlayWithPvp)
{
_canPlayWithPvp = canPlayWithPvp;
}
public void setPvpCooldown(long pvpCooldown)
{
_pvpCooldown = pvpCooldown;
}
public void setShouldPlay(boolean shouldPlay)
{
_shouldPlay = shouldPlay;
}
public void setEventType(UpdateType updateType)
{
_updateType = updateType;
}
public void addDisabledGames(GameType... disabledGames)
{
_disabledGames.addAll(Arrays.asList(disabledGames));
}
public boolean canPlayWithPvp()
{
return _canPlayWithPvp;
}
public boolean isGameDisabled(GameType gameType)
{
return _disabledGames.contains(gameType);
}
public long getPvpCooldown()
{
return _pvpCooldown;
}
public int getPlayerTicks(Player player)
{
return (_ticksPerPlayer.containsKey(player.getUniqueId())) ? _ticksPerPlayer.get(player.getUniqueId()) : -1;
}
@EventHandler
public void onUpdate(UpdateEvent event)
{
if (!_shouldPlay)
return;
if (event.getType() != _updateType)
return;
for (Player player : getActive())
{
if (_ticksPerPlayer.containsKey(player.getUniqueId()))
play(player);
}
}
}

81
Plugins/Mineplex.Core/src/mineplex/core/google/GoogleSheetsManager.java Normal file
View File

@ -0,0 +1,81 @@
package mineplex.core.google;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
@ReflectivelyCreateMiniPlugin
public class GoogleSheetsManager extends MiniPlugin
{
private static final File DATA_STORE_DIR = new File(".." + File.separatorChar + ".." + File.separatorChar + "update" + File.separatorChar + "files");
private GoogleSheetsManager()
{
super("Google Sheets");
}
public Map<String, List<List<String>>> getSheetData(String name)
{
return getSheetData(new File(DATA_STORE_DIR + File.separator + name + ".json"));
}
public Map<String, List<List<String>>> getSheetData(File file)
{
if (!file.exists())
{
return null;
}
Map<String, List<List<String>>> valuesMap = new HashMap<>();
try
{
JsonParser parser = new JsonParser();
JsonElement data = parser.parse(new FileReader(file));
JsonArray parent = data.getAsJsonObject().getAsJsonArray("data");
for (int i = 0; i < parent.size(); i++)
{
JsonObject sheet = parent.get(i).getAsJsonObject();
String name = sheet.get("name").getAsString();
JsonArray values = sheet.getAsJsonArray("values");
List<List<String>> valuesList = new ArrayList<>(values.size());
for (int j = 0; j < values.size(); j++)
{
List<String> list = new ArrayList<>();
Iterator<JsonElement> iterator = values.get(j).getAsJsonArray().iterator();
while (iterator.hasNext())
{
String value = iterator.next().getAsString();
list.add(value);
}
valuesList.add(list);
}
valuesMap.put(name, valuesList);
}
}
catch (FileNotFoundException e)
{
}
return valuesMap;
}
}

8
Plugins/Mineplex.Core/src/mineplex/core/google/SheetObjectDeserialiser.java Normal file
View File

@ -0,0 +1,8 @@
package mineplex.core.google;
public interface SheetObjectDeserialiser<T>
{
public T deserialise(String[] values) throws ArrayIndexOutOfBoundsException;
}

16
Plugins/Mineplex.Core/src/mineplex/core/itemstack/ItemBuilder.java
View File

@ -53,6 +53,7 @@ public class ItemBuilder
private int _amount;
private Color _color;
private short _data;
private short _durability;
private final HashMap<Enchantment, Integer> _enchants = new HashMap<Enchantment, Integer>();
private final List<String> _lore = new ArrayList<String>();
private Material _mat;
@ -90,6 +91,7 @@ public class ItemBuilder
_itemFlags.addAll(meta.getItemFlags());
_unbreakable = meta.spigot().isUnbreakable();
_durability = item.getDurability();
}
}
@ -108,6 +110,7 @@ public class ItemBuilder
_mat = mat;
_amount = amount;
_data = data;
_durability = 0;
}
public ItemBuilder(Material mat, short data)
@ -115,6 +118,13 @@ public class ItemBuilder
this(mat, 1, data);
}
public ItemBuilder setDurability(short durability)
{
_durability = durability;
return this;
}
public HashSet<ItemFlag> getItemFlags()
{
return _itemFlags;
@ -278,7 +288,8 @@ public class ItemBuilder
item.addUnsafeEnchantments(_enchants);
if (_glow) item.addEnchantment(UtilInv.getDullEnchantment(), 1);
if (_durability != 0) item.setDurability(_durability);
return item;
}
@ -298,7 +309,8 @@ public class ItemBuilder
newBuilder.setColor(_color);
// newBuilder.potion = potion;
newBuilder.setDurability(_durability);
return newBuilder;
}

104
Plugins/Mineplex.Core/src/mineplex/core/particleeffects/LineEffect.java
View File

@ -1,52 +1,52 @@
package mineplex.core.particleeffects;
import java.awt.Color;
import org.bukkit.Location;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.util.Vector;
import mineplex.core.common.util.UtilParticle;
import mineplex.core.common.util.particles.ColoredParticle;
import mineplex.core.common.util.particles.DustSpellColor;
public class LineEffect extends Effect
{
private int _particles = 100;
private Color _color;
private int _count = 0;
private Vector _vector;
private Location _fixedLoc;
public LineEffect(JavaPlugin plugin, Location location, Location target, Color color)
{
super(-1, new EffectLocation(location), plugin);
setTargetLocation(new EffectLocation(target));
_color = color;
}
@Override
public void runEffect()
{
Location location = _effectLocation.getFixedLocation().clone().add(0, 1, 0);
if (_vector == null)
{
Location targetLoc = getTargetLocation().getFixedLocation().clone();
Vector link = targetLoc.toVector().subtract(location.toVector());
float length = (float) link.length();
link.normalize();
Vector vector = link.multiply(length / _particles);
_vector = vector;
_fixedLoc = location.clone().subtract(_vector);
}
ColoredParticle coloredParticle = new ColoredParticle(UtilParticle.ParticleType.RED_DUST,
new DustSpellColor(_color), _effectLocation.getLocation().clone());
_fixedLoc.add(_vector);
if (_count == _particles)
{
stop();
}
}
}
package mineplex.core.particleeffects;
import java.awt.Color;
import org.bukkit.Location;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.util.Vector;
import mineplex.core.common.util.UtilParticle;
import mineplex.core.common.util.particles.ColoredParticle;
import mineplex.core.common.util.particles.DustSpellColor;
public class LineEffect extends Effect
{
private int _particles = 100;
private Color _color;
private int _count = 0;
private Vector _vector;
private Location _fixedLoc;
public LineEffect(JavaPlugin plugin, Location location, Location target, Color color)
{
super(-1, new EffectLocation(location), plugin);
setTargetLocation(new EffectLocation(target));
_color = color;
}
@Override
public void runEffect()
{
Location location = _effectLocation.getFixedLocation().clone().add(0, 1, 0);
if (_vector == null)
{
Location targetLoc = getTargetLocation().getFixedLocation().clone();
Vector link = targetLoc.toVector().subtract(location.toVector());
float length = (float) link.length();
link.normalize();
Vector vector = link.multiply(length / _particles);
_vector = vector;
_fixedLoc = location.clone().subtract(_vector);
}
ColoredParticle coloredParticle = new ColoredParticle(UtilParticle.ParticleType.RED_DUST,
new DustSpellColor(_color), _effectLocation.getLocation().clone());
_fixedLoc.add(_vector);
if (_count == _particles)
{
stop();
}
}
}

8
Plugins/Mineplex.Core/src/mineplex/core/pet/PetManager.java
View File

@ -169,8 +169,12 @@ public class PetManager extends MiniClientPlugin<PetClient>
if (player != null && player.isOnline())
{
getActivePet(playerName).setCustomNameVisible(true);
getActivePet(playerName).setCustomName(_petRenameQueue.get(playerName));
Creature activePet = getActivePet(playerName);
if (activePet != null)
{
activePet.setCustomNameVisible(true);
activePet.setCustomName(_petRenameQueue.get(playerName));
}
}
}

0
Plugins/Mineplex.Core/src/mineplex/core/portal/commands/SendCommand.java → Plugins/Mineplex.Core/src/mineplex/core/portal/Commands/SendCommand.java
View File

0
Plugins/Mineplex.Core/src/mineplex/core/portal/commands/ServerCommand.java → Plugins/Mineplex.Core/src/mineplex/core/portal/Commands/ServerCommand.java
View File

7
Plugins/Mineplex.Core/src/mineplex/core/portal/GenericServer.java
View File

@ -12,7 +12,12 @@ public enum GenericServer
/**
* The Clans Hubs, such as ClansHub-1
*/
CLANS_HUB("ClansHub");
CLANS_HUB("ClansHub"),
/**
* The Beta Hubs, such as BetaHub-1
*/
BETA_HUB("BetaHub"),
;
private final String _name;

1
Plugins/Mineplex.Core/src/mineplex/core/powerplayclub/PowerPlayClubRewards.java
View File

@ -35,6 +35,7 @@ public class PowerPlayClubRewards
.put(YearMonth.of(2016, Month.DECEMBER), new UnknownSalesPackageItem("Santa Morph"))
.put(YearMonth.of(2017, Month.JANUARY), new UnknownSalesPackageItem("Over Easy Morph"))
.put(YearMonth.of(2017, Month.FEBRUARY), new PetItem(PetType.TRUE_LOVE_PET))
.put(YearMonth.of(2017, Month.MARCH), new UnknownSalesPackageItem("Gold Pot Morph"))
.build();
public interface PowerPlayClubItem

36
Plugins/Mineplex.Core/src/mineplex/core/recharge/Recharge.java
View File

@ -12,8 +12,6 @@ import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.core.MiniPlugin;
import mineplex.core.updater.event.UpdateEvent;
import mineplex.core.updater.UpdateType;
import mineplex.core.account.event.ClientUnloadEvent;
import mineplex.core.common.util.F;
import mineplex.core.common.util.NautHashMap;
@ -21,6 +19,8 @@ import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.common.util.UtilTime;
import mineplex.core.common.util.UtilTime.TimeUnit;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
public class Recharge extends MiniPlugin
{
@ -207,10 +207,23 @@ public class Recharge extends MiniPlugin
}
public boolean usable(Player player, String ability, boolean inform)
{
return usable(player, ability, inform, null);
}
/**
* Checks if cooldown is over, using a custom message or not
* @param player The player to be checked
* @param ability The ability to be checked
* @param inform Should it inform the player?
* @param message The custom message (if NULL, default message will be shown)
* @return If the ability is in cooldown or not for that player
*/
public boolean usable(Player player, String ability, boolean inform, String message)
{
if (!Get(player).containsKey(ability))
return true;
if (Get(player).get(ability).GetRemaining() <= 0)
{
return true;
@ -218,9 +231,20 @@ public class Recharge extends MiniPlugin
else
{
if (inform && !Get(player).get(ability).DisplayForce && !Get(player).get(ability).AttachItem)
UtilPlayer.message(player, F.main("Recharge", "You cannot use " + F.skill(ability) + " for " +
F.time(UtilTime.convertString((Get(player).get(ability).GetRemaining()), 1, TimeUnit.FIT)) + "."));
{
if (message == null)
{
UtilPlayer.message(player, F.main("Recharge", "You cannot use " + F.skill(ability) + " for " +
F.time(UtilTime.convertString((Get(player).get(ability).GetRemaining()), 1, TimeUnit.FIT)) + "."));
}
else
{
UtilPlayer.message(player, F.main("Recharge", message.replace("%a", F.skill(ability))
.replace("%t", F.time(UtilTime.convertString(Get(player).get(ability).GetRemaining(),
1, TimeUnit.FIT)))));
}
}
return false;
}
}

49
Plugins/Mineplex.Core/src/mineplex/core/sponsorbranding/BrandingManager.java
View File

@ -3,28 +3,29 @@ package mineplex.core.sponsorbranding;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.ConcurrentHashMap;
import javax.imageio.ImageIO;
import mineplex.core.MiniPlugin;
import org.bukkit.Location;
import org.bukkit.block.BlockFace;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
/**
*
* Manager for creating billboards with branding logos
*/
@ReflectivelyCreateMiniPlugin
public class BrandingManager extends MiniPlugin
{
private ConcurrentHashMap<Integer, BrandingPost> _posts = new ConcurrentHashMap<Integer, BrandingPost>();
private ConcurrentHashMap<String, BufferedImage> _imgCache = new ConcurrentHashMap<String, BufferedImage>();
public BrandingManager(JavaPlugin plugin)
private BrandingManager()
{
super("Branding Manager", plugin);
super("Branding Manager");
}
private BufferedImage getImage(String fileName)
@ -56,6 +57,28 @@ public class BrandingManager extends MiniPlugin
return image;
}
private BufferedImage getImage(URL url)
{
if (_imgCache.containsKey(url.toString()))
{
return _imgCache.get(url.toString());
}
BufferedImage image = null;
try
{
image = ImageIO.read(url);
_imgCache.put(url.toString(), image);
}
catch (IOException e)
{
e.printStackTrace();
}
return image;
}
/**
* Generates a billboard with a stored logo
* @param location The center of the billboard
@ -75,6 +98,22 @@ public class BrandingManager extends MiniPlugin
_posts.put(_posts.size(), bp);
}
public void createPost(Location location, BlockFace facing, URL url)
{
BufferedImage image = getImage(url);
if (image == null)
{
System.out.println("ERROR! Invalid image url!");
return;
}
BrandingPost brandingPost = new BrandingPost(location, facing, image);
brandingPost.spawn();
// Umm why not use a List?
_posts.put(_posts.size(), brandingPost);
}
/**
* Clears away all existing billboards
*/

3
Plugins/Mineplex.Core/src/mineplex/core/sponsorbranding/BrandingPost.java
View File

@ -68,6 +68,8 @@ public class BrandingPost
int width = (int) Math.ceil(_img.getWidth() / 128);
int height = (int) Math.ceil(_img.getHeight() / 128);
Bukkit.broadcastMessage("width=" + width + " height=" + height);
switch (_facing)
{
case EAST:
@ -160,6 +162,7 @@ public class BrandingPost
ItemStack item = getMapItem(x, y, _img);
i.setItem(item);
Bukkit.broadcastMessage(x + " <- X Y -> " + y);
_ents.add(i);
}
}

3
Plugins/Mineplex.Core/src/mineplex/core/treasure/TreasureLocation.java
View File

@ -325,7 +325,8 @@ public class TreasureLocation implements Listener
event.setTo(newTo);
}
}
else
else if (event.getFrom().getWorld().equals(_currentTreasure.getCenterBlock().getWorld()) &&
event.getTo().getWorld().equals(_currentTreasure.getCenterBlock().getWorld()))
{
Location fromLocation = event.getFrom();
Location toLocation = event.getTo();

70
Plugins/Mineplex.Core/src/mineplex/core/treasure/gui/TreasurePageItem.java
View File

@ -1,35 +1,35 @@
package mineplex.core.treasure.gui;
import org.bukkit.inventory.ItemStack;
import mineplex.core.treasure.TreasureType;
public class TreasurePageItem
{
private final ItemStack _item;
private final int _count;
private final TreasureType _treasureType;
public TreasurePageItem(ItemStack item, int count, TreasureType treasureType)
{
_item = item;
_count = count;
_treasureType = treasureType;
}
public ItemStack getItem()
{
return _item;
}
public int getCount()
{
return _count;
}
public TreasureType getTreasureType()
{
return _treasureType;
}
}
package mineplex.core.treasure.gui;
import org.bukkit.inventory.ItemStack;
import mineplex.core.treasure.TreasureType;
public class TreasurePageItem
{
private final ItemStack _item;
private final int _count;
private final TreasureType _treasureType;
public TreasurePageItem(ItemStack item, int count, TreasureType treasureType)
{
_item = item;
_count = count;
_treasureType = treasureType;
}
public ItemStack getItem()
{
return _item;
}
public int getCount()
{
return _count;
}
public TreasureType getTreasureType()
{
return _treasureType;
}
}

64
Plugins/Mineplex.Core/src/mineplex/core/treasure/gui/pages/NextPageButton.java
View File

@ -1,32 +1,32 @@
package mineplex.core.treasure.gui.pages;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import mineplex.core.shop.item.IButton;
import mineplex.core.treasure.gui.TreasurePage;
public class NextPageButton implements IButton
{
private TreasurePage _treasurePage;
private Player _player;
public NextPageButton(TreasurePage treasurePage, Player player)
{
_treasurePage = treasurePage;
_player = player;
}
@Override
public void onClick(Player player, ClickType clickType)
{
if (_player != player)
return;
player.closeInventory();
TreasurePage nextPage = new TreasurePage(_treasurePage.getTreasureManager(), _treasurePage.getTreasureShop(), _treasurePage.getTreasureLocation(),
_treasurePage.getClientManager(), _treasurePage.getDonationManager(), _treasurePage.getInventoryManager(),
_treasurePage.getGadgetManager(), _player, _treasurePage.getActualPage() + 1);
_treasurePage.getTreasureShop().openPageForPlayer(player, nextPage);
}
}
package mineplex.core.treasure.gui.pages;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import mineplex.core.shop.item.IButton;
import mineplex.core.treasure.gui.TreasurePage;
public class NextPageButton implements IButton
{
private TreasurePage _treasurePage;
private Player _player;
public NextPageButton(TreasurePage treasurePage, Player player)
{
_treasurePage = treasurePage;
_player = player;
}
@Override
public void onClick(Player player, ClickType clickType)
{
if (_player != player)
return;
player.closeInventory();
TreasurePage nextPage = new TreasurePage(_treasurePage.getTreasureManager(), _treasurePage.getTreasureShop(), _treasurePage.getTreasureLocation(),
_treasurePage.getClientManager(), _treasurePage.getDonationManager(), _treasurePage.getInventoryManager(),
_treasurePage.getGadgetManager(), _player, _treasurePage.getActualPage() + 1);
_treasurePage.getTreasureShop().openPageForPlayer(player, nextPage);
}
}

66
Plugins/Mineplex.Core/src/mineplex/core/treasure/gui/pages/PreviousPageButton.java
View File

@ -1,33 +1,33 @@
package mineplex.core.treasure.gui.pages;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import mineplex.core.shop.item.IButton;
import mineplex.core.treasure.gui.TreasurePage;
public class PreviousPageButton implements IButton
{
private TreasurePage _treasurePage;
private Player _player;
public PreviousPageButton(TreasurePage treasurePage, Player player)
{
_treasurePage = treasurePage;
_player = player;
}
@Override
public void onClick(Player player, ClickType clickType)
{
if (_player != player)
return;
player.closeInventory();
TreasurePage previousPage = new TreasurePage(_treasurePage.getTreasureManager(), _treasurePage.getTreasureShop(), _treasurePage.getTreasureLocation(),
_treasurePage.getClientManager(), _treasurePage.getDonationManager(), _treasurePage.getInventoryManager(),
_treasurePage.getGadgetManager(), _player, _treasurePage.getActualPage() - 1);
_treasurePage.getTreasureShop().openPageForPlayer(player, previousPage);
}
}
package mineplex.core.treasure.gui.pages;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.ClickType;
import mineplex.core.shop.item.IButton;
import mineplex.core.treasure.gui.TreasurePage;
public class PreviousPageButton implements IButton
{
private TreasurePage _treasurePage;
private Player _player;
public PreviousPageButton(TreasurePage treasurePage, Player player)
{
_treasurePage = treasurePage;
_player = player;
}
@Override
public void onClick(Player player, ClickType clickType)
{
if (_player != player)
return;
player.closeInventory();
TreasurePage previousPage = new TreasurePage(_treasurePage.getTreasureManager(), _treasurePage.getTreasureShop(), _treasurePage.getTreasureLocation(),
_treasurePage.getClientManager(), _treasurePage.getDonationManager(), _treasurePage.getInventoryManager(),
_treasurePage.getGadgetManager(), _player, _treasurePage.getActualPage() - 1);
_treasurePage.getTreasureShop().openPageForPlayer(player, previousPage);
}
}

16
Plugins/Mineplex.Core/src/mineplex/core/updater/FileUpdater.java
View File

@ -6,10 +6,6 @@ import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Properties;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Intent;
import mineplex.core.updater.command.BuildVersionCommand;
import mineplex.core.updater.command.RestartServerCommand;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
@ -24,7 +20,11 @@ import mineplex.core.MiniPlugin;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.common.util.NautHashMap;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Intent;
import mineplex.core.portal.Portal;
import mineplex.core.updater.command.BuildVersionCommand;
import mineplex.core.updater.command.RestartServerCommand;
import mineplex.core.updater.event.RestartServerEvent;
import mineplex.core.updater.event.UpdateEvent;
import mineplex.serverdata.Region;
@ -38,19 +38,21 @@ public class FileUpdater extends MiniPlugin
private String _serverName;
private Region _region;
private final GenericServer _transferHub;
private boolean _needUpdate;
private boolean _enabled = true;
private Properties _buildProperties;
public FileUpdater(JavaPlugin plugin, Portal portal, String serverName, Region region)
public FileUpdater(JavaPlugin plugin, Portal portal, String serverName, Region region, GenericServer transferHub)
{
super("File Updater", plugin);
_portal = portal;
_serverName = serverName;
_region = region;
_transferHub = transferHub;
GetPluginMd5s();
@ -81,7 +83,7 @@ public class FileUpdater extends MiniPlugin
for (Player player : Bukkit.getOnlinePlayers())
{
player.sendMessage(F.main("Updater", message));
_portal.sendPlayerToGenericServer(player, GenericServer.HUB, Intent.KICK);
_portal.sendPlayerToGenericServer(player, _transferHub, Intent.KICK);
}
}
}
@ -110,7 +112,7 @@ public class FileUpdater extends MiniPlugin
{
public void run()
{
_portal.sendAllPlayersToGenericServer(GenericServer.HUB, Intent.KICK);
_portal.sendAllPlayersToGenericServer(_transferHub, Intent.KICK);
}
}, 60L);

5
Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/Clans.java
View File

@ -46,6 +46,7 @@ import mineplex.core.memory.MemoryFix;
import mineplex.core.message.MessageManager;
import mineplex.core.monitor.LagMeter;
import mineplex.core.packethandler.PacketHandler;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Portal;
import mineplex.core.preferences.PreferencesManager;
import mineplex.core.punish.Punish;
@ -131,7 +132,7 @@ public class Clans extends JavaPlugin
Teleport teleport = new Teleport(this, _clientManager);
Portal portal = new Portal();
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion());
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion(), GenericServer.CLANS_HUB);
ClansBanManager clansBans = new ClansBanManager(this, _clientManager, _donationManager);
@ -222,7 +223,7 @@ public class Clans extends JavaPlugin
}
}
BlockRestore blockRestore = new BlockRestore(this);
BlockRestore blockRestore = require(BlockRestore.class);
IgnoreManager ignoreManager = new IgnoreManager(this, _clientManager, preferenceManager, portal);

14
Plugins/Mineplex.Hub.Clans/src/mineplex/clanshub/ClansHub.java
View File

@ -4,7 +4,6 @@ import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.core.common.Constants;
import mineplex.core.CustomTagFix;
import mineplex.core.PacketsInteractionFix;
import mineplex.core.account.CoreClientManager;
@ -39,6 +38,7 @@ import mineplex.core.packethandler.PacketHandler;
import mineplex.core.party.PartyManager;
import mineplex.core.pet.PetManager;
import mineplex.core.poll.PollManager;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Portal;
import mineplex.core.preferences.PreferencesManager;
import mineplex.core.profileCache.ProfileCacheManager;
@ -71,14 +71,18 @@ import static mineplex.core.Managers.require;
*/
public class ClansHub extends JavaPlugin
{
private String WEB_CONFIG = "webServer";
@Override
public void onEnable()
{
Bukkit.setSpawnRadius(0);
getConfig().addDefault(Constants.WEB_CONFIG_KEY, Constants.WEB_ADDRESS);
getConfig().set(Constants.WEB_CONFIG_KEY, getConfig().getString(Constants.WEB_CONFIG_KEY));
getConfig().addDefault(WEB_CONFIG, "http://accounts.mineplex.com/");
getConfig().set(WEB_CONFIG, getConfig().getString(WEB_CONFIG));
saveConfig();
String webServerAddress = getConfig().getString(WEB_CONFIG);
//Logger.initialize(this);
//Velocity Fix
@ -95,7 +99,7 @@ public class ClansHub extends JavaPlugin
Recharge.Initialize(this);
VisibilityManager.Initialize(this); Give.Initialize(this);
Punish punish = new Punish(this, clientManager);
BlockRestore blockRestore = new BlockRestore(this);
BlockRestore blockRestore = require(BlockRestore.class);
DonationManager donationManager = require(DonationManager.class);
ServerConfiguration serverConfiguration = new ServerConfiguration(this, clientManager);
@ -153,7 +157,7 @@ public class ClansHub extends JavaPlugin
Chat chat = new Chat(this, incognito, clientManager, preferenceManager, achievementManager, serverStatusManager.getCurrentServerName());
new MessageManager(this, incognito, clientManager, preferenceManager, ignoreManager, punish, friendManager, chat);
new MemoryFix(this);
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion());
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion(), GenericServer.CLANS_HUB);
new CustomTagFix(this, packetHandler);
new PacketsInteractionFix(this, packetHandler);
new ResourcePackManager(this, portal);

9
Plugins/Mineplex.Hub/src/mineplex/hub/Hub.java
View File

@ -5,7 +5,6 @@ import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import mineplex.core.common.Constants;
import mineplex.core.CustomTagFix;
import mineplex.core.PacketsInteractionFix;
import mineplex.core.account.CoreClientManager;
@ -22,6 +21,7 @@ import mineplex.core.chatsnap.SnapshotManager;
import mineplex.core.chatsnap.SnapshotPlugin;
import mineplex.core.chatsnap.SnapshotRepository;
import mineplex.core.command.CommandCenter;
import mineplex.core.common.Constants;
import mineplex.core.common.events.ServerShutdownEvent;
import mineplex.core.creature.Creature;
import mineplex.core.customdata.CustomDataManager;
@ -47,6 +47,7 @@ import mineplex.core.party.PartyManager;
import mineplex.core.personalServer.PersonalServerManager;
import mineplex.core.pet.PetManager;
import mineplex.core.poll.PollManager;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Portal;
import mineplex.core.preferences.PreferencesManager;
import mineplex.core.profileCache.ProfileCacheManager;
@ -116,7 +117,7 @@ public class Hub extends JavaPlugin implements IRelation
Recharge.Initialize(this);
VisibilityManager.Initialize(this); Give.Initialize(this);
Punish punish = new Punish(this, clientManager);
BlockRestore blockRestore = new BlockRestore(this);
BlockRestore blockRestore = require(BlockRestore.class);
DonationManager donationManager = require(DonationManager.class);
ServerConfiguration serverConfiguration = new ServerConfiguration(this, clientManager);
@ -182,7 +183,7 @@ public class Hub extends JavaPlugin implements IRelation
Chat chat = new Chat(this, incognito, clientManager, preferenceManager, achievementManager, serverStatusManager.getCurrentServerName());
new MessageManager(this, incognito, clientManager, preferenceManager, ignoreManager, punish, friendManager, chat);
new MemoryFix(this);
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion());
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion(), GenericServer.HUB);
new CustomTagFix(this, packetHandler);
new PacketsInteractionFix(this, packetHandler);
new ResourcePackManager(this, portal);
@ -225,7 +226,7 @@ public class Hub extends JavaPlugin implements IRelation
//Updates
getServer().getScheduler().scheduleSyncRepeatingTask(this, new Updater(this), 1, 1);
BrandingManager brandingManager = new BrandingManager(this);
BrandingManager brandingManager = require(BrandingManager.class);
new BillboardManager(this, brandingManager);
require(TrackManager.class);

3
Plugins/Mineplex.Hub/src/mineplex/hub/modules/BillboardManager.java
View File

@ -4,9 +4,6 @@ import mineplex.core.MiniPlugin;
import mineplex.core.common.events.ServerShutdownEvent;
import mineplex.core.sponsorbranding.BrandingManager;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.ItemFrame;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageEvent;

3
Plugins/Mineplex.Hub/src/mineplex/hub/modules/NewsManager.java
View File

@ -253,6 +253,9 @@ public class NewsManager extends MiniPlugin
{
if (event.getType() != UpdateType.FASTEST)
return;
if (_news.length == 0)
return;
String text = "";
double healthPercent = 1;

21
Plugins/Mineplex.StaffServer/src/mineplex/staffServer/StaffServer.java
View File

@ -1,12 +1,21 @@
package mineplex.staffServer;
import java.util.UUID;
import net.minecraft.server.v1_8_R3.MinecraftServer;
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.v1_8_R3.CraftServer;
import org.bukkit.plugin.java.JavaPlugin;
import org.spigotmc.SpigotConfig;
import com.mojang.authlib.GameProfile;
import mineplex.core.common.Constants;
import mineplex.core.account.CoreClientManager;
import mineplex.core.achievement.AchievementManager;
import mineplex.core.chat.Chat;
import mineplex.core.command.CommandCenter;
import mineplex.core.common.Constants;
import mineplex.core.common.Rank;
import mineplex.core.creature.Creature;
import mineplex.core.disguise.DisguiseManager;
@ -17,6 +26,7 @@ import mineplex.core.memory.MemoryFix;
import mineplex.core.monitor.LagMeter;
import mineplex.core.npc.NpcManager;
import mineplex.core.packethandler.PacketHandler;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Portal;
import mineplex.core.powerplayclub.PowerPlayClubRepository;
import mineplex.core.preferences.PreferencesManager;
@ -29,13 +39,6 @@ import mineplex.core.updater.FileUpdater;
import mineplex.core.updater.Updater;
import mineplex.staffServer.customerSupport.CustomerSupport;
import mineplex.staffServer.salespackage.SalesPackageManager;
import net.minecraft.server.v1_8_R3.MinecraftServer;
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.v1_8_R3.CraftServer;
import org.bukkit.plugin.java.JavaPlugin;
import org.spigotmc.SpigotConfig;
import java.util.UUID;
import static mineplex.core.Managers.require;
@ -67,7 +70,7 @@ public class StaffServer extends JavaPlugin
StatsManager statsManager = new StatsManager(this, clientManager);
new Chat(this, null, clientManager, preferenceManager, new AchievementManager(statsManager, clientManager, donationManager, null, eloManager), serverStatusManager.getCurrentServerName());
new MemoryFix(this);
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion());
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion(), GenericServer.HUB);
require(PacketHandler.class);
require(DisguiseManager.class);

38
Plugins/Mineplex.StaffServer/src/mineplex/staffServer/salespackage/salespackages/MinestrikeChest.java
View File

@ -1,20 +1,20 @@
package mineplex.staffServer.salespackage.salespackages;
import org.bukkit.entity.Player;
import mineplex.staffServer.salespackage.SalesPackageManager;
public class MinestrikeChest extends SalesPackageBase
{
public MinestrikeChest(SalesPackageManager manager)
{
super(manager, "1 Minestrike Chest");
}
public void displayToAgent(Player agent, String playerName)
{
addButton(agent, "/sales item " + playerName + " 1 Item Minestrike Chest", "Give 1 Minestrike Chest.");
agent.sendMessage(" ");
addBackButton(agent, playerName);
}
package mineplex.staffServer.salespackage.salespackages;
import org.bukkit.entity.Player;
import mineplex.staffServer.salespackage.SalesPackageManager;
public class MinestrikeChest extends SalesPackageBase
{
public MinestrikeChest(SalesPackageManager manager)
{
super(manager, "1 Minestrike Chest");
}
public void displayToAgent(Player agent, String playerName)
{
addButton(agent, "/sales item " + playerName + " 1 Item Minestrike Chest", "Give 1 Minestrike Chest.");
agent.sendMessage(" ");
addBackButton(agent, playerName);
}
}

315
Plugins/Nautilus.Game.Arcade.UHC.WorldGen/src/nautilus/game/arcade/uhc/WorldGen.java
View File

@ -1,69 +1,138 @@
package nautilus.game.arcade.uhc;
import net.minecraft.server.v1_8_R3.BiomeBase;
import org.apache.commons.io.FileUtils;
import org.bukkit.Bukkit;
import org.bukkit.Difficulty;
import org.bukkit.World;
import org.bukkit.WorldCreator;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.spigotmc.WatchdogThread;
import org.zeroturnaround.zip.ZipEntrySource;
import org.zeroturnaround.zip.ZipUtil;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;
import java.util.logging.Level;
import java.util.zip.ZipEntry;
public class WorldGen extends JavaPlugin implements Runnable, Listener
import net.minecraft.server.v1_8_R3.BiomeBase;
import org.apache.commons.io.FileUtils;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.Difficulty;
import org.bukkit.World;
import org.bukkit.WorldBorder;
import org.bukkit.WorldCreator;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.craftbukkit.v1_8_R3.CraftWorld;
import org.bukkit.entity.Entity;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
import org.bukkit.event.world.ChunkUnloadEvent;
import org.bukkit.event.world.WorldInitEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.spigotmc.WatchdogThread;
import org.zeroturnaround.zip.ByteSource;
import org.zeroturnaround.zip.FileSource;
import org.zeroturnaround.zip.ZipEntrySource;
import org.zeroturnaround.zip.ZipUtil;
import org.zeroturnaround.zip.commons.IOUtils;
public class WorldGen extends JavaPlugin implements Listener
{
private static final int MIN_X = -1000;
private static final int MIN_Z = -1000;
private static final int MAX_X = 1000;
private static final int MAX_Z = 1000;
// The world will be -MAP_SIZE to MAP_SIZE large
private static final int MAP_SIZE = 1000;
private static final int VIEW_DISTANCE = 5;
private static final String API_HOST_FILE = "api-config.dat";
private static final Map<String, String> API_HOST_MAP = new HashMap<>();
static
{
try
{
File configFile = new File(API_HOST_FILE);
YamlConfiguration configuration = YamlConfiguration.loadConfiguration(configFile);
for (String key : configuration.getKeys(false))
{
String ip = configuration.getConfigurationSection(key).getString("ip");
// Use parseInt to catch non-ints instead of a 0
int port = Integer.parseInt(configuration.getConfigurationSection(key).getString("port"));
if (ip == null)
{
throw new NullPointerException();
}
API_HOST_MAP.put(key, ip + ":" + port);
}
}
catch (Throwable t)
{
t.printStackTrace();
}
}
@EventHandler
public void login(AsyncPlayerPreLoginEvent event)
{
event.setKickMessage("get out");
event.setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
}
@EventHandler
public void unload(ChunkUnloadEvent event)
{
event.setCancelled(true);
}
@EventHandler
public void init(WorldInitEvent event)
{
// Prevent any eager generation
event.getWorld().setKeepSpawnInMemory(false);
}
@Override
public void onEnable()
{
getLogger().info("Cleaning up other worlds");
for (World world : getServer().getWorlds())
{
world.setKeepSpawnInMemory(false);
world.setSpawnFlags(false, false);
world.setAmbientSpawnLimit(0);
world.setAnimalSpawnLimit(0);
world.setMonsterSpawnLimit(0);
world.setWaterAnimalSpawnLimit(0);
world.getEntities().forEach(Entity::remove);
for (Chunk chunk : world.getLoadedChunks())
{
chunk.unload(false, false);
}
getServer().unloadWorld(world, false);
getLogger().info("Unloaded " + world.getName());
}
getLogger().info("Replacing biomes");
BiomeBase.getBiomes()[BiomeBase.OCEAN.id] = BiomeBase.PLAINS;
BiomeBase.getBiomes()[BiomeBase.DEEP_OCEAN.id] = BiomeBase.PLAINS;
BiomeBase.getBiomes()[BiomeBase.SWAMPLAND.id] = BiomeBase.PLAINS;
BiomeBase.getBiomes()[BiomeBase.RIVER.id] = BiomeBase.PLAINS;
getLogger().info("Forcing system GC");
System.gc();
WatchdogThread.doStop();
getServer().getScheduler().runTaskTimer(this, this, 20L, 20L * 5L);
getServer().getPluginManager().registerEvents(this, this);
}
@EventHandler
public void onJoin(AsyncPlayerPreLoginEvent event)
{
event.setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
event.setKickMessage("Shoo, go away");
}
@Override
public void run()
{
File root = new File(".");
if (!root.exists())
{
getLogger().severe("Root folder does not exist. Aborting");
getServer().shutdown();
System.exit(0);
return;
}
@ -73,7 +142,7 @@ public class WorldGen extends JavaPlugin implements Runnable, Listener
if (!outputDirectory.mkdir())
{
getLogger().severe("Could not create output folder. Aborting");
getServer().shutdown();
System.exit(0);
return;
}
}
@ -85,6 +154,7 @@ public class WorldGen extends JavaPlugin implements Runnable, Listener
if (outputFile.exists())
{
getLogger().info("Seed " + seed + " has already been generated. Skipping");
System.exit(0);
return;
}
@ -93,30 +163,52 @@ public class WorldGen extends JavaPlugin implements Runnable, Listener
if (!outputFile.createNewFile())
{
getLogger().severe("Could not create new output file. Aborting");
getServer().shutdown();
System.exit(0);
return;
}
}
catch (IOException e)
{
getLogger().log(Level.SEVERE, "Could not create new output file. Aborting", e);
getServer().shutdown();
System.exit(0);
return;
}
File previousSession = new File("generating");
if (previousSession.exists())
{
if (!FileUtils.deleteQuietly(previousSession))
{
getLogger().severe("Could not delete previous generation session. Aborting");
System.exit(0);
return;
}
}
getLogger().info("Generating world seed " + seed);
World world = new WorldCreator("generating")
.environment(World.Environment.NORMAL)
.seed(seed)
.createWorld();
world.setDifficulty(Difficulty.HARD);
world.setKeepSpawnInMemory(false);
world.setDifficulty(Difficulty.HARD);
WorldBorder border = world.getWorldBorder();
border.setCenter(0.0, 0.0);
border.setSize(MAP_SIZE * 2);
int minChunkX = (MIN_X >> 4) - VIEW_DISTANCE;
int minChunkZ = (MIN_Z >> 4) - VIEW_DISTANCE;
int maxChunkX = (MAX_X >> 4) + VIEW_DISTANCE;
int maxChunkZ = (MAX_Z >> 4) + VIEW_DISTANCE;
int minChunkX = (-MAP_SIZE >> 4) - VIEW_DISTANCE;
int minChunkZ = (-MAP_SIZE >> 4) - VIEW_DISTANCE;
int maxChunkX = (MAP_SIZE >> 4) + VIEW_DISTANCE;
int maxChunkZ = (MAP_SIZE >> 4) + VIEW_DISTANCE;
net.minecraft.server.v1_8_R3.WorldServer nmsWorld = ((CraftWorld) world).getHandle();
//
// Field mfield = nmsWorld.getClass().getDeclaredField("M");
// mfield.setAccessible(true);
//
// HashTreeSet<NextTickListEntry> treeSet = ((HashTreeSet) mfield.get(nmsWorld));
for (int x = minChunkX; x <= maxChunkX; x++)
{
@ -124,7 +216,15 @@ public class WorldGen extends JavaPlugin implements Runnable, Listener
for (int z = minChunkZ; z <= maxChunkZ; z++)
{
world.getChunkAt(x, z).load(true);
nmsWorld.a(true);
// Manually tick blocks - this should be the equivalent of letting a full server tick run once
// between each chunk generation, except we cut out the extra useless stuff
}
// System.out.println("M: " + treeSet.size());
// System.out.println("E: " + nmsWorld.entityList.size());
// System.out.println("TE: " + nmsWorld.tileEntityList.size());
// System.out.println("C: " + nmsWorld.chunkProviderServer.chunks.size());
}
for (int x = minChunkX; x <= maxChunkX; x++)
@ -134,6 +234,11 @@ public class WorldGen extends JavaPlugin implements Runnable, Listener
{
world.getChunkAt(x, z).unload(true, false);
}
// System.out.println("M: " + treeSet.size());
// System.out.println("E: " + nmsWorld.entityList.size());
// System.out.println("TE: " + nmsWorld.tileEntityList.size());
// System.out.println("C: " + nmsWorld.chunkProviderServer.chunks.size());
}
getLogger().info("Unloading and saving world");
@ -145,10 +250,10 @@ public class WorldGen extends JavaPlugin implements Runnable, Listener
StringBuilder worldconfig = new StringBuilder();
worldconfig.append("MAP_NAME:UHC World").append(System.lineSeparator());
worldconfig.append("MAP_AUTHOR:Mineplex").append(System.lineSeparator());
worldconfig.append("MIN_X:").append(MIN_X).append(System.lineSeparator());
worldconfig.append("MIN_Z:").append(MIN_Z).append(System.lineSeparator());
worldconfig.append("MAX_X:").append(MAX_X).append(System.lineSeparator());
worldconfig.append("MAX_Z:").append(MAX_Z).append(System.lineSeparator());
worldconfig.append("MIN_X:").append(-MAP_SIZE).append(System.lineSeparator());
worldconfig.append("MIN_Z:").append(-MAP_SIZE).append(System.lineSeparator());
worldconfig.append("MAX_X:").append(MAP_SIZE).append(System.lineSeparator());
worldconfig.append("MAX_Z:").append(MAP_SIZE).append(System.lineSeparator());
for (int i = 1; i <= 60; i++)
{
worldconfig.append("TEAM_NAME:").append(i).append(System.lineSeparator());
@ -164,82 +269,68 @@ public class WorldGen extends JavaPlugin implements Runnable, Listener
if (regionFiles == null)
{
getLogger().severe("Unexpected null region files. Aborting");
getServer().shutdown();
System.exit(0);
return;
}
List<ZipEntrySource> zipEntrySourceList = new ArrayList<>();
zipEntrySourceList.add(new ZipEntrySource()
{
@Override
public String getPath()
{
return "WorldConfig.dat";
}
@Override
public ZipEntry getEntry()
{
return new ZipEntry(getPath());
}
@Override
public InputStream getInputStream() throws IOException
{
return new ByteArrayInputStream(worldconfig.toString().getBytes(StandardCharsets.UTF_8));
}
});
zipEntrySourceList.add(new ByteSource("WorldConfig.dat", worldconfig.toString().getBytes(StandardCharsets.UTF_8)));
for (File file : regionFiles)
{
zipEntrySourceList.add(new ZipEntrySource()
{
@Override
public String getPath()
{
return "region/" + file.getName();
}
@Override
public ZipEntry getEntry()
{
return new ZipEntry(getPath());
}
@Override
public InputStream getInputStream() throws IOException
{
return new FileInputStream(file);
}
});
zipEntrySourceList.add(new FileSource("region/" + file.getName(), file));
}
zipEntrySourceList.add(new ZipEntrySource()
{
@Override
public String getPath()
{
return "level.dat";
}
@Override
public ZipEntry getEntry()
{
return new ZipEntry(getPath());
}
@Override
public InputStream getInputStream() throws IOException
{
return new FileInputStream(new File(worldFolder, "level.dat"));
}
});
zipEntrySourceList.add(new FileSource("level.dat", new File(worldFolder, "level.dat")));
ZipUtil.pack(zipEntrySourceList.toArray(new ZipEntrySource[zipEntrySourceList.size()]), outputFile);
FileUtils.deleteQuietly(worldFolder);
getLogger().info("Finished generating world seed " + seed);
try
{
getLogger().info("Uploading " + seed + "!");
URL url = new URL("http://" + API_HOST_MAP.get("ENDERCHEST") + "/map/uhc/upload?name=" + outputFile.getName());
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setDoOutput(true);
IOUtils.copy(new FileInputStream(outputFile), connection.getOutputStream());
connection.connect();
if (connection.getResponseCode() != 200)
{
if (connection.getResponseCode() == 409)
{
getLogger().warning("Oops - Server rejected " + seed + " because it was already generated");
if (!outputFile.delete())
{
getLogger().warning("Could not clean up " + seed);
}
}
else
{
getLogger().severe("Failed to upload " + seed + ": " + connection.getResponseCode() + " " + connection.getResponseMessage());
}
}
else
{
getLogger().info("Uploaded " + seed + "!");
if (!outputFile.delete())
{
getLogger().warning("Could not clean up " + seed);
}
}
}
catch (IOException e)
{
getLogger().log(Level.SEVERE, "An error occurred while uploading " + seed + "!", e);
}
finally
{
getLogger().info("Finished generating world seed " + seed);
}
Bukkit.shutdown();
}
}

8
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/Arcade.java
View File

@ -10,12 +10,10 @@ import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.spigotmc.SpigotConfig;
import mineplex.core.common.Constants;
import mineplex.core.CustomTagFix;
import mineplex.core.FoodDupeFix;
import mineplex.core.PacketsInteractionFix;
import mineplex.core.TimingsFix;
import mineplex.core.account.CoreClientManager;
import mineplex.core.achievement.AchievementManager;
import mineplex.core.antihack.AntiHack;
@ -28,6 +26,7 @@ import mineplex.core.chatsnap.SnapshotManager;
import mineplex.core.chatsnap.SnapshotPlugin;
import mineplex.core.chatsnap.SnapshotRepository;
import mineplex.core.command.CommandCenter;
import mineplex.core.common.Constants;
import mineplex.core.common.events.ServerShutdownEvent;
import mineplex.core.common.util.FileUtil;
import mineplex.core.common.util.UtilServer;
@ -55,6 +54,7 @@ import mineplex.core.npc.NpcManager;
import mineplex.core.packethandler.PacketHandler;
import mineplex.core.pet.PetManager;
import mineplex.core.poll.PollManager;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Portal;
import mineplex.core.preferences.PreferencesManager;
import mineplex.core.profileCache.ProfileCacheManager;
@ -138,7 +138,7 @@ public class Arcade extends JavaPlugin
LeaderboardManager leaderboardManager = new LeaderboardManager(this, _clientManager);
Teleport teleport = new Teleport(this, _clientManager);
Portal portal = new Portal();
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion());
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion(), GenericServer.HUB);
DisguiseManager disguiseManager = require(DisguiseManager.class);
@ -162,7 +162,7 @@ public class Arcade extends JavaPlugin
new SnapshotPlugin(this, snapshotManager, _clientManager);
new ReportPlugin(this, reportManager);
BlockRestore blockRestore = new BlockRestore(this);
BlockRestore blockRestore = require(BlockRestore.class);
ProjectileManager projectileManager = new ProjectileManager(this);
HologramManager hologramManager = new HologramManager(this, packetHandler);

2
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/ArcadeManager.java
View File

@ -288,7 +288,7 @@ public class ArcadeManager extends MiniPlugin implements IRelation
_conditionManager = new SkillConditionManager(plugin);
_brandingManager = new BrandingManager(plugin);
_brandingManager = require(BrandingManager.class);
_boosterManager = boosterManager;

102
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/command/TauntCommand.java
View File

@ -1,51 +1,51 @@
package nautilus.game.arcade.command;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import mineplex.core.Managers;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilTime;
import mineplex.core.gadget.event.TauntCommandEvent;
import mineplex.core.gadget.gadgets.taunts.GameType;
import mineplex.minecraft.game.core.combat.CombatManager;
import nautilus.game.arcade.ArcadeManager;
import nautilus.game.arcade.game.Game;
public class TauntCommand extends CommandBase<ArcadeManager>
{
private ArcadeManager _arcadeManager;
public TauntCommand(ArcadeManager manager)
{
super(manager, Rank.ALL, "taunt");
_arcadeManager = manager;
}
@Override
public void Execute(Player player, String[] args)
{
boolean pvp = false;
CombatManager combatManager = Managers.get(CombatManager.class);
if (combatManager != null)
{
pvp = UtilTime.elapsed(combatManager.Get(player).GetLastCombatEngaged(), 5000 * 60);
}
Game game = _arcadeManager.GetGame();
GameType gameType = GameType.NONE;
if (game != null)
{
gameType = GameType.valueOf(game.GetType().toString().toUpperCase());
}
TauntCommandEvent event = new TauntCommandEvent(player, _arcadeManager.isGameInProgress(),
_arcadeManager.GetGame().IsAlive(player), UtilPlayer.isSpectator(player), combatManager.Get(player).GetLastCombatEngaged(),
gameType);
Bukkit.getPluginManager().callEvent(event);
}
}
package nautilus.game.arcade.command;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import mineplex.core.Managers;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilTime;
import mineplex.core.gadget.event.TauntCommandEvent;
import mineplex.core.gadget.gadgets.taunts.GameType;
import mineplex.minecraft.game.core.combat.CombatManager;
import nautilus.game.arcade.ArcadeManager;
import nautilus.game.arcade.game.Game;
public class TauntCommand extends CommandBase<ArcadeManager>
{
private ArcadeManager _arcadeManager;
public TauntCommand(ArcadeManager manager)
{
super(manager, Rank.ALL, "taunt");
_arcadeManager = manager;
}
@Override
public void Execute(Player player, String[] args)
{
boolean pvp = false;
CombatManager combatManager = Managers.get(CombatManager.class);
if (combatManager != null)
{
pvp = UtilTime.elapsed(combatManager.Get(player).GetLastCombatEngaged(), 5000 * 60);
}
Game game = _arcadeManager.GetGame();
GameType gameType = GameType.NONE;
if (game != null)
{
gameType = GameType.valueOf(game.GetType().toString().toUpperCase());
}
TauntCommandEvent event = new TauntCommandEvent(player, _arcadeManager.isGameInProgress(),
_arcadeManager.GetGame().IsAlive(player), UtilPlayer.isSpectator(player), combatManager.Get(player).GetLastCombatEngaged(),
gameType);
Bukkit.getPluginManager().callEvent(event);
}
}

37
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/minestrike/Minestrike.java
View File

@ -414,22 +414,29 @@ public class Minestrike extends TeamGame
int amount;
String gunType = (String) event.GetLog().GetLastDamager().GetDamage().getFirst().getMetadata().get("gunType");
switch (gunType)
if (gunType == null)
{
case "AWP":
amount = 100;
break;
case "PPBIZON":
amount = 600;
break;
case "NOVA":
amount = 900;
break;
case "KNIFE":
amount = 1500;
break;
default:
amount = 300;
amount = 300;
}
else
{
switch (gunType)
{
case "AWP":
amount = 100;
break;
case "PPBIZON":
amount = 600;
break;
case "NOVA":
amount = 900;
break;
case "KNIFE":
amount = 1500;
break;
default:
amount = 300;
}
}
_shopManager.addMoney(killer, amount, "kill with " + event.GetLog().GetLastDamager().GetReason());

2
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/smash/perks/skeletalhorse/PerkBoneRush.java
View File

@ -193,7 +193,7 @@ public class PerkBoneRush extends SmashPerk implements IThrown
return;
}
if (!(target instanceof Player || data.getThrower() instanceof Player))
if (!(target instanceof Player) || !(data.getThrower() instanceof Player))
{
return;
}

19
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/smash/perks/squid/PerkFishFlurry.java
View File

@ -102,11 +102,6 @@ public class PerkFishFlurry extends SmashPerk implements IThrown
return;
}
if (!Recharge.Instance.use(player, GetName(), COOLDOWN, true, true))
{
return;
}
event.setCancelled(true);
Set<Block> blocks = new HashSet<>();
@ -131,10 +126,18 @@ public class PerkFishFlurry extends SmashPerk implements IThrown
blocks.add(cur);
}
_active.add(new DataSquidGeyser(player, blocks));
if (!blocks.isEmpty())
{
if (!Recharge.Instance.use(player, GetName(), COOLDOWN, true, true))
{
return;
}
// Inform
UtilPlayer.message(player, F.main("Game", "You used " + F.skill(GetName()) + "."));
_active.add(new DataSquidGeyser(player, blocks));
// Inform
UtilPlayer.message(player, F.main("Game", "You used " + F.skill(GetName()) + "."));
}
}
@EventHandler

2
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/smash/perks/witherskeleton/PerkWitherImage.java
View File

@ -169,7 +169,7 @@ public class PerkWitherImage extends SmashPerk
}
}
if (event.getTarget() != null && _skeletons.get(event.getTarget().getUniqueId()).equals(event.getEntity()))
if (event.getTarget() != null && event.getEntity().equals(_skeletons.get(event.getTarget().getUniqueId())))
{
event.setCancelled(true);
}

6
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/smash/perks/wolf/PerkWolf.java
View File

@ -503,6 +503,12 @@ public class PerkWolf extends SmashPerk
UUID uuid = playerIterator.next();
Player player = UtilPlayer.searchExact(uuid);
if (player == null)
{
playerIterator.remove();
continue;
}
Iterator<Long> timeIterator = _repeat.get(uuid).iterator();
while (timeIterator.hasNext())

12
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/uhc/UHC.java
View File

@ -365,17 +365,19 @@ public abstract class UHC extends Game
UtilPlayer.message(caller, F.main("Debug", "World info for " + targetWorld.getName()));
UtilPlayer.message(caller, F.desc("Chunks", String.valueOf(chunks.length)));
UtilPlayer.message(caller, F.desc("Entities", String.valueOf(targetWorld.getEntities().size())));
UtilPlayer.message(caller, F.desc("Tile Entities", String.valueOf(Arrays.stream(chunks).map(Chunk::getTileEntities).map(Arrays::asList).flatMap(Collection::stream)
.count())));
UtilPlayer.message(caller, F.desc("Tile Entities", String.valueOf(Arrays.stream(chunks).map(Chunk::getTileEntities).map(Arrays::asList).mapToLong(Collection::size).sum())));
UtilPlayer.message(caller, F.desc("View Distance", String.valueOf(nmsWorld.spigotConfig.viewDistance)));
UtilPlayer.message(caller, F.desc("Unload queue size", String.valueOf(nmsWorld.chunkProviderServer.unloadQueue.size())));
try
{
HashTreeSet<NextTickListEntry> m = (HashTreeSet<NextTickListEntry>) nmsWorld.getClass().getField("M").get(nmsWorld);
Field f = nmsWorld.getClass().getDeclaredField("M");
f.setAccessible(true);
HashTreeSet<NextTickListEntry> m = (HashTreeSet<NextTickListEntry>) f.get(nmsWorld);
UtilPlayer.message(caller, F.desc("Pending tick", String.valueOf(m.size())));
}
catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException e)
catch (ReflectiveOperationException e)
{
e.printStackTrace();
}
@ -571,7 +573,7 @@ public abstract class UHC extends Game
}
}
});
registerDebugCommand(new DebugCommand("uhccallchunks", Rank.DEVELOPER)
registerDebugCommand(new DebugCommand("uhcallchunks", Rank.DEVELOPER)
{
@Override

10
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/wither/WitherGame.java
View File

@ -255,11 +255,15 @@ public class WitherGame extends TeamGame implements IBlockRestorer
if (GetState() == GameState.Recruit || GetState() == GameState.Prepare)
{
Projectile proj = event.getEntity();
WitherSkull ws = (WitherSkull) proj;
if (ws.getShooter() instanceof Wither)
if (proj instanceof WitherSkull)
{
event.setCancelled(true);
WitherSkull ws = (WitherSkull) proj;
if (ws.getShooter() instanceof Wither)
{
event.setCancelled(true);
}
}
}
}

11
Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/managers/ProgressingKitManager.java
View File

@ -157,12 +157,15 @@ public class ProgressingKitManager implements Listener
PlayerKit playerKit = _manager.getKitProgressionManager().getDataManager().get(player.getUniqueId());
try
{
for (Kit kit : _manager.GetGame().GetKits())
if (_manager.GetGame() != null)
{
if (kit instanceof ProgressingKit)
for (Kit kit : _manager.GetGame().GetKits())
{
ProgressingKit progressingKit = (ProgressingKit) kit;
_manager.getKitProgressionManager().getRepository().insertOrUpdate(playerKit, progressingKit.getInternalName());
if (kit instanceof ProgressingKit)
{
ProgressingKit progressingKit = (ProgressingKit) kit;
_manager.getKitProgressionManager().getRepository().insertOrUpdate(playerKit, progressingKit.getInternalName());
}
}
}
}

2
Plugins/Nautilus.Game.PvP/src/nautilus/game/pvp/PvP.java
View File

@ -328,7 +328,7 @@ public class PvP extends JavaPlugin implements IPlugin, Listener
public BlockRestore GetBlockRestore()
{
if (_blockRestore == null)
_blockRestore = new BlockRestore(this);
_blockRestore = require(BlockRestore.class);
return _blockRestore;
}

5
Plugins/mavericks-review-hub/src/mineplex/mavericks/review/Hub.java
View File

@ -38,6 +38,7 @@ import mineplex.core.monitor.LagMeter;
import mineplex.core.mount.MountManager;
import mineplex.core.packethandler.PacketHandler;
import mineplex.core.pet.PetManager;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Portal;
import mineplex.core.preferences.PreferencesManager;
import mineplex.core.profileCache.ProfileCacheManager;
@ -102,7 +103,7 @@ public class Hub extends JavaPlugin
Creature creature = new Creature(this);
ServerStatusManager serverStatusManager = new ServerStatusManager(this, _clientManager, new LagMeter(this, _clientManager));
Portal portal = new Portal();
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion());
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion(), GenericServer.HUB);
DisguiseManager disguiseManager = require(DisguiseManager.class);
@ -117,7 +118,7 @@ public class Hub extends JavaPlugin
Chat chat = new Chat(this, incognito, _clientManager, preferenceManager, achievementManager, serverStatusManager.getCurrentServerName());
new MessageManager(this, incognito, _clientManager, preferenceManager, ignoreManager, punish, friendManager, chat);
BlockRestore blockRestore = new BlockRestore(this);
BlockRestore blockRestore = require(BlockRestore.class);
ProjectileManager projectileManager = new ProjectileManager(this);
HologramManager hologramManager = new HologramManager(this, packetHandler);

5
Plugins/mineplex-game-gemhunters/plugin.yml Normal file
View File

@ -0,0 +1,5 @@
name: GemHunters
main: mineplex.gemhunters.GemHunters
version: 0.1
commands:
playwire:

27
Plugins/mineplex-game-gemhunters/pom.xml Normal file
View File

@ -0,0 +1,27 @@
<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>
<parent>
<groupId>com.mineplex</groupId>
<artifactId>mineplex-plugin</artifactId>
<version>dev-SNAPSHOT</version>
<relativePath>../plugin.xml</relativePath>
</parent>
<name>GemHunters</name>
<artifactId>mineplex-game-gemhunters</artifactId>
<dependencies>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mineplex-core</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>mineplex-minecraft-game-core</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
</project>

313
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/GemHunters.java Normal file
View File

@ -0,0 +1,313 @@
package mineplex.gemhunters;
import net.minecraft.server.v1_8_R3.MinecraftServer;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.craftbukkit.v1_8_R3.CraftWorld;
import org.bukkit.plugin.java.JavaPlugin;
import org.spigotmc.SpigotConfig;
import mineplex.core.CustomTagFix;
import mineplex.core.FoodDupeFix;
import mineplex.core.TimingsFix;
import mineplex.core.account.CoreClientManager;
import mineplex.core.achievement.AchievementManager;
import mineplex.core.antihack.AntiHack;
import mineplex.core.beta.BetaWhitelist;
import mineplex.core.blockrestore.BlockRestore;
import mineplex.core.boosters.BoosterManager;
import mineplex.core.chat.Chat;
import mineplex.core.command.CommandCenter;
import mineplex.core.common.Constants;
import mineplex.core.common.events.ServerShutdownEvent;
import mineplex.core.communities.CommunityManager;
import mineplex.core.cosmetic.CosmeticManager;
import mineplex.core.creature.Creature;
import mineplex.core.delayedtask.DelayedTask;
import mineplex.core.disguise.DisguiseManager;
import mineplex.core.donation.DonationManager;
import mineplex.core.elo.EloManager;
import mineplex.core.explosion.Explosion;
import mineplex.core.friend.FriendManager;
import mineplex.core.gadget.GadgetManager;
import mineplex.core.give.Give;
import mineplex.core.hologram.HologramManager;
import mineplex.core.ignore.IgnoreManager;
import mineplex.core.incognito.IncognitoManager;
import mineplex.core.inventory.InventoryManager;
import mineplex.core.itemstack.ItemStackFactory;
import mineplex.core.memory.MemoryFix;
import mineplex.core.menu.MenuManager;
import mineplex.core.message.MessageManager;
import mineplex.core.monitor.LagMeter;
import mineplex.core.mount.MountManager;
import mineplex.core.npc.NpcManager;
import mineplex.core.packethandler.PacketHandler;
import mineplex.core.party.PartyManager;
import mineplex.core.pet.PetManager;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Portal;
import mineplex.core.powerplayclub.PowerPlayClubRepository;
import mineplex.core.preferences.PreferencesManager;
import mineplex.core.projectile.ProjectileManager;
import mineplex.core.punish.Punish;
import mineplex.core.recharge.Recharge;
import mineplex.core.serverConfig.ServerConfiguration;
import mineplex.core.stats.StatsManager;
import mineplex.core.status.ServerStatusManager;
import mineplex.core.teleport.Teleport;
import mineplex.core.thank.ThankManager;
import mineplex.core.twofactor.TwoFactorAuth;
import mineplex.core.updater.FileUpdater;
import mineplex.core.updater.Updater;
import mineplex.core.visibility.VisibilityManager;
import mineplex.gemhunters.beta.BetaModule;
import mineplex.gemhunters.bounties.BountyModule;
import mineplex.gemhunters.chat.ChatModule;
import mineplex.gemhunters.death.DeathModule;
import mineplex.gemhunters.death.npc.NPCManager;
import mineplex.gemhunters.economy.CashOutModule;
import mineplex.gemhunters.economy.EconomyModule;
import mineplex.gemhunters.loot.InventoryModule;
import mineplex.gemhunters.loot.LootModule;
import mineplex.gemhunters.map.ItemMapModule;
import mineplex.gemhunters.mount.MountModule;
import mineplex.gemhunters.quest.QuestModule;
import mineplex.gemhunters.safezone.SafezoneModule;
import mineplex.gemhunters.scoreboard.ScoreboardModule;
import mineplex.gemhunters.shop.ShopModule;
import mineplex.gemhunters.spawn.SpawnModule;
import mineplex.gemhunters.supplydrop.SupplyDropModule;
import mineplex.gemhunters.world.DebugListeners;
import mineplex.gemhunters.world.TimeCycle;
import mineplex.gemhunters.world.UndergroundMobs;
import mineplex.gemhunters.world.WorldListeners;
import mineplex.gemhunters.worldevent.WorldEventModule;
import mineplex.minecraft.game.core.combat.CombatManager;
import mineplex.minecraft.game.core.condition.ConditionManager;
import mineplex.minecraft.game.core.damage.DamageManager;
import static mineplex.core.Managers.require;
/**
* Gem Hunters main class <br>
*
* TODO make documentation and a nice header
*
* @author Sam
*/
public class GemHunters extends JavaPlugin
{
@Override
public void onEnable()
{
// Load configuration
getConfig().addDefault(Constants.WEB_CONFIG_KEY, Constants.WEB_ADDRESS);
getConfig().set(Constants.WEB_CONFIG_KEY, getConfig().getString(Constants.WEB_CONFIG_KEY));
saveConfig();
// Load core modules
CommandCenter.Initialize(this);
// Client Manager
CoreClientManager clientManager = new CoreClientManager(this);
// Donation Manager
DonationManager donationManager = require(DonationManager.class);
// Command Centre
CommandCenter.Instance.setClientManager(clientManager);
// Timings
require(TimingsFix.class);
// ItemStacks
ItemStackFactory.Initialize(this, false);
// Delayed Tasks
DelayedTask.Initialize(this);
// Recharge
Recharge.Initialize(this);
// Visibility
VisibilityManager.Initialize(this);
// Give
Give.Initialize(this);
// Server config
ServerConfiguration serverConfig = new ServerConfiguration(this, clientManager);
// Teleport
new Teleport(this, clientManager);
// Packets
PacketHandler packetHandler = require(PacketHandler.class);
// Vanish
IncognitoManager incognito = new IncognitoManager(this, clientManager, packetHandler);
// Preferences
PreferencesManager preferenceManager = new PreferencesManager(this, incognito, clientManager);
// Why do these depend on each other... :(
incognito.setPreferencesManager(preferenceManager);
// Server Status
ServerStatusManager serverStatusManager = new ServerStatusManager(this, clientManager, new LagMeter(this, clientManager));
// Portal
Portal portal = new Portal();
// File Updater
new FileUpdater(this, portal, serverStatusManager.getCurrentServerName(), serverStatusManager.getRegion(), GenericServer.BETA_HUB);
// Punish
Punish punish = new Punish(this, clientManager);
// Disguises
DisguiseManager disguiseManager = require(DisguiseManager.class);
// Creatures
Creature creature = new Creature(this);
// The old classic Damage Manager
DamageManager damageManager = new DamageManager(this, new CombatManager(this), new NpcManager(this, creature), disguiseManager, new ConditionManager(this));
damageManager.SetEnabled(false);
// GWEN
AntiHack antiHack = require(AntiHack.class);
Bukkit.getScheduler().runTask(this, antiHack::enableAnticheat);
// Block Restore
BlockRestore blockRestore = require(BlockRestore.class);
// Ignoring
IgnoreManager ignoreManager = new IgnoreManager(this, clientManager, preferenceManager, portal);
// Statistics
StatsManager statsManager = new StatsManager(this, clientManager);
// Elo
EloManager eloManager = new EloManager(this, clientManager);
// Achievements
AchievementManager achievementManager = new AchievementManager(statsManager, clientManager, donationManager, incognito, eloManager);
// Chat/Messaging
Chat chat = new Chat(this, incognito, clientManager, preferenceManager, achievementManager, serverStatusManager.getCurrentServerName());
new MessageManager(this, incognito, clientManager, preferenceManager, ignoreManager, punish, new FriendManager(this, clientManager, preferenceManager, portal), chat);
// Parties
new PartyManager();
// Communities
new CommunityManager(this, clientManager);
// Fixes
new MemoryFix(this);
new FoodDupeFix(this);
// Explosions
Explosion explosion = new Explosion(this, blockRestore);
explosion.SetDebris(true);
explosion.SetTemporaryDebris(false);
// Inventories
InventoryManager inventoryManager = new InventoryManager(this, clientManager);
// Reports
// SnapshotManager snapshotManager = new SnapshotManager(this, new
// SnapshotRepository(serverStatusManager.getCurrentServerName(),
// getLogger()));
// new SnapshotPlugin(this, snapshotManager, clientManager);
// new ReportPlugin(this, new ReportManager(this, snapshotManager,
// clientManager, incognito, punish, serverStatusManager.getRegion(),
// serverStatusManager.getCurrentServerName(), 1));
// Tag fix
new CustomTagFix(this, packetHandler);
// Holograms
HologramManager hologramManager = new HologramManager(this, packetHandler);
// Menus
new MenuManager(this);
// Gadgets, used for mounts, lots of managers for something really small
// :(
MountManager mountManager = new MountManager(this, clientManager, donationManager, blockRestore, disguiseManager);
PetManager petManager = new PetManager(this, clientManager, donationManager, inventoryManager, disguiseManager, creature, blockRestore);
ProjectileManager projectileManager = new ProjectileManager(this);
GadgetManager gadgetManager = new GadgetManager(this, clientManager, donationManager, inventoryManager, mountManager, petManager, preferenceManager, disguiseManager, blockRestore, projectileManager, achievementManager, packetHandler, hologramManager, incognito);
ThankManager thankManager = new ThankManager(this, clientManager, donationManager);
BoosterManager boosterManager = new BoosterManager(this, null, clientManager, donationManager, inventoryManager, thankManager);
CosmeticManager cosmeticManager = new CosmeticManager(this, clientManager, donationManager, inventoryManager, gadgetManager, mountManager, petManager, null, boosterManager);
cosmeticManager.setActive(false);
cosmeticManager.setHideParticles(true);
gadgetManager.setGadgetEnabled(false);
// Now we finally get to enable the Gem Hunters modules
// Though if any other module needs one of these it will be generated in
// order, however they are all here just for good measure.
require(BetaModule.class);
//require(DebugModule.class);
require(BountyModule.class);
require(CashOutModule.class);
require(ChatModule.class);
require(DeathModule.class);
require(EconomyModule.class);
require(InventoryModule.class);
require(LootModule.class);
require(ItemMapModule.class);
require(MountModule.class);
require(QuestModule.class);
require(SafezoneModule.class);
require(ScoreboardModule.class);
require(SpawnModule.class);
require(ShopModule.class);
require(SupplyDropModule.class);
require(WorldEventModule.class);
// An arbitrary collection of world listeners such as block place/break,
// interact events etc...
new WorldListeners(this);
new TimeCycle(this);
new UndergroundMobs(this);
new DebugListeners(this);
// Combat npc
new NPCManager(hologramManager);
// UpdateEvent!!!
new Updater(this);
// Disable spigot's item merging
for (World world : getServer().getWorlds())
{
((CraftWorld) world).getHandle().spigotConfig.itemMerge = 0;
}
// Turn off the server's debugging
MinecraftServer.getServer().getPropertyManager().setProperty("debug", false);
SpigotConfig.debug = false;
// Two-factor auth
require(TwoFactorAuth.class);
// beta whitelist
new BetaWhitelist(clientManager, new PowerPlayClubRepository(this, clientManager, donationManager));
}
@Override
public void onDisable()
{
getServer().getPluginManager().callEvent(new ServerShutdownEvent(this));
}
}

49
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/beta/BetaModule.java Normal file
View File

@ -0,0 +1,49 @@
package mineplex.gemhunters.beta;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
@ReflectivelyCreateMiniPlugin
public class BetaModule extends MiniPlugin
{
private static final String[] ANNOUCEMENTS = {
"Please remember this game is an early access BETA and all bugs should be reported at mineplex.com/forums/m/11929946/viewforum/8006500 .",
"Thank you for playing Gem Hunters!",
"Many more features are being added over the coming days!",
"Players in your party show up on your map!",
"Safezones are marked as green areas on your map!",
"Players that have super valuable items show up on your map!"
};
private int _lastIndex;
private BetaModule()
{
super("Beta");
}
@EventHandler
public void annouce(UpdateEvent event)
{
if (event.getType() != UpdateType.MIN_01)
{
return;
}
Bukkit.broadcastMessage(F.main(C.cRedB + "BETA", C.cYellow + ANNOUCEMENTS[_lastIndex]));
if (++_lastIndex == ANNOUCEMENTS.length)
{
_lastIndex = 0;
}
}
}

36
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/bounties/Bounty.java Normal file
View File

@ -0,0 +1,36 @@
package mineplex.gemhunters.bounties;
import java.util.UUID;
import org.bukkit.entity.Player;
public class Bounty
{
private UUID _target;
private UUID _setter;
private int _amount;
public Bounty(Player target, Player setter, int amount)
{
_target = target.getUniqueId();
_setter = setter.getUniqueId();
_amount = amount;
}
public UUID getTarget()
{
return _target;
}
public UUID getSetter()
{
return _setter;
}
public int getAmount()
{
return _amount;
}
}

46
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/bounties/BountyModule.java Normal file
View File

@ -0,0 +1,46 @@
package mineplex.gemhunters.bounties;
import java.net.MalformedURLException;
import java.net.URL;
import org.bukkit.block.BlockFace;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.sponsorbranding.BrandingManager;
@ReflectivelyCreateMiniPlugin
public class BountyModule extends MiniPlugin
{
private final BrandingManager _brandingManager;
private BountyModule()
{
super("Bounty");
_brandingManager = require(BrandingManager.class);
}
//@EventHandler
public void test(PlayerCommandPreprocessEvent event)
{
if (!event.getMessage().startsWith("/want"))
{
return;
}
try
{
event.setCancelled(true);
_brandingManager.createPost(event.getPlayer().getLocation(), BlockFace.SOUTH, new URL("http://minotar.net/helm/Moppletop.png"));
}
catch (MalformedURLException e)
{
e.printStackTrace();
}
}
}

75
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/chat/ChatModule.java Normal file
View File

@ -0,0 +1,75 @@
package mineplex.gemhunters.chat;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.account.CoreClientManager;
import mineplex.core.chat.Chat;
import mineplex.core.common.Rank;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
/**
* This module handles player chat.
*/
@ReflectivelyCreateMiniPlugin
public class ChatModule extends MiniPlugin
{
private final CoreClientManager _clientManager;
private final Chat _chat;
private ChatModule()
{
super("Chat");
_clientManager = require(CoreClientManager.class);
_chat = require(Chat.class);
}
@EventHandler(priority = EventPriority.LOWEST)
public void playerJoin(PlayerJoinEvent event)
{
event.setJoinMessage(F.sys("Join", event.getPlayer().getName()));
}
@EventHandler(priority = EventPriority.LOWEST)
public void playerQuit(PlayerQuitEvent event)
{
event.setQuitMessage(F.sys("Quit", event.getPlayer().getName()));
}
@EventHandler(priority = EventPriority.HIGHEST)
public void chat(AsyncPlayerChatEvent event)
{
// Checks if the player has been muted/chat is silenced etc...
if (event.isCancelled())
{
return;
}
Player player = event.getPlayer();
String playerName = player.getName();
Rank rank = _clientManager.Get(player).getRealOrDisguisedRank();
String rankString = rank == Rank.ALL ? "" : rank.getTag(true, true);
// Create a message that follows the rest of the network's chat format
String message = (rankString + " " + C.cYellow + playerName + " " + C.cWhite + _chat.getFilteredMessage(player, event.getMessage())).trim();
// We will handle the broadcast
event.setCancelled(true);
for (Player other : event.getRecipients())
{
other.sendMessage(message);
}
}
}

198
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/death/DeathModule.java Normal file
View File

@ -0,0 +1,198 @@
package mineplex.gemhunters.death;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.entity.ItemSpawnEvent;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import com.google.common.collect.Sets;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.common.util.C;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.common.util.UtilTextMiddle;
import mineplex.core.common.util.UtilTime;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import mineplex.core.visibility.VisibilityManager;
import mineplex.gemhunters.death.event.PlayerCustomRespawnEvent;
import mineplex.gemhunters.spawn.SpawnModule;
/**
* This module handles anything to do with a players death
*/
@ReflectivelyCreateMiniPlugin
public class DeathModule extends MiniPlugin
{
// Some items like the cash out item (and for some reason players drop
// bones?) don't need to be dropped to avoid duplication.
private static final Set<Material> DISALLOWED_DROPS = Sets.newHashSet(Material.EMERALD, Material.MAP, Material.BONE, Material.STAINED_GLASS_PANE);
private static final int DEATH_ANIMATION_TIME = 7000;
private static final int DEATH_ANIMATION_COUNTDOWN = 2000;
private final SpawnModule _spawn;
private final Map<UUID, Long> _toRemove;
private DeathModule()
{
super("Death");
_spawn = require(SpawnModule.class);
_toRemove = new HashMap<>();
}
@EventHandler
public void join(PlayerJoinEvent event)
{
PlayerCustomRespawnEvent event2 = new PlayerCustomRespawnEvent(event.getPlayer());
UtilServer.CallEvent(event2);
}
@EventHandler
public void death(PlayerDeathEvent event)
{
Player player = event.getEntity();
// Stop the player dieing
player.setHealth(20);
player.setFoodLevel(20);
player.setExhaustion(0);
startAnimation(player);
_toRemove.put(player.getUniqueId(), System.currentTimeMillis());
}
@EventHandler
public void itemSpawn(ItemSpawnEvent event)
{
if (DISALLOWED_DROPS.contains(event.getEntity().getItemStack().getType()))
{
event.setCancelled(true);
}
}
@EventHandler
public void updateAnimations(UpdateEvent event)
{
if (event.getType() != UpdateType.SEC)
{
return;
}
Iterator<UUID> iterator = _toRemove.keySet().iterator();
while (iterator.hasNext())
{
UUID key = iterator.next();
Player player = UtilPlayer.searchExact(key);
if (player == null)
{
iterator.remove();
continue;
}
long start = _toRemove.get(key);
long end = start + DEATH_ANIMATION_TIME + 1000;
if (UtilTime.elapsed(start, DEATH_ANIMATION_TIME))
{
stopAnimation(player);
_toRemove.remove(key);
continue;
}
else if (UtilTime.elapsed(start, DEATH_ANIMATION_COUNTDOWN))
{
UtilTextMiddle.display(C.cRedB + "YOU DIED", String.valueOf((int) (end - System.currentTimeMillis()) / 1000), 0, 20, 0, player);
}
}
}
public void startAnimation(Player player)
{
UtilTextMiddle.display(C.cRedB + "YOU DIED", "Respawning shortly", 0, 60, 0, player);
VisibilityManager.Instance.setVisibility(player, false, UtilServer.getPlayers());
((CraftPlayer) player).getHandle().spectating = true;
player.setAllowFlight(true);
player.setFlying(true);
player.setGameMode(GameMode.CREATIVE);
}
public void stopAnimation(Player player)
{
UtilTextMiddle.display(C.cGreenB + "RESPAWNED", "", 0, 20, 20, player);
VisibilityManager.Instance.setVisibility(player, true, UtilServer.getPlayers());
((CraftPlayer) player).getHandle().spectating = false;
player.setFlying(false);
player.setAllowFlight(false);
player.setGameMode(GameMode.SURVIVAL);
_spawn.teleportToSpawn(player);
PlayerCustomRespawnEvent event = new PlayerCustomRespawnEvent(player);
UtilServer.CallEvent(event);
}
@EventHandler
public void itemPickup(PlayerPickupItemEvent event)
{
if (_toRemove.containsKey(event.getPlayer().getUniqueId()))
{
event.setCancelled(true);
}
}
@EventHandler
public void blockBreak(BlockBreakEvent event)
{
if (_toRemove.containsKey(event.getPlayer().getUniqueId()))
{
event.setCancelled(true);
}
}
@EventHandler
public void blockPlace(BlockPlaceEvent event)
{
if (_toRemove.containsKey(event.getPlayer().getUniqueId()))
{
event.setCancelled(true);
}
}
@EventHandler
public void inventory(InventoryClickEvent event)
{
if (_toRemove.containsKey(event.getWhoClicked().getUniqueId()))
{
event.setCancelled(true);
}
}
@EventHandler
public void playerQuit(PlayerQuitEvent event)
{
_toRemove.remove(event.getPlayer().getUniqueId());
}
}

27
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/death/event/PlayerCustomRespawnEvent.java Normal file
View File

@ -0,0 +1,27 @@
package mineplex.gemhunters.death.event;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
public class PlayerCustomRespawnEvent extends PlayerEvent
{
private static final HandlerList HANDLERS = new HandlerList();
public PlayerCustomRespawnEvent(Player who)
{
super(who);
}
public HandlerList getHandlers()
{
return HANDLERS;
}
public static HandlerList getHandlerList()
{
return HANDLERS;
}
}

238
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/death/npc/CombatLogNPC.java Normal file
View File

@ -0,0 +1,238 @@
package mineplex.gemhunters.death.npc;
import java.io.File;
import java.util.List;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftLivingEntity;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Skeleton;
import org.bukkit.metadata.FixedMetadataValue;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilEnt;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.common.util.UtilTime;
import mineplex.core.disguise.DisguiseManager;
import mineplex.core.disguise.disguises.DisguisePlayer;
import mineplex.core.hologram.Hologram;
import mineplex.core.hologram.HologramManager;
public class CombatLogNPC
{
public final static EntityType NPC_TYPE = EntityType.VILLAGER;
private PlayerInfo _playerInfo;
private Hologram _hologram;
private DisguiseManager _disguiseManager;
private long _spawnDate;
private final long _endingTime;
private double _spawnHealth;
private boolean _creative;
private LivingEntity _npc;
private ArmorStand _stand;
private CraftLivingEntity _lastDamager;
public int getEntityId()
{
return _npc.getEntityId();
}
public CombatLogNPC(Player player, DisguiseManager disguiseManager, HologramManager hologramManager, boolean wasCreative)
{
_playerInfo = new PlayerInfo(player);
_creative = wasCreative;
_disguiseManager = disguiseManager;
_hologram = new Hologram(hologramManager, player.getEyeLocation().add(0, 1, 0), C.cYellow + UtilTime.MakeStr(NPCManager.COMBAT_LOG_DURATION) + C.cWhite + " Seconds left before despawn");
_spawnDate = 0;
_endingTime = System.currentTimeMillis() + NPCManager.COMBAT_LOG_DURATION;
_spawnHealth = player.getHealth();
_hologram.start();
}
/**
* Called when the {@code _npc} associated with this CombatLogNPC is killed
* and thus drops all the owner's items.
*/
public void onDeath(CraftLivingEntity killer)
{
Location location = _npc.getLocation();
World world = location.getWorld();
File file = new File(world.getWorldFolder(), String.format("playerdata/%s.dat", _playerInfo.getPlayerUuid()));
file.delete(); // Delete the player's .dat file so they will join with
// empty inventory/respawn on next login
if (killer != null)
{
String killerName = "Unknown";
if (killer instanceof CraftPlayer)
{
killerName = ((CraftPlayer) killer).getName();
}
else
{
killerName = UtilEnt.getName(killer);
}
// try
// {
// DataOutputStream stream = new DataOutputStream(new FileOutputStream(_userDataPath + String.format("DEATH_%s.dat", _playerInfo.getPlayerUuid())));
//
// stream.writeLong(System.currentTimeMillis());
// stream.writeInt(killerName.length());
// stream.writeBytes(killerName);
//
// stream.close();
// }
// catch (IOException e)
// {
// System.out.println(String.format("FATAL ERROR while trying to create player death lock for %s, meaning %s will not be informed that they died next time they log in.", _playerInfo.getPlayerName(), _playerInfo.getPlayerName()));
// }
UtilServer.broadcast(F.main("Death", F.elem(_playerInfo.getPlayerName()) + " was killed by " + F.elem(killerName) + " while combat logged."));
}
_playerInfo.dropItems(location);
_disguiseManager.undisguise(_npc);
}
public void update()
{
_hologram.setText("Quitting in " + UtilTime.MakeStr(Math.max(_endingTime - System.currentTimeMillis(), 0)));
}
/**
* @return true, if the {@code _npc} associated with this CombatLogNPC is
* alive, false otherwise.
*/
public boolean isAlive()
{
return _npc != null && !_npc.isDead();
}
/**
* @return the amount of time (in milliseconds) that this npc has been alive
* an spawned in.
*/
public long getAliveDuation()
{
return System.currentTimeMillis() - _spawnDate;
}
public void spawn()
{
if (_npc != null) despawn();
_npc = spawnNpc(getPlayer());
_spawnDate = System.currentTimeMillis();
}
public void despawn()
{
System.out.println("Despawning");
if (_npc != null)
{
if (_stand != null)
{
_stand.setPassenger(null);
_stand.remove();
_stand = null;
}
_npc.remove();
_npc = null;
_hologram.stop();
_hologram = null;
}
}
public void remove()
{
if (_hologram != null)
{
_hologram.stop();
_hologram = null;
}
}
public PlayerInfo getPlayerInfo()
{
return _playerInfo;
}
public Player getPlayer()
{
return _playerInfo.getPlayer();
}
public boolean matchesPlayer(Player player)
{
return _playerInfo.getPlayerName().equalsIgnoreCase(player.getName());
}
private LivingEntity spawnNpc(Player player)
{
Location spawnLoc = player.getLocation();
Skeleton skel = player.getWorld().spawn(spawnLoc, Skeleton.class);
skel.setMetadata("CombatLogNPC", new FixedMetadataValue(UtilServer.getPlugin(), player.getUniqueId().toString()));
skel.teleport(spawnLoc);
skel.setHealth(_spawnHealth);
UtilEnt.vegetate(skel);
UtilEnt.silence(skel, true);
skel.getEquipment().setHelmet(player.getInventory().getHelmet());
skel.getEquipment().setChestplate(player.getInventory().getChestplate());
skel.getEquipment().setLeggings(player.getInventory().getLeggings());
skel.getEquipment().setBoots(player.getInventory().getBoots());
skel.getEquipment().setItemInHand(player.getItemInHand());
// Get in range
List<Player> inRange = UtilPlayer.getNearby(spawnLoc, 75d);
// Disguise
DisguisePlayer disguise = new DisguisePlayer(skel, ((CraftPlayer) player).getHandle().getProfile());
_disguiseManager.disguise(disguise, attempted -> inRange.contains(attempted));
if (!UtilEnt.isGrounded(player))
{
ArmorStand stand = player.getWorld().spawn(spawnLoc.clone().subtract(0,1,0), ArmorStand.class);
stand.setVisible(false);
stand.setPassenger(skel);
stand.setGravity(false);
_stand = stand;
}
return skel;
}
public boolean wasCreative()
{
return _creative;
}
public CraftLivingEntity getLastDamager()
{
return _lastDamager;
}
public void setLastDamager(CraftLivingEntity damager)
{
_lastDamager = damager;
}
}

262
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/death/npc/NPCManager.java Normal file
View File

@ -0,0 +1,262 @@
package mineplex.gemhunters.death.npc;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Sound;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftLivingEntity;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityCombustEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.world.ChunkUnloadEvent;
import org.bukkit.metadata.FixedMetadataValue;
import mineplex.core.MiniPlugin;
import mineplex.core.disguise.DisguiseManager;
import mineplex.core.hologram.HologramManager;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import mineplex.gemhunters.economy.PlayerCashOutCompleteEvent;
import mineplex.minecraft.game.core.damage.CustomDamageEvent;
public class NPCManager extends MiniPlugin
{
public static final long COMBAT_LOG_DURATION = 30000;
private static NPCManager _instance;
public static NPCManager getInstance()
{
return _instance;
}
private Set<CombatLogNPC> _logoutNpcs;
private Set<Integer> _toKillIds;
private Set<UUID> _cashedOutPreventNPCs = new HashSet<>();
private HologramManager _hologramManager;
public NPCManager(HologramManager hologramManager)
{
super("NPC Manager");
_instance = this;
_logoutNpcs = new HashSet<>();
_toKillIds = new HashSet<>();
_hologramManager = hologramManager;
}
@EventHandler
public void onCashOut(PlayerCashOutCompleteEvent event)
{
_cashedOutPreventNPCs.add(event.getPlayer().getUniqueId());
}
@EventHandler
public void playerQuit(PlayerQuitEvent event)
{
NPCManager.getInstance().spawnLogoutNpc(event.getPlayer());
}
@Override
public void disable()
{
log("Killing logout npcs");
// Despawn/kill all combat log NPCs on server shutdown
for (CombatLogNPC npc : _logoutNpcs)
{
npc.despawn();
}
_logoutNpcs.clear();
}
public void spawnLogoutNpc(Player player)
{
if (!_cashedOutPreventNPCs.remove(player.getUniqueId()) && !hasLogoutNpc(player))
{
CombatLogNPC npc = new CombatLogNPC(player, require(DisguiseManager.class), _hologramManager, player.getGameMode().equals(GameMode.CREATIVE));
npc.spawn();
_logoutNpcs.add(npc);
log(String.format("Spawned combat log NPC for %s!", player.getName()));
}
}
@EventHandler
public void killNpcs(PlayerJoinEvent event)
{
for (LivingEntity entity : Bukkit.getWorlds().get(0).getLivingEntities())
{
if (entity.hasMetadata("CombatLogNPC") && ((FixedMetadataValue) entity.getMetadata("CombatLogNPC").get(0)).asString().equals(event.getPlayer().getUniqueId().toString()))
{
entity.remove();
}
}
}
public void despawnLogoutNpc(Player player)
{
CombatLogNPC npc = getLogoutNpc(player);
if (npc != null)
{
_toKillIds.add(npc.getEntityId());
npc.despawn();
_logoutNpcs.remove(npc);
log(String.format("Despawned combat log NPC for %s!", player.getName()));
}
}
public boolean hasLogoutNpc(Player player)
{
return getLogoutNpc(player) != null;
}
public CombatLogNPC getLogoutNpc(Player player)
{
for (CombatLogNPC logoutNpc : _logoutNpcs)
{
if (logoutNpc.matchesPlayer(player))
{
return logoutNpc;
}
}
return null;
}
@EventHandler
public void onChunkUnload(ChunkUnloadEvent event)
{
for (Entity entity : event.getChunk().getEntities())
{
for (CombatLogNPC npc : _logoutNpcs)
{
if (entity.getEntityId() == npc.getEntityId())
{
event.setCancelled(true);
break;
}
}
}
}
@EventHandler(ignoreCancelled = true)
public void onEntityDeath(EntityDeathEvent event)
{
CombatLogNPC logoutNpc = getLogoutNpc(event.getEntity());
if (logoutNpc != null)
{
logoutNpc.onDeath(logoutNpc.getLastDamager());
event.getDrops().clear(); // Clear the entity's item drops. Manually
// drops combat log items earlier
}
}
@EventHandler(ignoreCancelled = true)
public void onEntityDamaged(CustomDamageEvent event)
{
CombatLogNPC logoutNpc = getLogoutNpc(event.GetDamageeEntity());
if (logoutNpc != null && event.GetDamagerEntity(true) != null)
{
if (logoutNpc.wasCreative())
{
event.SetCancelled("Cannot hurt creative player");
return;
}
if (event.GetDamagerPlayer(true) != null)
{
event.GetDamagerPlayer(true).playSound(event.GetDamagerPlayer(true).getLocation(), Sound.HURT_FLESH, 1, 1);
}
logoutNpc.setLastDamager(((CraftLivingEntity) event.GetDamagerEntity(true)));
event.SetKnockback(false);
}
}
@EventHandler
public void onEntityIgnite(EntityCombustEvent event)
{
if (isLogoutNpc(event.getEntity()))
{
event.setCancelled(true);
}
}
@EventHandler
public void onUpdate(UpdateEvent event)
{
if (event.getType() == UpdateType.FASTER)
{
for (CombatLogNPC npc : _logoutNpcs)
{
npc.update();
}
}
if (event.getType() == UpdateType.SEC)
{
Iterator<CombatLogNPC> iterator = _logoutNpcs.iterator();
while (iterator.hasNext())
{
CombatLogNPC npc = iterator.next();
if (Bukkit.getPlayer(npc.getPlayerInfo().getPlayerName()) != null)
{
System.out.println("{NPCMANAGER} ORIGINAL PLAYER ALIVE AND DESPAWNING");
npc.despawn();
iterator.remove();
}
else if (!npc.isAlive())
{
System.out.println("{NPCMANAGER} NOT ALIVE AND REMOVING");
npc.remove();
iterator.remove();
}
else if (npc.getAliveDuation() > COMBAT_LOG_DURATION)
{
System.out.println("{NPCMANAGER} DESPAWNING");
npc.despawn();
iterator.remove();
}
}
}
}
private boolean isLogoutNpc(Entity entity)
{
return getLogoutNpc(entity) != null;
}
private CombatLogNPC getLogoutNpc(Entity entity)
{
return getLogoutNpc(entity.getEntityId());
}
private CombatLogNPC getLogoutNpc(int entityId)
{
for (CombatLogNPC npc : _logoutNpcs)
{
if (npc.getEntityId() == entityId)
{
return npc;
}
}
return null;
}
}

92
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/death/npc/PlayerInfo.java Normal file
View File

@ -0,0 +1,92 @@
package mineplex.gemhunters.death.npc;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import mineplex.gemhunters.loot.InventoryModule;
public class PlayerInfo
{
private String _playerName;
private UUID _playerUuid;
private ItemStack[] _armor;
private List<ItemStack> _items;
private Location _location;
public PlayerInfo(Player player)
{
_playerName = player.getName();
_playerUuid = player.getUniqueId();
_armor = player.getInventory().getArmorContents();
_items = fetchItems(player.getInventory());
_location = player.getLocation();
}
public void dropItems(Location location)
{
World world = location.getWorld();
for (ItemStack item : _items)
{
world.dropItemNaturally(location, item);
}
}
public void restore()
{
Player player = getPlayer();
player.getInventory().clear();
player.getInventory().setArmorContents(_armor);
player.getInventory().addItem(_items.toArray(new ItemStack[0]));
player.teleport(_location);
}
public String getPlayerName()
{
return _playerName;
}
public UUID getUniqueId()
{
return _playerUuid;
}
public String getPlayerUuid()
{
return _playerUuid.toString();
}
public Player getPlayer()
{
return Bukkit.getPlayerExact(_playerName);
}
private List<ItemStack> fetchItems(PlayerInventory inventory)
{
List<ItemStack> items = new ArrayList<>();
addItems(items, inventory.getContents());
return items;
}
private void addItems(List<ItemStack> items, ItemStack[] itemsToAdd)
{
for (ItemStack item : itemsToAdd)
{
if (item != null && item.getType() != Material.AIR && !item.isSimilar(InventoryModule.LOCKED))
{
items.add(item);
}
}
}
}

276
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/economy/CashOutModule.java Normal file
View File

@ -0,0 +1,276 @@
package mineplex.gemhunters.economy;
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.UUID;
import org.bukkit.Material;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.ItemStack;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilEvent;
import mineplex.core.common.util.UtilEvent.ActionType;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.common.util.UtilTextMiddle;
import mineplex.core.donation.DonationManager;
import mineplex.core.itemstack.ItemBuilder;
import mineplex.core.portal.GenericServer;
import mineplex.core.portal.Intent;
import mineplex.core.portal.Portal;
import mineplex.core.recharge.Recharge;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import mineplex.gemhunters.spawn.event.PlayerTeleportIntoMapEvent;
@ReflectivelyCreateMiniPlugin
public class CashOutModule extends MiniPlugin
{
private static final DecimalFormat ARMOUR_STAND_FORMAT = new DecimalFormat("0.0");
private static final ItemStack CASH_OUT_ITEM = new ItemBuilder(Material.EMERALD).setTitle(C.cGreen + "Cash Out").addLore("", C.cGray + "Click to begin the process to cash out.", C.cGray + "Cashing out saves your current loot.").build();
private static final int CASH_OUT_COOLDOWN = 10000;
private static final int CASH_OUT_MAX_MOVE_DISTANCE_SQUARED = 4;
private final DonationManager _donation;
private final Map<UUID, CashOutSession> _sessions;
public CashOutModule()
{
super("Cash Out");
_donation = require(DonationManager.class);
_sessions = new HashMap<>();
}
@EventHandler
public void teleportIn(PlayerTeleportIntoMapEvent event)
{
if (event.isCancelled())
{
return;
}
event.getPlayer().getInventory().setItem(7, CASH_OUT_ITEM);
}
@EventHandler
public void playerInteract(PlayerInteractEvent event)
{
if (!UtilEvent.isAction(event, ActionType.R))
{
return;
}
Player player = event.getPlayer();
ItemStack itemStack = player.getItemInHand();
if (itemStack == null)
{
return;
}
if (!itemStack.isSimilar(CASH_OUT_ITEM))
{
return;
}
attemptCashOut(player);
}
@EventHandler
public void itemDrop(PlayerDropItemEvent event)
{
if (event.getItemDrop().getItemStack().isSimilar(CASH_OUT_ITEM))
{
event.getPlayer().sendMessage(F.main("Game", "You cannot drop the " + F.item("Cash Out Item") + "."));
event.setCancelled(true);
}
}
@EventHandler
public void inventoryClick(InventoryClickEvent event)
{
ItemStack itemStack = event.getCurrentItem();
if (itemStack == null)
{
return;
}
if (!itemStack.isSimilar(CASH_OUT_ITEM))
{
return;
}
event.setCancelled(true);
}
@EventHandler
public void playerQuit(PlayerQuitEvent event)
{
}
@EventHandler
public void update(UpdateEvent event)
{
if (event.getType() != UpdateType.TICK)
{
return;
}
Iterator<UUID> iterator = _sessions.keySet().iterator();
while (iterator.hasNext())
{
UUID key = iterator.next();
Player player = UtilPlayer.searchExact(key);
CashOutSession session = _sessions.get(key);
double current = session.getCurrent();
ArmorStand stand = session.getArmourStand();
String standName = ARMOUR_STAND_FORMAT.format(current);
if (player == null)
{
session.endSession();
iterator.remove();
continue;
}
UtilTextMiddle.display(C.cGreen + standName, UtilTextMiddle.progress((float) (1 - current / session.getMax())), 0, 10, 0, player);
stand.setCustomName(standName + " seconds");
session.setCurrent(current - 0.05);
if (session.getCurrent() <= 0)
{
PlayerCashOutCompleteEvent completeEvent = new PlayerCashOutCompleteEvent(player);
UtilServer.CallEvent(completeEvent);
_donation.rewardCurrencyUntilSuccess(GlobalCurrency.GEM, player, "Earned", completeEvent.getGems());
session.endSession();
iterator.remove();
Portal.getInstance().sendPlayerToGenericServer(player, GenericServer.BETA_HUB, Intent.FORCE_TRANSFER);
}
}
}
@EventHandler
public void updateMove(UpdateEvent event)
{
if (event.getType() != UpdateType.FAST)
{
return;
}
for (UUID key : _sessions.keySet())
{
Player player = UtilPlayer.searchExact(key);
CashOutSession session = _sessions.get(key);
if (session.getLocation().distanceSquared(player.getLocation()) > CASH_OUT_MAX_MOVE_DISTANCE_SQUARED)
{
cancelCashOut(player, "You moved!");
}
}
}
@EventHandler
public void entityDamage(EntityDamageEvent event)
{
if (!(event.getEntity() instanceof Player))
{
return;
}
Player player = (Player) event.getEntity();
if (isCashingOut(player))
{
cancelCashOut(player, "You took damage!");
}
}
@EventHandler
public void entityAttack(EntityDamageByEntityEvent event)
{
if (!(event.getDamager() instanceof Player) || event.getEntity() instanceof ArmorStand)
{
return;
}
Player player = (Player) event.getDamager();
if (isCashingOut(player))
{
cancelCashOut(player, "You attacked a player!");
}
}
public void attemptCashOut(Player player)
{
UUID key = player.getUniqueId();
if (_sessions.containsKey(key))
{
player.sendMessage(F.main("Game", "You are already cashing out."));
return;
}
if (!Recharge.Instance.use(player, "Cash Out", CASH_OUT_COOLDOWN, true, false))
{
return;
}
// Test time
_sessions.put(key, new CashOutSession(player, 10));
}
public void cancelCashOut(Player player, String message)
{
UUID key = player.getUniqueId();
CashOutSession session = _sessions.get(key);
player.sendMessage(F.main("Game", message + " Your cash out has been cancelled."));
session.endSession();
_sessions.remove(key);
}
public boolean isCashingOut(Player player)
{
return getCashOutSession(player) != null;
}
public CashOutSession getCashOutSession(Player player)
{
for (UUID key : _sessions.keySet())
{
if (key.equals(player.getUniqueId()))
{
return _sessions.get(key);
}
}
return null;
}
}

58
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/economy/CashOutSession.java Normal file
View File

@ -0,0 +1,58 @@
package mineplex.gemhunters.economy;
import org.bukkit.Location;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Player;
public class CashOutSession
{
private double _current;
private double _max;
private ArmorStand _stand;
private Location _location;
public CashOutSession(Player player, double max)
{
_current = max;
_max = max;
_stand = player.getWorld().spawn(player.getLocation().add(0, 0.5, 0), ArmorStand.class);
_stand.setCustomNameVisible(true);
_stand.setVisible(false);
_stand.setGravity(false);
_location = player.getLocation();
}
public void endSession()
{
_stand.remove();
}
public void setCurrent(double current)
{
_current = current;
}
public double getCurrent()
{
return _current;
}
public double getMax()
{
return _max;
}
public ArmorStand getArmourStand()
{
return _stand;
}
public Location getLocation()
{
return _location;
}
}

110
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/economy/EconomyModule.java Normal file
View File

@ -0,0 +1,110 @@
package mineplex.gemhunters.economy;
import java.util.UUID;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.PlayerDeathEvent;
import mineplex.core.MiniClientPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.common.currency.GlobalCurrency;
import mineplex.core.common.util.F;
import mineplex.core.donation.DonationManager;
import mineplex.core.donation.Donor;
import mineplex.gemhunters.death.event.PlayerCustomRespawnEvent;
import mineplex.gemhunters.economy.command.GiveGemsCommand;
import mineplex.gemhunters.spawn.event.PlayerTeleportIntoMapEvent;
@ReflectivelyCreateMiniPlugin
public class EconomyModule extends MiniClientPlugin<Integer>
{
private static final float GEM_KILL_FACTOR = 0.5F;
private static final int GEM_START_COST = 100;
private final DonationManager _donation;
public EconomyModule()
{
super("Economy");
_donation = require(DonationManager.class);
}
@Override
public void addCommands()
{
addCommand(new GiveGemsCommand(this));
}
@EventHandler
public void respawn(PlayerCustomRespawnEvent event)
{
addToStore(event.getPlayer(), null, GEM_START_COST);
}
@EventHandler
public void teleportIn(PlayerTeleportIntoMapEvent event)
{
Player player = event.getPlayer();
Donor donor = _donation.Get(event.getPlayer());
if (donor.getBalance(GlobalCurrency.GEM) >= GEM_START_COST)
{
_donation.purchaseUnknownSalesPackage(player, "Gem Hunters Access", GlobalCurrency.GEM, GEM_START_COST, false, null);
}
}
@EventHandler
public void death(PlayerDeathEvent event)
{
Player player = event.getEntity();
Entity killer = event.getEntity().getKiller();
int oldGems = getGems(player);
if (killer instanceof Player)
{
Player killerPlayer = (Player) killer;
int newGems = (int) (oldGems * GEM_KILL_FACTOR);
addToStore(killerPlayer, "Killing " + F.name(player.getName()), newGems);
}
removeFromStore(player, oldGems);
}
@EventHandler
public void cashOut(PlayerCashOutCompleteEvent event)
{
event.incrementGems(getGems(event.getPlayer()));
}
public void addToStore(Player player, String reason, int gems)
{
Set(player, Get(player) + gems);
if (reason != null)
{
player.sendMessage(F.main(_moduleName, "+" + F.currency(GlobalCurrency.GEM, gems) + " (" + reason + ")."));
}
}
public void removeFromStore(Player player, int gems)
{
addToStore(player, null, -gems);
}
public int getGems(Player player)
{
return Get(player);
}
@Override
protected Integer addPlayer(UUID uuid)
{
return 0;
}
}

44
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/economy/PlayerCashOutCompleteEvent.java Normal file
View File

@ -0,0 +1,44 @@
package mineplex.gemhunters.economy;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
public class PlayerCashOutCompleteEvent extends PlayerEvent
{
private static final HandlerList HANDLERS = new HandlerList();
private int _gems;
public PlayerCashOutCompleteEvent(Player player)
{
super(player);
}
public void incrementGems(int gems)
{
_gems += gems;
}
public void setGems(int gems)
{
_gems = gems;
}
public int getGems()
{
return _gems;
}
public HandlerList getHandlers()
{
return HANDLERS;
}
public static HandlerList getHandlerList()
{
return HANDLERS;
}
}

47
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/economy/command/GiveGemsCommand.java Normal file
View File

@ -0,0 +1,47 @@
package mineplex.gemhunters.economy.command;
import org.bukkit.entity.Player;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.gemhunters.economy.EconomyModule;
public class GiveGemsCommand extends CommandBase<EconomyModule>
{
public GiveGemsCommand(EconomyModule plugin)
{
super(plugin, Rank.ADMIN, "givegems");
}
@Override
public void Execute(Player caller, String[] args)
{
if (args.length < 2)
{
caller.sendMessage(F.help("/" + _aliasUsed + " <player> <amount>", "Adds an amount of gems to a player's gems earned.", Rank.ADMIN));
return;
}
Player target = UtilPlayer.searchOnline(caller, args[0], true);
if (target == null)
{
return;
}
try
{
int amount = Integer.parseInt(args[1]);
Plugin.addToStore(target, "Given by " + F.name(caller.getName()), amount);
}
catch (NumberFormatException e)
{
caller.sendMessage(F.main(Plugin.getName(), "That is not a number."));
}
}
}

107
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/ChestProperties.java Normal file
View File

@ -0,0 +1,107 @@
package mineplex.gemhunters.loot;
import java.util.HashMap;
import java.util.Map;
import org.bukkit.Material;
public class ChestProperties
{
private final String _name;
private final Material _blockMaterial;
private final String _dataKey;
private final int _minAmount;
private final int _maxAmount;
private final int _maxChestPerLoc;
private final int _spawnRate;
private final int _expireRate;
private final int _spawnRadius;
private final int _maxActive;
private final Map<Integer, Integer> _spawnedIndexes;
private long _lastSpawn;
public ChestProperties(String name, Material blockMaterial, String dataKey, int minAmount, int maxAmount, int maxChestPerLoc, int spawnRate, int expireRate, int spawnRadius, int maxActive)
{
_name = name;
_blockMaterial = blockMaterial;
_dataKey = dataKey;
_minAmount = minAmount;
_maxAmount = maxAmount;
_maxChestPerLoc = maxChestPerLoc;
_spawnRate = spawnRate;
_expireRate = expireRate;
_spawnRadius = spawnRadius;
_maxActive = maxActive;
_spawnedIndexes = new HashMap<>();
setLastSpawn();
}
public final String getName()
{
return _name;
}
public final Material getBlockMaterial()
{
return _blockMaterial;
}
public final String getDataKey()
{
return _dataKey;
}
public final int getMinAmount()
{
return _minAmount;
}
public final int getMaxAmount()
{
return _maxAmount;
}
public final int getMaxChestPerLocation()
{
return _maxChestPerLoc;
}
public final int getSpawnRate()
{
return _spawnRate;
}
public final int getExpireRate()
{
return _expireRate;
}
public final int getSpawnRadius()
{
return _spawnRadius;
}
public final int getMaxActive()
{
return _maxActive;
}
public final Map<Integer, Integer> getSpawnIndexes()
{
return _spawnedIndexes;
}
public void setLastSpawn()
{
_lastSpawn = System.currentTimeMillis();
}
public long getLastSpawn()
{
return _lastSpawn;
}
}

133
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/InventoryModule.java Normal file
View File

@ -0,0 +1,133 @@
package mineplex.gemhunters.loot;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilEvent;
import mineplex.core.common.util.UtilEvent.ActionType;
import mineplex.core.common.util.UtilInv;
import mineplex.core.itemstack.ItemBuilder;
import mineplex.gemhunters.death.event.PlayerCustomRespawnEvent;
@ReflectivelyCreateMiniPlugin
public class InventoryModule extends MiniPlugin
{
public static final ItemStack LOCKED = new ItemBuilder(Material.STAINED_GLASS_PANE, (byte) 15).setTitle(C.cGray + "Locked").build();
private static final int START_INDEX = 9;
private static final String ITEM_METADATA = "UNLOCKER";
private final LootModule _loot;
private final Map<UUID, Integer> _slotsUnlocked;
private InventoryModule()
{
super("Unlocker");
_loot = require(LootModule.class);
_slotsUnlocked = new HashMap<>();
}
@EventHandler
public void respawn(PlayerCustomRespawnEvent event)
{
Player player = event.getPlayer();
Inventory inv = player.getInventory();
_slotsUnlocked.put(player.getUniqueId(), 0);
for (int i = START_INDEX; i < inv.getSize(); i++)
{
inv.setItem(i, LOCKED);
}
}
@EventHandler
public void quit(PlayerQuitEvent event)
{
_slotsUnlocked.remove(event.getPlayer().getUniqueId());
}
@EventHandler
public void inventoryClick(InventoryClickEvent event)
{
Player player = (Player) event.getWhoClicked();
if (event.getClickedInventory() == null || event.getCurrentItem() == null)
{
return;
}
if (event.getCurrentItem().isSimilar(LOCKED))
{
event.setCancelled(true);
player.playSound(player.getLocation(), Sound.ITEM_BREAK, 1, 0.6F);
}
}
@EventHandler
public void interact(PlayerInteractEvent event)
{
if (!UtilEvent.isAction(event, ActionType.R))
{
return;
}
Player player = event.getPlayer();
ItemStack itemStack = player.getItemInHand();
if (itemStack == null)
{
return;
}
LootItem lootItem = _loot.fromItemStack(itemStack);
if (lootItem == null || lootItem.getMetadata() == null || !lootItem.getMetadata().equals(ITEM_METADATA))
{
return;
}
player.setItemInHand(UtilInv.decrement(itemStack));
unlockSlots(player, itemStack.getType() == Material.CHEST ? 9 : 18);
}
public void unlockSlots(Player player, int slots)
{
Inventory inv = player.getInventory();
UUID key = player.getUniqueId();
int start = START_INDEX + _slotsUnlocked.get(key);
int end = Math.min(inv.getSize(), start + slots);
int delta = end - start;
//DebugModule.getInstance().d("start=" + start);
//DebugModule.getInstance().d("end=" + end);
//DebugModule.getInstance().d("delta=" + delta);
for (int i = start; i < end; i++)
{
inv.setItem(i, null);
}
player.sendMessage(F.main(_moduleName, "You unlocked an additional " + F.count(String.valueOf(delta)) + " slots of your inventory!"));
_slotsUnlocked.put(key, _slotsUnlocked.get(key) + slots);
}
}

90
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/LootItem.java Normal file
View File

@ -0,0 +1,90 @@
package mineplex.gemhunters.loot;
import org.bukkit.inventory.ItemStack;
import mineplex.core.common.util.UtilMath;
/**
* Represents an item that can be contained in a chest inside the Gem Hunters
* world.
*/
public class LootItem
{
private final ItemStack _itemStack;
private final int _minAmount;
private final int _maxAmount;
private final double _probability;
private final String _metadata;
public LootItem(ItemStack itemStack, int minAmount, int maxAmount, double probability, String metadata)
{
_itemStack = itemStack;
_minAmount = minAmount;
_maxAmount = maxAmount;
_probability = probability;
_metadata = metadata;
}
/**
* Returns the Minecraft {@link ItemStack} bound to this
* {@link LootItem}.<br>
* The {@link ItemStack} returned will have an amount/size between the
* minAmount and maxAmount integers (set within the constuctor's parameters)
* inclusively.
*
* @return
*/
public ItemStack getItemStack()
{
_itemStack.setAmount(_minAmount + UtilMath.r(_maxAmount - _minAmount + 1));
return _itemStack;
}
/**
* The minimum amount or size an {@link ItemStack} of this {@link LootItem}
* can have.
*
* @return
*/
public int getMinAmount()
{
return _minAmount;
}
/**
* The maximum amount or size an {@link ItemStack} of this {@link LootItem}
* can have.
*
* @return
*/
public int getMaxAmount()
{
return _maxAmount;
}
/**
* The double value of the item's probability of being chosen to when
* picking an individual chest's loot.
*
* @return
*/
public double getProbability()
{
return _probability;
}
/**
* Any metadata bound to a {@link LootItem}. Useful for determining if an
* item has a particular <i>skill</i> or <i>ability</i> attached to it which
* you can use in code.
*
* @return
*/
public String getMetadata()
{
return _metadata;
}
}

662
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/LootModule.java Normal file
View File

@ -0,0 +1,662 @@
package mineplex.gemhunters.loot;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import org.bukkit.Bukkit;
import org.bukkit.Effect;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;
import org.bukkit.block.Chest;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import mineplex.core.MiniPlugin;
import mineplex.core.ReflectivelyCreateMiniPlugin;
import mineplex.core.common.util.UtilAlg;
import mineplex.core.common.util.UtilBlock;
import mineplex.core.common.util.UtilEvent;
import mineplex.core.common.util.UtilEvent.ActionType;
import mineplex.core.common.util.UtilInv;
import mineplex.core.common.util.UtilMath;
import mineplex.core.common.util.UtilServer;
import mineplex.core.common.util.UtilTime;
import mineplex.core.google.GoogleSheetsManager;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import mineplex.gemhunters.economy.EconomyModule;
import mineplex.gemhunters.economy.PlayerCashOutCompleteEvent;
import mineplex.gemhunters.loot.command.SpawnChestCommand;
import mineplex.gemhunters.loot.command.UpdateLootCommand;
import mineplex.gemhunters.loot.deserialisers.ChestPropertiesDeserialiser;
import mineplex.gemhunters.loot.deserialisers.LootItemDeserialiser;
import mineplex.gemhunters.loot.event.PlayerChestOpenEvent;
import mineplex.gemhunters.loot.rewards.LootChestReward;
import mineplex.gemhunters.loot.rewards.LootGadgetReward;
import mineplex.gemhunters.loot.rewards.LootItemReward;
import mineplex.gemhunters.loot.rewards.LootRankReward;
import mineplex.gemhunters.loot.rewards.LootShardReward;
import mineplex.gemhunters.safezone.SafezoneModule;
import mineplex.gemhunters.spawn.event.PlayerTeleportIntoMapEvent;
import mineplex.gemhunters.util.SlackSheetsBot;
import mineplex.gemhunters.world.WorldDataModule;
@ReflectivelyCreateMiniPlugin
public class LootModule extends MiniPlugin
{
private static final String SHEET_FILE_NAME = "GEM_HUNTERS_CHESTS";
private static final String CHEST_MASTER_SHEET_NAME = "CHEST_MASTER";
private static final long CHEST_DESPAWN_TIME_OPENED = TimeUnit.SECONDS.toMillis(15);
private static final float CHESTS_ON_START_FACTOR = 0.333F;
private static final int MAX_SEARCH_ATTEMPTS = 40;
private static final int MAX_CHEST_CHECK_DISTANCE_SQUARED = 4;
private static final LootItemDeserialiser DESERIALISER = new LootItemDeserialiser();
private static final ChestPropertiesDeserialiser CHEST_DESERIALISER = new ChestPropertiesDeserialiser();
private static final ItemStack[] SPAWN_ITEMS = {
new ItemStack(Material.WOOD_SWORD),
new ItemStack(Material.APPLE, 3),
};
private static final String GEM_METADATA = "GEM";
private final EconomyModule _economy;
private final GoogleSheetsManager _sheets;
private final SafezoneModule _safezone;
private final WorldDataModule _worldData;
private final Map<String, Set<LootItem>> _chestLoot;
private final Map<String, ChestProperties> _chestProperties;
private final Set<SpawnedChest> _spawnedChest;
private final Set<LootItemReward> _itemRewards;
private final Set<UUID> _shownPlayers;
private LootModule()
{
super("Loot");
_economy = require(EconomyModule.class);
_sheets = require(GoogleSheetsManager.class);
_safezone = require(SafezoneModule.class);
_worldData = require(WorldDataModule.class);
_chestLoot = new HashMap<>();
_chestProperties = new HashMap<>();
_spawnedChest = new HashSet<>();
_itemRewards = new HashSet<>();
_shownPlayers = new HashSet<>();
runSyncLater(() -> {
updateChestLoot();
// Spawn some chests
for (String key : _chestProperties.keySet())
{
int max = _chestProperties.get(key).getMaxActive();
for (int i = 0; i < max * CHESTS_ON_START_FACTOR; i++)
{
addSpawnedChest(key, true);
}
}
}, 20);
}
@Override
public void addCommands()
{
addCommand(new UpdateLootCommand(this));
addCommand(new SpawnChestCommand(this));
}
@EventHandler
public void updateSpawnChests(UpdateEvent event)
{
if (event.getType() != UpdateType.SEC)
{
return;
}
// Despawn opened chests
Iterator<SpawnedChest> iterator = _spawnedChest.iterator();
while (iterator.hasNext())
{
SpawnedChest chest = iterator.next();
ChestProperties properties = chest.getProperties();
if (chest.isOpened() && UtilTime.elapsed(chest.getOpenedAt(), CHEST_DESPAWN_TIME_OPENED) || UtilTime.elapsed(chest.getSpawnedAt(), properties.getExpireRate()))
{
if (chest.getID() != -1)
{
properties.getSpawnIndexes().put(chest.getID(), properties.getSpawnIndexes().get(chest.getID()) - 1);
}
Block block = chest.getLocation().getBlock();
if (block.getState() instanceof Chest)
{
((Chest) block.getState()).getBlockInventory().clear();
}
block.getWorld().playEffect(chest.getLocation(), Effect.STEP_SOUND, block.getType());
block.setType(Material.AIR);
iterator.remove();
}
}
// Spawn new chests
for (String key : _chestProperties.keySet())
{
addSpawnedChest(key, false);
}
}
public boolean isSuitable(Block block)
{
Block up = block.getRelative(BlockFace.UP);
Block down = block.getRelative(BlockFace.DOWN);
if (block.getType() != Material.AIR || up.getType() != Material.AIR || down.getType() == Material.AIR || UtilBlock.liquid(down) || UtilBlock.liquid(up) || UtilBlock.liquid(block) || _safezone.isInSafeZone(block.getLocation()))
{
return false;
}
return true;
}
public void updateChestLoot()
{
log("Updating chest loot");
Map<String, List<List<String>>> map = _sheets.getSheetData(SHEET_FILE_NAME);
for (String key : map.keySet())
{
if (key.equals(CHEST_MASTER_SHEET_NAME))
{
int row = 0;
for (List<String> rows : map.get(key))
{
row++;
try
{
ChestProperties properties = CHEST_DESERIALISER.deserialise(rows.toArray(new String[0]));
_chestProperties.put(properties.getDataKey(), properties);
}
catch (Exception e)
{
if (row != 1)
{
SlackSheetsBot.reportParsingError(e, "Chest Loot", key, row);
}
continue;
}
}
continue;
}
Set<LootItem> items = new HashSet<>();
int row = 0;
for (List<String> rows : map.get(key))
{
row++;
try
{
items.add(DESERIALISER.deserialise(rows.toArray(new String[0])));
}
catch (Exception e)
{
if (row != 1)
{
SlackSheetsBot.reportParsingError(e, "Chest Loot", key, row);
}
continue;
}
}
_chestLoot.put(key, items);
}
log("Finished updating chest loot");
}
public void addSpawnedChest(String key, boolean force)
{
if (key.equals("PURPLE") && Bukkit.getOnlinePlayers().size() < 10)
{
return;
}
List<Location> locations = _worldData.getDataLocation(key);
ChestProperties properties = _chestProperties.get(key);
if (!force && !UtilTime.elapsed(properties.getLastSpawn(), properties.getSpawnRate()))
{
return;
}
properties.setLastSpawn();
// Only spawn more chests if we need to
int max = properties.getMaxActive();
int spawned = 0;
for (SpawnedChest chest : _spawnedChest)
{
if (chest.getProperties().getDataKey().equals(key))
{
spawned++;
}
}
// If there are too many chests of this type we can ignore it
if (spawned > max)
{
return;
}
if (locations.isEmpty())
{
return;
}
Map<Integer, Integer> spawnedIndexes = properties.getSpawnIndexes();
Location randomLocation = null;
boolean found = false;
int attempts = 0;
int index = -1;
while (index == -1 || !found && attempts < MAX_SEARCH_ATTEMPTS)
{
attempts++;
index = UtilMath.r(locations.size());
if (spawnedIndexes.getOrDefault(index, 0) >= properties.getMaxChestPerLocation())
{
continue;
}
}
if (index == -1)
{
return;
}
spawnedIndexes.put(index, spawnedIndexes.getOrDefault(index, 0) + 1);
randomLocation = locations.get(index);
int placeRadius = properties.getSpawnRadius();
Location chestToPlace = UtilAlg.getRandomLocation(randomLocation, placeRadius, 0, placeRadius);
Block block = chestToPlace.getBlock();
attempts = 0;
boolean suitable = false;
while (!suitable && attempts < MAX_SEARCH_ATTEMPTS)
{
chestToPlace = UtilAlg.getRandomLocation(randomLocation, placeRadius, 0, placeRadius);
block = chestToPlace.getBlock();
suitable = isSuitable(block);
attempts++;
}
if (!suitable)
{
return;
}
//DebugModule.getInstance().d("Spawned at " + UtilWorld.blockToStrClean(block) + " with key=" + key + " and index=" + index + " and max=" + spawned + "/" + max);
_spawnedChest.add(new SpawnedChest(chestToPlace, properties, index));
block.setType(properties.getBlockMaterial());
}
public void addSpawnedChest(Location location, String colour)
{
_spawnedChest.add(new SpawnedChest(location, _chestProperties.get(colour), -1));
}
public void fillChest(Player player, Block block, String key)
{
Set<Integer> used = new HashSet<>();
Set<LootItem> items = _chestLoot.get(key);
ChestProperties properties = _chestProperties.get(key);
Inventory inventory = null;
if (block.getType() == Material.ENDER_CHEST)
{
inventory = player.getEnderChest();
}
else
{
BlockState state = block.getState();
Chest chest = (Chest) state;
inventory = chest.getBlockInventory();
}
inventory.clear();
for (int i = 0; i < UtilMath.rRange(properties.getMinAmount(), properties.getMaxAmount()); i++)
{
LootItem lootItem = getRandomItem(items);
ItemStack itemStack = lootItem.getItemStack();
int index = getFreeIndex(inventory.getSize(), used);
inventory.setItem(index, itemStack);
}
}
public LootItem getRandomItem(Set<LootItem> items)
{
double totalWeight = 0;
for (LootItem item : items)
{
totalWeight += item.getProbability();
}
double select = Math.random() * totalWeight;
for (LootItem item : items)
{
if ((select -= item.getProbability()) <= 0)
{
return item;
}
}
return null;
}
private int getFreeIndex(int endIndex, Set<Integer> used)
{
int index = -1;
while (index == -1 || used.contains(index))
{
index = UtilMath.r(endIndex);
}
used.add(index);
return index;
}
public LootItem fromItemStack(ItemStack itemStack)
{
if (itemStack == null)
{
return null;
}
for (Set<LootItem> items : _chestLoot.values())
{
for (LootItem item : items)
{
if (item.getItemStack().isSimilar(itemStack))
{
return item;
}
}
}
return null;
}
public boolean hasChestBeenOpened(Location location)
{
for (SpawnedChest chest : _spawnedChest)
{
if (chest.getLocation().distanceSquared(location) < MAX_CHEST_CHECK_DISTANCE_SQUARED && chest.isOpened())
{
return true;
}
}
return false;
}
@EventHandler
public void chestOpen(PlayerInteractEvent event)
{
if (event.isCancelled() || !UtilEvent.isAction(event, ActionType.R_BLOCK))
{
return;
}
Player player = event.getPlayer();
Block block = event.getClickedBlock();
if (block.getType() != Material.CHEST && block.getType() != Material.ENDER_CHEST)
{
return;
}
if (hasChestBeenOpened(block.getLocation()))
{
return;
}
String key = null;
for (SpawnedChest chest : _spawnedChest)
{
if (UtilMath.offsetSquared(chest.getLocation(), block.getLocation()) < MAX_CHEST_CHECK_DISTANCE_SQUARED)
{
key = chest.getProperties().getDataKey();
chest.setOpened();
break;
}
}
if (key == null)
{
event.setCancelled(true);
return;
}
PlayerChestOpenEvent openEvent = new PlayerChestOpenEvent(player, block, _chestProperties.get(key));
UtilServer.CallEvent(openEvent);
if (openEvent.isCancelled())
{
event.setCancelled(true);
return;
}
fillChest(player, block, key);
}
@EventHandler
public void inventoryClick(InventoryClickEvent event)
{
if (event.getClickedInventory() == null)
{
return;
}
ItemStack itemStack = event.getCurrentItem();
if (itemStack == null)
{
return;
}
handleRewardItem((Player) event.getWhoClicked(), itemStack);
}
@EventHandler
public void pickupItem(PlayerPickupItemEvent event)
{
if (event.getItem() == null)
{
return;
}
handleRewardItem(event.getPlayer(), event.getItem().getItemStack());
}
public void handleRewardItem(Player player, ItemStack itemStack)
{
LootItem lootItem = fromItemStack(itemStack);
if (lootItem == null || lootItem.getMetadata() == null)
{
return;
}
LootItemReward reward = null;
for (LootItemReward storedReward : _itemRewards)
{
if (storedReward.getItemStack().isSimilar(itemStack))
{
reward = storedReward;
}
}
if (reward == null)
{
String[] metadataSplit = lootItem.getMetadata().split(" ");
String key = metadataSplit[0];
String[] values = new String[metadataSplit.length - 1];
for (int i = 1; i < metadataSplit.length; i++)
{
values[i - 1] = metadataSplit[i];
}
switch (key)
{
case "RANK_UPGRADE":
reward = new LootRankReward(itemStack);
break;
case "SHARD":
reward = new LootShardReward(Integer.parseInt(values[0]) * 1000, itemStack, Integer.parseInt(values[1]));
break;
case "CHEST":
reward = new LootChestReward(Integer.parseInt(values[0]) * 1000, itemStack, values[1], Integer.parseInt(values[2]));
break;
case "GADGET":
String gadget = "";
for (int i = 1; i < values.length; i++)
{
gadget += values[i] + " ";
}
reward = new LootGadgetReward(Integer.parseInt(values[0]) * 1000, itemStack, gadget.trim());
break;
default:
return;
}
_itemRewards.add(reward);
}
reward.collectItem(player);
}
@EventHandler
public void gemClick(PlayerInteractEvent event)
{
if (!UtilEvent.isAction(event, ActionType.R))
{
return;
}
Player player = event.getPlayer();
ItemStack itemStack = player.getItemInHand();
if (itemStack == null)
{
return;
}
LootItem lootItem = fromItemStack(itemStack);
if (lootItem == null || lootItem.getMetadata() == null || !lootItem.getMetadata().startsWith(GEM_METADATA))
{
return;
}
player.setItemInHand(UtilInv.decrement(itemStack));
int amount = Integer.parseInt(lootItem.getMetadata().split(" ")[1]);
_economy.addToStore(player, "Gem Item", amount);
}
@EventHandler
public void mapUpdate(UpdateEvent event)
{
if (event.getType() != UpdateType.SEC)
{
return;
}
_shownPlayers.clear();
for (Player player : Bukkit.getOnlinePlayers())
{
UUID key = player.getUniqueId();
for (LootItemReward itemReward : _itemRewards)
{
if (itemReward.getPlayer().equals(player))
{
_shownPlayers.add(key);
break;
}
}
}
}
@EventHandler
public void mapTeleport(PlayerTeleportIntoMapEvent event)
{
event.getPlayer().getInventory().addItem(SPAWN_ITEMS);
}
@EventHandler
public void cashOutComplete(PlayerCashOutCompleteEvent event)
{
Player player = event.getPlayer();
Iterator<LootItemReward> iterator = _itemRewards.iterator();
while (iterator.hasNext())
{
LootItemReward reward = iterator.next();
if (player.equals(reward.getPlayer()))
{
reward.success();
iterator.remove();
}
}
}
public final Set<UUID> getShownPlayers()
{
return _shownPlayers;
}
}

59
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/SpawnedChest.java Normal file
View File

@ -0,0 +1,59 @@
package mineplex.gemhunters.loot;
import org.bukkit.Location;
public class SpawnedChest
{
private Location _location;
private ChestProperties _properties;
private int _id;
private long _spawnedAt;
private long _openedAt;
public SpawnedChest(Location location, ChestProperties properties, int id)
{
_location = location;
_properties =properties;
_id = id;
_spawnedAt = System.currentTimeMillis();
_openedAt = 0;
}
public void setOpened()
{
_openedAt = System.currentTimeMillis();
}
public Location getLocation()
{
return _location;
}
public ChestProperties getProperties()
{
return _properties;
}
public int getID()
{
return _id;
}
public long getSpawnedAt()
{
return _spawnedAt;
}
public long getOpenedAt()
{
return _openedAt;
}
public boolean isOpened()
{
return _openedAt != 0;
}
}

47
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/command/SpawnChestCommand.java Normal file
View File

@ -0,0 +1,47 @@
package mineplex.gemhunters.loot.command;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.gemhunters.loot.LootModule;
public class SpawnChestCommand extends CommandBase<LootModule>
{
public SpawnChestCommand(LootModule plugin)
{
super(plugin, Rank.ADMIN, "spawnchest");
}
@Override
public void Execute(Player caller, String[] args)
{
if (args.length == 0)
{
caller.sendMessage(F.help("/" + _aliasUsed + " <colour>", "Spawns a chest at your location.", GetRequiredRank()));
return;
}
String colour = args[0].toUpperCase();
try
{
DyeColor.valueOf(colour);
}
catch (IllegalArgumentException e)
{
caller.sendMessage(F.main(Plugin.getName(), "That is not a valid colour."));
return;
}
caller.sendMessage(F.main(Plugin.getName(), "Spawned a " + colour + " chest at your location."));
caller.getLocation().getBlock().setType(Material.CHEST);
Plugin.addSpawnedChest(caller.getLocation(), colour);
}
}

33
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/command/UpdateLootCommand.java Normal file
View File

@ -0,0 +1,33 @@
package mineplex.gemhunters.loot.command;
import org.bukkit.entity.Player;
import mineplex.core.command.CommandBase;
import mineplex.core.common.Rank;
import mineplex.core.common.util.F;
import mineplex.gemhunters.loot.LootModule;
/**
* An ADMIN command that allows users to retrieve the latest data from the
* google sheet and update all locally cached loot tables.
*/
public class UpdateLootCommand extends CommandBase<LootModule>
{
public UpdateLootCommand(LootModule plugin)
{
super(plugin, Rank.ADMIN, "updateloot");
}
@Override
public void Execute(Player caller, String[] args)
{
if (args.length > 1)
{
// TODO send redis message
}
caller.sendMessage(F.main(Plugin.getName(), "This command is currently disabled due to development issues."));
}
}

43
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/deserialisers/ChestPropertiesDeserialiser.java Normal file
View File

@ -0,0 +1,43 @@
package mineplex.gemhunters.loot.deserialisers;
import org.bukkit.Material;
import mineplex.core.google.SheetObjectDeserialiser;
import mineplex.gemhunters.loot.ChestProperties;
public class ChestPropertiesDeserialiser implements SheetObjectDeserialiser<ChestProperties>
{
@Override
public ChestProperties deserialise(String[] values) throws ArrayIndexOutOfBoundsException
{
String name = values[0];
Material blockMaterial = Material.valueOf(values[1]);
String dataKey = values[2];
int minAmount = 1;
int maxAmount = 1;
String[] numbers = values[3].split("-");
if (numbers.length != 2)
{
minAmount = Integer.parseInt(String.valueOf(values[3]));
maxAmount = minAmount;
}
else
{
minAmount = Integer.parseInt(numbers[0]);
maxAmount = Integer.parseInt(numbers[1]);
}
int spawnRate = Integer.parseInt(values[4]);
int expireRate = Integer.parseInt(values[5]);
int maxChestsPerLoc = Integer.parseInt(values[6]);
int spawnRadius = Integer.parseInt(values[7]);
int maxActive = Integer.parseInt(values[8]);
return new ChestProperties(name, blockMaterial, dataKey, minAmount, maxAmount, maxChestsPerLoc, spawnRate, expireRate, spawnRadius, maxActive);
}
}

100
Plugins/mineplex-game-gemhunters/src/mineplex/gemhunters/loot/deserialisers/LootItemDeserialiser.java Normal file
View File

@ -0,0 +1,100 @@
package mineplex.gemhunters.loot.deserialisers;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import mineplex.core.google.SheetObjectDeserialiser;
import mineplex.core.itemstack.ItemBuilder;
import mineplex.gemhunters.loot.LootItem;
import net.md_5.bungee.api.ChatColor;
/**
* This is a {@link LootItem} deserialiser for Google Sheet interpretation.<br>
* <br>
* Arguments should follow the form:<br>
* <ul>
* <li>Material</li>
* <li>Material Data</li>
* <li>Max Durability</li>
* <li>Amount</li>
* <li>Item Name <i>(optional)</i></li>
* <li>Item Lore <i>(optional) each line separated by colons</i></li>
* <li>Enchantments <i>(optional) Has a NAME:LEVEL format with multiple
* enchantments being separated by commas</i></li>
* <li>Probability</li>
* <li>Metadata <i>(optional)</i></li>
* </ul>
* Thus derserialise is guaranteed to have at least 8 strings passed in.<br>
* If an illegal argument is passed in, derserialise will throw an exception,
* these should be handled by the caller.
*
* @see SheetObjectDeserialiser
*/
public class LootItemDeserialiser implements SheetObjectDeserialiser<LootItem>
{
@Override
public LootItem deserialise(String[] values) throws ArrayIndexOutOfBoundsException, IllegalArgumentException, NumberFormatException
{
Material material = Material.valueOf(values[0]);
byte data = values[1].equals("") ? 0 : Byte.parseByte(values[1]);
int minAmount = 1;
int maxAmount = 1;
short durability = values[2].equals("") ? 0 : Short.valueOf(values[2]);
String[] numbers = values[3].split("-");
if (numbers.length != 2)
{
minAmount = Integer.parseInt(values[3].equals("") ? "1" : values[3]);
maxAmount = minAmount;
}
else
{
minAmount = Integer.parseInt(numbers[0]);
maxAmount = Integer.parseInt(numbers[1]);
}
ItemBuilder builder = new ItemBuilder(material, data);
builder.setDurability(durability);
String title = ChatColor.translateAlternateColorCodes('&', values[4]);
builder.setTitle(title);
if (!values[5].equals(""))
{
String[] lore = values[5].split(":");
String[] colouredLore = new String[lore.length];
int loreIndex = 0;
for (String line : lore)
{
colouredLore[loreIndex++] = ChatColor.translateAlternateColorCodes('&', line);
}
builder.setLore(colouredLore);
}
String[] enchants = String.valueOf(values[6]).split(",");
for (String enchant : enchants)
{
String[] enchantData = enchant.split(":");
if (enchantData.length < 2)
{
continue;
}
builder.addEnchantment(Enchantment.getByName(enchantData[0]), Integer.parseInt(enchantData[1]));
}
double proability = Double.parseDouble(values[7]);
String metadata = values.length > 8 ? values[8] : null;
return new LootItem(builder.build(), minAmount, maxAmount, proability, metadata);
}
}

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