535 lines
17 KiB
Java
535 lines
17 KiB
Java
package mineplex.game.clans.items;
|
|
|
|
import java.util.ArrayList;
|
|
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 org.bukkit.GameMode;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.inventory.ItemStack;
|
|
import org.bukkit.inventory.meta.ItemMeta;
|
|
import org.bukkit.plugin.java.JavaPlugin;
|
|
|
|
import com.google.gson.Gson;
|
|
import com.google.gson.GsonBuilder;
|
|
|
|
import mineplex.core.MiniPlugin;
|
|
import mineplex.core.account.CoreClientManager;
|
|
import mineplex.core.common.util.F;
|
|
import mineplex.core.common.util.UtilPlayer;
|
|
import mineplex.core.common.util.UtilServer;
|
|
import mineplex.core.donation.DonationManager;
|
|
import mineplex.core.packethandler.IPacketHandler;
|
|
import mineplex.core.packethandler.PacketHandler;
|
|
import mineplex.core.packethandler.PacketInfo;
|
|
import mineplex.game.clans.items.attributes.AttributeContainer;
|
|
import mineplex.game.clans.items.attributes.AttributeType;
|
|
import mineplex.game.clans.items.attributes.ItemAttribute;
|
|
import mineplex.game.clans.items.attributes.armor.ConqueringArmorAttribute;
|
|
import mineplex.game.clans.items.attributes.armor.LavaAttribute;
|
|
import mineplex.game.clans.items.attributes.armor.PaddedAttribute;
|
|
import mineplex.game.clans.items.attributes.armor.ReinforcedAttribute;
|
|
import mineplex.game.clans.items.attributes.armor.SlantedAttribute;
|
|
import mineplex.game.clans.items.attributes.bow.HeavyArrowsAttribute;
|
|
import mineplex.game.clans.items.attributes.bow.HuntingAttribute;
|
|
import mineplex.game.clans.items.attributes.bow.InverseAttribute;
|
|
import mineplex.game.clans.items.attributes.bow.LeechingAttribute;
|
|
import mineplex.game.clans.items.attributes.bow.RecursiveAttribute;
|
|
import mineplex.game.clans.items.attributes.bow.ScorchingAttribute;
|
|
import mineplex.game.clans.items.attributes.bow.SlayingAttribute;
|
|
import mineplex.game.clans.items.attributes.weapon.ConqueringAttribute;
|
|
import mineplex.game.clans.items.attributes.weapon.FlamingAttribute;
|
|
import mineplex.game.clans.items.attributes.weapon.FrostedAttribute;
|
|
import mineplex.game.clans.items.attributes.weapon.HasteAttribute;
|
|
import mineplex.game.clans.items.attributes.weapon.JaggedAttribute;
|
|
import mineplex.game.clans.items.attributes.weapon.SharpAttribute;
|
|
import mineplex.game.clans.items.commands.GearCommand;
|
|
import mineplex.game.clans.items.economy.GoldToken;
|
|
import mineplex.game.clans.items.generation.Weight;
|
|
import mineplex.game.clans.items.generation.WeightSet;
|
|
import mineplex.game.clans.items.legendaries.AlligatorsTooth;
|
|
import mineplex.game.clans.items.legendaries.GiantsBroadsword;
|
|
import mineplex.game.clans.items.legendaries.HyperBlade;
|
|
import mineplex.game.clans.items.legendaries.LegendaryItem;
|
|
import mineplex.game.clans.items.legendaries.MagneticBlade;
|
|
import mineplex.game.clans.items.legendaries.WindBlade;
|
|
import mineplex.game.clans.items.smelting.SmeltingListener;
|
|
import mineplex.game.clans.items.ui.GearShop;
|
|
import mineplex.serverdata.serialization.RuntimeTypeAdapterFactory;
|
|
import net.minecraft.server.v1_8_R3.Packet;
|
|
import net.minecraft.server.v1_8_R3.PacketPlayOutChat;
|
|
import net.minecraft.server.v1_8_R3.PacketPlayOutSetSlot;
|
|
import net.minecraft.server.v1_8_R3.PacketPlayOutWindowItems;
|
|
|
|
/**
|
|
* Manages creation and retrieval of associated {@link PlayerGear}s with online
|
|
* players, as well as offering methods for parsing and handling
|
|
* {@link CustomItem}s.
|
|
*
|
|
* @author MrTwiggy
|
|
*
|
|
*/
|
|
public class GearManager extends MiniPlugin implements IPacketHandler, Runnable
|
|
{
|
|
private static final String ITEM_SERIALIZATION_TAG = "-JSON-";
|
|
private static Gson _gson;
|
|
private static GearManager _instance; // Singleton instance
|
|
|
|
private Map<String, PlayerGear> _playerGears; // Mapping of player names
|
|
// (key) to cached gear set
|
|
// (value).
|
|
private WeightSet<Integer> _attributeWeights; // Weightings for randomly
|
|
// selecting number of
|
|
// attributes (1, 2, 3)
|
|
private WeightSet<ItemType> _typeWeights; // Weightings for randomly
|
|
// selecting item type
|
|
// (legendary/weapon/armor/bow)
|
|
private Set<String> _creativePlayers; // Set of names for all players
|
|
// currently in Creative gamemode
|
|
|
|
// Legendary generation
|
|
private WeightSet<Class<? extends LegendaryItem>> _legendaryWeights;
|
|
|
|
// Weapon generation
|
|
private WeightSet<Material> _weaponTypes;
|
|
|
|
// Armor generation
|
|
private WeightSet<Material> _armorTypes;
|
|
|
|
// Attribute generation
|
|
private WeightSet<Class<? extends ItemAttribute>> _weaponAttributes;
|
|
private WeightSet<Class<? extends ItemAttribute>> _armorAttributes;
|
|
private WeightSet<Class<? extends ItemAttribute>> _bowAttributes;
|
|
|
|
private GearShop _shop;
|
|
|
|
public GearManager(JavaPlugin plugin, PacketHandler packetHandler, CoreClientManager clientManager, DonationManager donationManager)
|
|
{
|
|
super("CustomGear", plugin);
|
|
|
|
_instance = this;
|
|
|
|
_shop = new GearShop(this, clientManager, donationManager);
|
|
|
|
_creativePlayers = new HashSet<String>();
|
|
_playerGears = new HashMap<String, PlayerGear>();
|
|
// TODO: Introduce configurable non-hardcoded values for generation
|
|
// weights?
|
|
_attributeWeights = new WeightSet<Integer>(new Weight<Integer>(3, 3), new Weight<Integer>(20, 2), new Weight<Integer>(77, 1));
|
|
_typeWeights = new WeightSet<ItemType>(new Weight<ItemType>(10, ItemType.LEGENDARY), new Weight<ItemType>(45, ItemType.ARMOR), new Weight<ItemType>(23, ItemType.WEAPON), new Weight<ItemType>(22, ItemType.BOW));
|
|
|
|
// Weapon-based attributes
|
|
_weaponAttributes = new WeightSet<Class<? extends ItemAttribute>>(FrostedAttribute.class, SharpAttribute.class, JaggedAttribute.class, HasteAttribute.class, FlamingAttribute.class, ConqueringAttribute.class);
|
|
|
|
// Armor-based attributes
|
|
_armorAttributes = new WeightSet<Class<? extends ItemAttribute>>(SlantedAttribute.class, ReinforcedAttribute.class, ConqueringArmorAttribute.class, PaddedAttribute.class, LavaAttribute.class);
|
|
|
|
// Bow-based attributes
|
|
_bowAttributes = new WeightSet<Class<? extends ItemAttribute>>(HeavyArrowsAttribute.class, HuntingAttribute.class, InverseAttribute.class, LeechingAttribute.class, RecursiveAttribute.class, ScorchingAttribute.class, SlayingAttribute.class);
|
|
|
|
// Weapon material types
|
|
_weaponTypes = new WeightSet<Material>(Material.DIAMOND_SWORD, Material.GOLD_SWORD, Material.IRON_SWORD, Material.DIAMOND_AXE, Material.GOLD_AXE, Material.IRON_AXE);
|
|
|
|
// Armor material types
|
|
_armorTypes = new WeightSet<Material>(Material.DIAMOND_HELMET, Material.DIAMOND_CHESTPLATE, Material.DIAMOND_LEGGINGS, Material.DIAMOND_BOOTS, Material.IRON_HELMET, Material.IRON_CHESTPLATE, Material.IRON_LEGGINGS, Material.IRON_BOOTS, Material.GOLD_HELMET, Material.GOLD_CHESTPLATE, Material.GOLD_LEGGINGS, Material.GOLD_BOOTS);
|
|
|
|
// TODO: Initialize list of attributes and types
|
|
|
|
// Initialize various LegendaryItem types
|
|
_legendaryWeights = new WeightSet<Class<? extends LegendaryItem>>(AlligatorsTooth.class, WindBlade.class, GiantsBroadsword.class, HyperBlade.class, MagneticBlade.class);
|
|
// TODO: Add rest of legendaries, find better way?
|
|
|
|
// Register listeners
|
|
UtilServer.getServer().getPluginManager().registerEvents(new ItemListener(getPlugin()), getPlugin());
|
|
UtilServer.getServer().getPluginManager().registerEvents(new SmeltingListener(), getPlugin());
|
|
|
|
// Initialize attribute types factory for JSON handling of polymorphism.
|
|
RuntimeTypeAdapterFactory<ItemAttribute> attributeFactory = RuntimeTypeAdapterFactory.of(ItemAttribute.class);
|
|
|
|
for (Class<? extends ItemAttribute> attributeType : _armorAttributes.elements())
|
|
{
|
|
attributeFactory.registerSubtype(attributeType);
|
|
}
|
|
for (Class<? extends ItemAttribute> attributeType : _weaponAttributes.elements())
|
|
{
|
|
attributeFactory.registerSubtype(attributeType);
|
|
}
|
|
for (Class<? extends ItemAttribute> attributeType : _bowAttributes.elements())
|
|
{
|
|
attributeFactory.registerSubtype(attributeType);
|
|
}
|
|
|
|
// Initialize legendary item type factory for JSON handling of
|
|
// polymorphism.
|
|
RuntimeTypeAdapterFactory<CustomItem> customItemType = RuntimeTypeAdapterFactory.of(CustomItem.class);
|
|
customItemType.registerSubtype(CustomItem.class);
|
|
customItemType.registerSubtype(LegendaryItem.class);
|
|
customItemType.registerSubtype(GoldToken.class);
|
|
for (Class<? extends CustomItem> itemType : _legendaryWeights.elements())
|
|
{
|
|
customItemType.registerSubtype(itemType);
|
|
}
|
|
|
|
// Build GSON instance off factories for future serialization of items.
|
|
_gson = new GsonBuilder().registerTypeAdapterFactory(attributeFactory).registerTypeAdapterFactory(customItemType).create();
|
|
|
|
packetHandler.addPacketHandler(this, PacketPlayOutSetSlot.class, PacketPlayOutWindowItems.class);
|
|
|
|
plugin.getServer().getScheduler().runTaskTimer(plugin, this, 1l, 1l);
|
|
}
|
|
|
|
@Override
|
|
public void addCommands()
|
|
{
|
|
addCommand(new GearCommand(this));
|
|
}
|
|
|
|
public void addCreativePlayer(Player player)
|
|
{
|
|
_creativePlayers.add(player.getName());
|
|
player.updateInventory();
|
|
}
|
|
|
|
public void removeCreativePlayer(Player player)
|
|
{
|
|
_creativePlayers.remove(player.getName());
|
|
player.updateInventory();
|
|
}
|
|
|
|
/**
|
|
* Tick & update internal logic for {@link GearManager}. Called once per
|
|
* tick.
|
|
*/
|
|
@Override
|
|
public void run()
|
|
{
|
|
Iterator<PlayerGear> iterator = _playerGears.values().iterator();
|
|
while (iterator.hasNext())
|
|
{
|
|
PlayerGear gear = iterator.next();
|
|
if (gear.isOnline())
|
|
{
|
|
gear.update();
|
|
}
|
|
else
|
|
{
|
|
iterator.remove();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param player - the player whose {@link PlayerGear} set is to be fetched.
|
|
* @return the cached or newly instantiated {@link PlayerGear} associated
|
|
* with {@code player}.
|
|
*/
|
|
public PlayerGear getPlayerGear(Player player)
|
|
{
|
|
String playerName = player.getName();
|
|
if (!_playerGears.containsKey(playerName))
|
|
{
|
|
PlayerGear gear = new PlayerGear(playerName);
|
|
_playerGears.put(playerName, gear);
|
|
}
|
|
|
|
return _playerGears.get(playerName);
|
|
}
|
|
|
|
public CustomItem generateItem()
|
|
{
|
|
int attributeCount = _attributeWeights.generateRandom();
|
|
ItemType itemType = _typeWeights.generateRandom();
|
|
|
|
RareItemFactory factory = RareItemFactory.begin(itemType);
|
|
|
|
if (itemType == ItemType.LEGENDARY)
|
|
{
|
|
factory.setLegendary(_legendaryWeights.generateRandom());
|
|
}
|
|
else if (itemType == ItemType.ARMOR)
|
|
{
|
|
factory.setType(_armorTypes.generateRandom());
|
|
}
|
|
else if (itemType == ItemType.WEAPON)
|
|
{
|
|
factory.setType(_weaponTypes.generateRandom());
|
|
}
|
|
else if (itemType == ItemType.BOW)
|
|
{
|
|
factory.setType(Material.BOW);
|
|
}
|
|
|
|
if (itemType != ItemType.LEGENDARY) // Only non-legendaries have
|
|
// attributes
|
|
{
|
|
AttributeContainer attributes = new AttributeContainer();
|
|
generateAttributes(attributes, itemType, attributeCount);
|
|
|
|
if (attributes.getSuperPrefix() != null)
|
|
{
|
|
factory.setSuperPrefix(attributes.getSuperPrefix().getClass());
|
|
}
|
|
if (attributes.getPrefix() != null)
|
|
{
|
|
factory.setPrefix(attributes.getPrefix().getClass());
|
|
}
|
|
if (attributes.getSuffix() != null)
|
|
{
|
|
factory.setSuffix(attributes.getSuffix().getClass());
|
|
}
|
|
}
|
|
|
|
return factory.getWrapper();
|
|
}
|
|
|
|
private void generateAttributes(AttributeContainer container, ItemType type, int count)
|
|
{
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
int attempts = 0;
|
|
Set<AttributeType> remaining = container.getRemainingTypes();
|
|
ItemAttribute attribute = null;
|
|
|
|
while (remaining.size() > 0 && attempts < 10 && attribute == null)
|
|
{
|
|
ItemAttribute sampleAttribute = null;
|
|
|
|
switch (type)
|
|
{
|
|
case ARMOR:
|
|
sampleAttribute = instantiate(_armorAttributes.generateRandom());
|
|
break;
|
|
case WEAPON:
|
|
sampleAttribute = instantiate(_weaponAttributes.generateRandom());
|
|
break;
|
|
case BOW:
|
|
sampleAttribute = instantiate(_bowAttributes.generateRandom());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (sampleAttribute != null && remaining.contains(sampleAttribute.getType()))
|
|
{
|
|
attribute = sampleAttribute; // Select valid attribute to
|
|
// add
|
|
}
|
|
}
|
|
|
|
container.addAttribute(attribute);
|
|
}
|
|
}
|
|
|
|
public void spawnItem(Location location)
|
|
{
|
|
CustomItem item = generateItem();
|
|
location.getWorld().dropItem(location, item.toItemStack());
|
|
}
|
|
|
|
public static CustomItem parseItem(ItemStack item)
|
|
{
|
|
String serialization = getItemSerialization(item);
|
|
|
|
if (serialization != null)
|
|
{
|
|
CustomItem customItem = null;
|
|
|
|
try
|
|
{
|
|
customItem = deserialize(serialization);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
System.out.println("==========");
|
|
System.out.println("GearManager parse problem :");
|
|
System.out.println(serialization);
|
|
System.out.println("==========");
|
|
}
|
|
|
|
return customItem;
|
|
}
|
|
|
|
return null; // No serialization found in item's lore, not a custom
|
|
// item!
|
|
}
|
|
|
|
public static boolean isCustomItem(ItemStack item)
|
|
{
|
|
return getItemSerialization(item) != null;
|
|
}
|
|
|
|
public static String getItemSerialization(CustomItem customItem)
|
|
{
|
|
String serialization = serialize(customItem);
|
|
|
|
return ITEM_SERIALIZATION_TAG + serialization;
|
|
}
|
|
|
|
/**
|
|
* @param type - the class-type of the object to be instantiated. (must have
|
|
* zero-argument constructor)
|
|
* @return a newly instantiated instance of {@code type} class-type.
|
|
* Instantied with zero argument constructor.
|
|
*/
|
|
private static <T> T instantiate(Class<T> type)
|
|
{
|
|
try
|
|
{
|
|
return type.newInstance();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static String getItemSerialization(ItemStack item)
|
|
{
|
|
if (item == null || item.getItemMeta() == null || item.getItemMeta().getLore() == null) return null;
|
|
|
|
ItemMeta meta = item.getItemMeta();
|
|
|
|
for (String lore : meta.getLore())
|
|
{
|
|
if (lore.startsWith(ITEM_SERIALIZATION_TAG)) // Found serialization
|
|
// lore-line
|
|
{
|
|
int tagLength = ITEM_SERIALIZATION_TAG.length();
|
|
String serialization = lore.substring(tagLength);
|
|
|
|
return serialization;
|
|
}
|
|
}
|
|
|
|
return null; // Unable to find any serialized lore lines, hence not a
|
|
// CustomItem.
|
|
}
|
|
|
|
public static String serialize(CustomItem customItem)
|
|
{
|
|
return _gson.toJson(customItem, CustomItem.class);
|
|
}
|
|
|
|
public static String serialize(AttributeContainer attributes)
|
|
{
|
|
return _gson.toJson(attributes, AttributeContainer.class);
|
|
}
|
|
|
|
public static CustomItem deserialize(String serialization)
|
|
{
|
|
return _gson.fromJson(serialization, CustomItem.class);
|
|
}
|
|
|
|
public static <T> T deserialize(String serialization, Class<T> type)
|
|
{
|
|
return _gson.fromJson(serialization, type);
|
|
}
|
|
|
|
/**
|
|
* @return singleton instance of {@link GearManager}.
|
|
*/
|
|
public static GearManager getInstance()
|
|
{
|
|
return _instance;
|
|
}
|
|
|
|
public static void notify(Player player, String message)
|
|
{
|
|
UtilPlayer.message(player, F.main("Gear", message));
|
|
}
|
|
|
|
/**
|
|
* @param player - the player to see if they should have their out-going
|
|
* packets masked on CustomGear items.
|
|
* @return true, if the player should have their gear lore masked, false
|
|
* otherwise.
|
|
*/
|
|
private boolean maskGearPacket(Player player)
|
|
{
|
|
return player.getGameMode() != GameMode.CREATIVE && !_creativePlayers.contains(player.getName());
|
|
}
|
|
|
|
public void handle(PacketInfo packetInfo)
|
|
{
|
|
System.out.println("handling packet...");
|
|
|
|
// Don't mask custom gear lore for creative players, as this will break
|
|
// them.
|
|
if (!maskGearPacket(packetInfo.getPlayer())) return;
|
|
|
|
Packet<?> packet = packetInfo.getPacket();
|
|
|
|
System.out.println("<-GearManager-> Packet >> " + packetInfo.getPlayer().getName());
|
|
|
|
if (packet instanceof PacketPlayOutSetSlot)
|
|
{
|
|
PacketPlayOutSetSlot slotPacket = (PacketPlayOutSetSlot) packet;
|
|
slotPacket.c = maskItem(slotPacket.c); // Mask all out-going item
|
|
// packets
|
|
}
|
|
else if (packet instanceof PacketPlayOutWindowItems)
|
|
{
|
|
PacketPlayOutWindowItems itemsPacket = (PacketPlayOutWindowItems) packet;
|
|
|
|
for (int i = 0; i < itemsPacket.b.length; i++)
|
|
{
|
|
itemsPacket.b[i] = maskItem(itemsPacket.b[i]); // Mask all
|
|
// out-going
|
|
// item packets
|
|
}
|
|
}
|
|
}
|
|
|
|
private net.minecraft.server.v1_8_R3.ItemStack maskItem(net.minecraft.server.v1_8_R3.ItemStack item)
|
|
{
|
|
System.out.println("<-GearManager-> attempting item mask...");
|
|
// Cannot mask a null item
|
|
if (item == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
CraftItemStack originalItem = CraftItemStack.asCraftMirror(item);
|
|
ItemMeta originalMeta = originalItem.getItemMeta();
|
|
|
|
// No need to modify item packets with no lore
|
|
if (originalMeta == null || originalMeta.getLore() == null)
|
|
{
|
|
return item;
|
|
}
|
|
|
|
List<String> lore = new ArrayList<String>();
|
|
|
|
for (String line : originalMeta.getLore())
|
|
{
|
|
if (!line.startsWith(ITEM_SERIALIZATION_TAG)) // Remove
|
|
// serialization
|
|
// lines from
|
|
// out-going lore
|
|
{
|
|
lore.add(line);
|
|
}else{
|
|
}
|
|
}
|
|
|
|
net.minecraft.server.v1_8_R3.ItemStack newItem = CraftItemStack.asNMSCopy(originalItem);
|
|
CraftItemStack newCopy = CraftItemStack.asCraftMirror(newItem);
|
|
ItemMeta newMeta = newCopy.getItemMeta();
|
|
newMeta.setLore(lore);
|
|
newCopy.setItemMeta(newMeta);
|
|
return newItem;
|
|
}
|
|
|
|
public void openShop(Player player)
|
|
{
|
|
_shop.attemptShopOpen(player);
|
|
}
|
|
}
|