mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-18 23:09:05 +00:00
685 lines
27 KiB
Java
685 lines
27 KiB
Java
package noppes.npcs.quests;
|
|
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import noppes.npcs.NoppesUtilPlayer;
|
|
import noppes.npcs.NoppesUtilServer;
|
|
import noppes.npcs.NpcMiscInventory;
|
|
import noppes.npcs.api.handler.data.IQuestItem;
|
|
import noppes.npcs.api.handler.data.IQuestObjective;
|
|
import noppes.npcs.constants.EnumPartyObjectives;
|
|
import noppes.npcs.controllers.data.Party;
|
|
import noppes.npcs.controllers.data.PlayerData;
|
|
import noppes.npcs.scripted.CustomNPCsException;
|
|
import noppes.npcs.util.ValueUtil;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
import java.util.Vector;
|
|
|
|
public class QuestItem extends QuestInterface implements IQuestItem {
|
|
public NpcMiscInventory items = new NpcMiscInventory(3);
|
|
public static EntityPlayer pickedUpPlayerSolo;
|
|
public static ItemStack pickedUp;
|
|
|
|
public static ItemStack pickedUpParty;
|
|
public static EntityPlayer pickedUpPlayer;
|
|
|
|
public boolean leaveItems = false;
|
|
public boolean ignoreDamage = false;
|
|
public boolean ignoreNBT = false;
|
|
|
|
@Override
|
|
public void readEntityFromNBT(NBTTagCompound compound) {
|
|
items.setFromNBT(compound.getCompoundTag("Items"));
|
|
leaveItems = compound.getBoolean("LeaveItems");
|
|
ignoreDamage = compound.getBoolean("IgnoreDamage");
|
|
ignoreNBT = compound.getBoolean("IgnoreNBT");
|
|
}
|
|
|
|
@Override
|
|
public void writeEntityToNBT(NBTTagCompound compound) {
|
|
compound.setTag("Items", items.getToNBT());
|
|
compound.setBoolean("LeaveItems", leaveItems);
|
|
compound.setBoolean("IgnoreDamage", ignoreDamage);
|
|
compound.setBoolean("IgnoreNBT", ignoreNBT);
|
|
}
|
|
|
|
@Override
|
|
public boolean isCompleted(PlayerData playerData) {
|
|
if (playerData == null || playerData.player == null)
|
|
return false;
|
|
|
|
List<ItemStack> requiredStacks = NoppesUtilPlayer.countStacks(this.items, this.ignoreDamage, this.ignoreNBT);
|
|
List<ItemStack> availableStacks = aggregateAvailableStacks(collectAvailableStacks(playerData.player, pickedUp));
|
|
|
|
for (ItemStack required : requiredStacks) {
|
|
boolean done = false;
|
|
for (ItemStack available : availableStacks) {
|
|
if (NoppesUtilPlayer.compareItems(required, available, ignoreDamage, ignoreNBT) && available.stackSize >= required.stackSize) {
|
|
done = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!done)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public HashMap<Integer, ItemStack> getProcessSet(EntityPlayer player) {
|
|
return buildProgressMap(collectAvailableStacks(player, pickedUp));
|
|
}
|
|
|
|
@Override
|
|
public void handleComplete(EntityPlayer player) {
|
|
super.handleComplete(player);
|
|
if (leaveItems)
|
|
return;
|
|
removeItems(player);
|
|
}
|
|
|
|
public void handlePartyComplete(EntityPlayer player, Party party, boolean isLeader, EnumPartyObjectives objectives) {
|
|
super.handlePartyComplete(player, party, isLeader, objectives);
|
|
if (leaveItems)
|
|
return;
|
|
|
|
if (isLeader && objectives == EnumPartyObjectives.Leader) {
|
|
removeItems(player);
|
|
} else if (objectives == EnumPartyObjectives.All) {
|
|
removeItems(player);
|
|
} else if (objectives == EnumPartyObjectives.Shared) {
|
|
// Shared Case
|
|
// Do nothing, handled later in quest completion
|
|
}
|
|
}
|
|
|
|
public void removePartyItems(Party party) {
|
|
// Iterate through each quest item in the list
|
|
for (ItemStack questItem : items.items.values()) {
|
|
int remainingItems = questItem.stackSize;
|
|
|
|
// Iterate through all members of the party
|
|
for (UUID uuid : party.getPlayerUUIDs()) {
|
|
EntityPlayer player = NoppesUtilServer.getPlayer(uuid);
|
|
if (player != null) {
|
|
int removedItems = removeItemFromPlayer(player, questItem, remainingItems);
|
|
remainingItems -= removedItems;
|
|
|
|
// If no remaining items are needed for this quest item, move to the next one
|
|
if (remainingItems <= 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private int removeItemFromPlayer(EntityPlayer player, ItemStack questItem, int numItemsToRemove) {
|
|
int itemsRemoved = 0;
|
|
|
|
// Iterate through the player's inventory
|
|
for (int i = 0; i < player.inventory.mainInventory.length && itemsRemoved < numItemsToRemove; i++) {
|
|
ItemStack itemStack = player.inventory.mainInventory[i];
|
|
if (itemStack == null)
|
|
continue;
|
|
if (NoppesUtilPlayer.compareItems(itemStack, questItem, ignoreDamage, ignoreNBT)) {
|
|
int itemsToRemoveFromStack = Math.min(itemStack.stackSize, numItemsToRemove - itemsRemoved);
|
|
int size = itemStack.stackSize;
|
|
if (itemsToRemoveFromStack >= size) {
|
|
player.inventory.setInventorySlotContents(i, null);
|
|
itemStack.splitStack(size);
|
|
} else {
|
|
itemStack.splitStack(itemsToRemoveFromStack);
|
|
}
|
|
|
|
itemsRemoved += size;
|
|
|
|
// If there are no more remaining items to remove, break out of the loop
|
|
if (itemsRemoved >= numItemsToRemove) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return itemsRemoved;
|
|
}
|
|
|
|
|
|
public void removeItems(EntityPlayer player) {
|
|
for (ItemStack questitem : items.items.values()) {
|
|
int stacksize = questitem.stackSize;
|
|
for (int i = 0; i < player.inventory.mainInventory.length; i++) {
|
|
ItemStack item = player.inventory.mainInventory[i];
|
|
if (item == null)
|
|
continue;
|
|
if (NoppesUtilPlayer.compareItems(item, questitem, ignoreDamage, ignoreNBT)) {
|
|
int size = item.stackSize;
|
|
if (stacksize - size >= 0) {
|
|
player.inventory.setInventorySlotContents(i, null);
|
|
item.splitStack(size);
|
|
} else {
|
|
item.splitStack(stacksize);
|
|
}
|
|
stacksize -= size;
|
|
if (stacksize <= 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Vector<String> getQuestLogStatus(EntityPlayer player) {
|
|
Vector<String> vec = new Vector<String>();
|
|
|
|
HashMap<Integer, ItemStack> map = getProcessSet(player);
|
|
for (int slot : map.keySet()) {
|
|
ItemStack item = map.get(slot);
|
|
ItemStack quest = items.items.get(slot);
|
|
if (item == null)
|
|
continue;
|
|
String process = item.stackSize + "";
|
|
if (item.stackSize > quest.stackSize)
|
|
process = quest.stackSize + "";
|
|
process += "/" + quest.stackSize + "";
|
|
if (item.hasDisplayName())
|
|
vec.add(item.getDisplayName() + ": " + process);
|
|
else
|
|
vec.add(item.getUnlocalizedName() + ".name" + ": " + process);
|
|
}
|
|
return vec;
|
|
}
|
|
|
|
public IQuestObjective[] getObjectives(EntityPlayer player) {
|
|
List<IQuestObjective> list = new ArrayList<>();
|
|
List<ItemStack> questItems = NoppesUtilPlayer.countStacks(this.items, this.ignoreDamage, this.ignoreNBT);
|
|
|
|
for (ItemStack stack : questItems) {
|
|
if (stack.stackSize > 0) {
|
|
list.add(new QuestItemObjective(this, player, stack));
|
|
}
|
|
}
|
|
|
|
return list.toArray(new IQuestObjective[0]);
|
|
}
|
|
|
|
@Override
|
|
public IQuestObjective[] getPartyObjectives(Party party) {
|
|
List<IQuestObjective> list = new ArrayList<>();
|
|
List<ItemStack> questItems = NoppesUtilPlayer.countStacks(this.items, this.ignoreDamage, this.ignoreNBT);
|
|
|
|
for (ItemStack stack : questItems) {
|
|
if (stack.stackSize > 0) {
|
|
list.add(new QuestItemObjective(this, party, stack));
|
|
}
|
|
}
|
|
|
|
return list.toArray(new IQuestObjective[0]);
|
|
}
|
|
|
|
@Override
|
|
public Vector<String> getPartyQuestLogStatus(Party party) {
|
|
Vector<String> vec = new Vector<String>();
|
|
if (party == null || party.getObjectiveRequirement() == null)
|
|
return vec;
|
|
|
|
EnumPartyObjectives objectives = party.getObjectiveRequirement();
|
|
if (objectives == EnumPartyObjectives.All) {
|
|
// Slot, QuestItem Vector
|
|
HashMap<Integer, String> questVector = new HashMap<>();
|
|
HashMap<Integer, List<String>> playerVector = new HashMap<>();
|
|
for (int slot : items.items.keySet()) {
|
|
ItemStack questItem = items.items.get(slot);
|
|
if (questItem != null) {
|
|
if (questItem.hasDisplayName())
|
|
questVector.put(slot, questItem.getDisplayName() + ": " + questItem.stackSize);
|
|
else
|
|
questVector.put(slot, questItem.getUnlocalizedName() + ".name" + ": " + questItem.stackSize);
|
|
|
|
playerVector.put(slot, new ArrayList<>());
|
|
}
|
|
}
|
|
|
|
// Slot, List of Players and Their Item Counts
|
|
|
|
for (UUID uuid : party.getPlayerUUIDs()) {
|
|
EntityPlayer player = NoppesUtilServer.getPlayer(uuid);
|
|
if (player != null) {
|
|
HashMap<Integer, ItemStack> perPlayerMap = getProcessSetParty(player);
|
|
for (int slot : perPlayerMap.keySet()) {
|
|
List<String> slotCurrent = playerVector.get(slot);
|
|
ItemStack item = perPlayerMap.get(slot);
|
|
ItemStack quest = items.items.get(slot);
|
|
if (item == null)
|
|
continue;
|
|
if (quest == null)
|
|
continue;
|
|
if (item.stackSize > quest.stackSize)
|
|
continue;
|
|
slotCurrent.add(player.getCommandSenderName() + ": " + item.stackSize);
|
|
playerVector.put(slot, slotCurrent);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add entries to the vec vector
|
|
for (int slot : questVector.keySet()) {
|
|
String questEntry = questVector.get(slot);
|
|
vec.add(questEntry);
|
|
List<String> playerItems = playerVector.get(slot);
|
|
if (playerItems != null && !playerItems.isEmpty()) {
|
|
StringBuilder playerNamesBuilder = new StringBuilder();
|
|
for (String playerName : playerItems) {
|
|
if (playerNamesBuilder.length() > 0) {
|
|
playerNamesBuilder.append(", ");
|
|
}
|
|
playerNamesBuilder.append(playerName);
|
|
}
|
|
vec.add("[" + playerNamesBuilder.toString() + "]");
|
|
}
|
|
}
|
|
} else if (objectives == EnumPartyObjectives.Shared || objectives == EnumPartyObjectives.Leader) {
|
|
HashMap<Integer, Integer> totals = new HashMap<Integer, Integer>();
|
|
for (int slot : items.items.keySet()) {
|
|
ItemStack item = items.items.get(slot);
|
|
if (item != null) {
|
|
totals.put(slot, 0);
|
|
}
|
|
}
|
|
// Iterate over each player in the party
|
|
for (UUID uuid : party.getPlayerUUIDs()) {
|
|
if (uuid == null)
|
|
continue;
|
|
|
|
if (objectives == EnumPartyObjectives.Leader && !party.getLeaderUUID().equals(uuid))
|
|
continue;
|
|
|
|
EntityPlayer player = NoppesUtilServer.getPlayer(uuid);
|
|
if (player != null) {
|
|
HashMap<Integer, ItemStack> perPlayerMap = getProcessSetParty(player);
|
|
for (Map.Entry<Integer, ItemStack> entry : items.items.entrySet()) {
|
|
int slot = entry.getKey();
|
|
ItemStack reqItem = entry.getValue();
|
|
if (reqItem == null)
|
|
continue;
|
|
ItemStack item = perPlayerMap.get(slot);
|
|
if (item != null && NoppesUtilPlayer.compareItems(reqItem, item, ignoreDamage, ignoreNBT)) {
|
|
int count = totals.get(slot);
|
|
count += item.stackSize;
|
|
totals.put(slot, count);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if the total count of required items collected by the party exceeds the required amount for each slot
|
|
for (int slot : items.items.keySet()) {
|
|
ItemStack reqItem = items.items.get(slot);
|
|
if (reqItem == null)
|
|
continue;
|
|
|
|
int totalCount = totals.get(slot);
|
|
if (totalCount > reqItem.stackSize) {
|
|
totalCount = reqItem.stackSize;
|
|
}
|
|
String process = totalCount + "/" + reqItem.stackSize;
|
|
if (reqItem.hasDisplayName())
|
|
vec.add(reqItem.getDisplayName() + ": " + process);
|
|
else
|
|
vec.add(reqItem.getUnlocalizedName() + ".name" + ": " + process);
|
|
}
|
|
}
|
|
return vec;
|
|
}
|
|
|
|
@Override
|
|
public boolean isPartyCompleted(Party party) {
|
|
if (party == null || party.getObjectiveRequirement() == null)
|
|
return false;
|
|
|
|
EnumPartyObjectives objectives = party.getObjectiveRequirement();
|
|
if (objectives == EnumPartyObjectives.All) {
|
|
for (UUID uuid : party.getPlayerUUIDs()) {
|
|
EntityPlayer player = NoppesUtilServer.getPlayer(uuid);
|
|
if (player != null) {
|
|
HashMap<Integer, ItemStack> perPlayerMap = getProcessSetParty(player);
|
|
for (ItemStack reqItem : items.items.values()) {
|
|
boolean done = false;
|
|
for (ItemStack item : perPlayerMap.values()) {
|
|
if (NoppesUtilPlayer.compareItems(reqItem, item, ignoreDamage, ignoreNBT) && item.stackSize >= reqItem.stackSize) {
|
|
done = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!done)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
} else if (objectives == EnumPartyObjectives.Shared || objectives == EnumPartyObjectives.Leader) {
|
|
HashMap<Integer, Integer> totals = new HashMap<Integer, Integer>();
|
|
for (int slot : items.items.keySet()) {
|
|
ItemStack item = items.items.get(slot);
|
|
if (item != null) {
|
|
totals.put(slot, 0);
|
|
}
|
|
}
|
|
|
|
// Iterate over each player in the party
|
|
for (UUID uuid : party.getPlayerUUIDs()) {
|
|
if (uuid == null)
|
|
continue;
|
|
|
|
if (objectives == EnumPartyObjectives.Leader && !party.getLeaderUUID().equals(uuid))
|
|
continue;
|
|
|
|
EntityPlayer player = NoppesUtilServer.getPlayer(uuid);
|
|
if (player != null) {
|
|
HashMap<Integer, ItemStack> perPlayerMap = getProcessSetParty(player);
|
|
for (Map.Entry<Integer, ItemStack> entry : items.items.entrySet()) {
|
|
int slot = entry.getKey();
|
|
ItemStack reqItem = entry.getValue();
|
|
if (reqItem == null)
|
|
continue;
|
|
ItemStack item = perPlayerMap.get(slot);
|
|
if (item != null && NoppesUtilPlayer.compareItems(reqItem, item, ignoreDamage, ignoreNBT)) {
|
|
int count = totals.get(slot);
|
|
count += item.stackSize;
|
|
totals.put(slot, count);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if the total count of required items collected by the party exceeds the required amount for each slot
|
|
for (int slot : items.items.keySet()) {
|
|
ItemStack reqItem = items.items.get(slot);
|
|
int totalCount = totals.get(slot);
|
|
if (totalCount < reqItem.stackSize) {
|
|
return false; // Party has not completed the objective
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public HashMap<Integer, ItemStack> getProcessSetParty(EntityPlayer player) {
|
|
ItemStack extra = null;
|
|
if (pickedUpPlayer != null && player != null && player.getCommandSenderName().equals(pickedUpPlayer.getCommandSenderName()))
|
|
extra = pickedUpParty;
|
|
return buildProgressMap(collectAvailableStacks(player, extra));
|
|
}
|
|
|
|
private List<ItemStack> collectAvailableStacks(EntityPlayer player, ItemStack extra) {
|
|
List<ItemStack> available = new ArrayList<>();
|
|
if (player == null)
|
|
return available;
|
|
|
|
for (ItemStack stack : player.inventory.mainInventory) {
|
|
if (stack != null && stack.stackSize > 0) {
|
|
available.add(stack.copy());
|
|
}
|
|
}
|
|
|
|
if (extra != null && extra.stackSize > 0) {
|
|
available.add(extra.copy());
|
|
}
|
|
|
|
return available;
|
|
}
|
|
|
|
private HashMap<Integer, ItemStack> buildProgressMap(List<ItemStack> available) {
|
|
HashMap<Integer, ItemStack> map = new HashMap<Integer, ItemStack>();
|
|
List<Integer> slots = new ArrayList<>(items.items.keySet());
|
|
Collections.sort(slots);
|
|
|
|
for (int slot : slots) {
|
|
ItemStack requirement = items.items.get(slot);
|
|
if (requirement == null)
|
|
continue;
|
|
|
|
ItemStack progress = requirement.copy();
|
|
progress.stackSize = 0;
|
|
int remaining = requirement.stackSize;
|
|
|
|
for (ItemStack stack : available) {
|
|
if (stack == null || stack.stackSize <= 0)
|
|
continue;
|
|
|
|
if (NoppesUtilPlayer.compareItems(requirement, stack, ignoreDamage, ignoreNBT)) {
|
|
int used = Math.min(stack.stackSize, remaining);
|
|
if (used > 0) {
|
|
progress.stackSize += used;
|
|
stack.stackSize -= used;
|
|
remaining -= used;
|
|
}
|
|
|
|
if (remaining <= 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
map.put(slot, progress);
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
private List<ItemStack> aggregateAvailableStacks(List<ItemStack> available) {
|
|
List<ItemStack> aggregated = new ArrayList<>();
|
|
for (ItemStack stack : available) {
|
|
if (stack == null || stack.stackSize <= 0)
|
|
continue;
|
|
|
|
boolean found = false;
|
|
for (ItemStack existing : aggregated) {
|
|
if (NoppesUtilPlayer.compareItems(existing, stack, ignoreDamage, ignoreNBT)) {
|
|
existing.stackSize += stack.stackSize;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
aggregated.add(stack.copy());
|
|
}
|
|
}
|
|
return aggregated;
|
|
}
|
|
|
|
public void setLeaveItems(boolean leaveItems) {
|
|
this.leaveItems = leaveItems;
|
|
}
|
|
|
|
public boolean getLeaveItems() {
|
|
return this.leaveItems;
|
|
}
|
|
|
|
public void setIgnoreDamage(boolean ignoreDamage) {
|
|
this.ignoreDamage = ignoreDamage;
|
|
}
|
|
|
|
public boolean getIgnoreDamage() {
|
|
return this.ignoreDamage;
|
|
}
|
|
|
|
public void setIgnoreNbt(boolean ignoreNbt) {
|
|
this.ignoreNBT = ignoreNbt;
|
|
}
|
|
|
|
public boolean getIgnoreNbt() {
|
|
return this.ignoreNBT;
|
|
}
|
|
|
|
class QuestItemObjective implements IQuestObjective {
|
|
private final QuestItem parent;
|
|
private final EntityPlayer player;
|
|
private final Party party;
|
|
private final ItemStack questItem;
|
|
|
|
public QuestItemObjective(QuestItem this$0, EntityPlayer player, ItemStack item) {
|
|
this.parent = this$0;
|
|
this.player = player;
|
|
this.questItem = item;
|
|
this.party = null;
|
|
}
|
|
|
|
public QuestItemObjective(QuestItem this$0, Party party, ItemStack item) {
|
|
this.parent = this$0;
|
|
this.player = null;
|
|
this.questItem = item;
|
|
this.party = party;
|
|
}
|
|
|
|
public int getProgress() {
|
|
int count = 0;
|
|
if (player != null) {
|
|
ItemStack item = QuestItem.pickedUp;
|
|
if (!NoppesUtilServer.IsItemStackNull(item) && NoppesUtilPlayer.compareItems(this.questItem, item, this.parent.ignoreDamage, this.parent.ignoreNBT)) {
|
|
count += item.stackSize;
|
|
}
|
|
|
|
for (int i = 0; i < this.player.inventory.getSizeInventory(); ++i) {
|
|
item = this.player.inventory.getStackInSlot(i);
|
|
if (!NoppesUtilServer.IsItemStackNull(item) && NoppesUtilPlayer.compareItems(this.questItem, item, this.parent.ignoreDamage, this.parent.ignoreNBT)) {
|
|
count += item.stackSize;
|
|
}
|
|
}
|
|
} else if (party != null && party.getObjectiveRequirement() != null) {
|
|
ItemStack item;
|
|
EnumPartyObjectives objectives = party.getObjectiveRequirement();
|
|
for (String name : party.getPlayerNames()) {
|
|
EntityPlayer playerMP = NoppesUtilServer.getPlayerByName(name);
|
|
if (playerMP == null)
|
|
continue;
|
|
|
|
if (!playerMP.getUniqueID().equals(party.getLeaderUUID()) && objectives == EnumPartyObjectives.Leader)
|
|
continue;
|
|
|
|
int amount = 0;
|
|
for (int i = 0; i < playerMP.inventory.getSizeInventory(); ++i) {
|
|
item = playerMP.inventory.getStackInSlot(i);
|
|
if (!NoppesUtilServer.IsItemStackNull(item) && NoppesUtilPlayer.compareItems(this.questItem, item, this.parent.ignoreDamage, this.parent.ignoreNBT)) {
|
|
amount += item.stackSize;
|
|
}
|
|
}
|
|
|
|
if (objectives == EnumPartyObjectives.All) {
|
|
count += ValueUtil.clamp(amount, 0, this.questItem.stackSize);
|
|
} else {
|
|
count += amount;
|
|
}
|
|
}
|
|
|
|
if (objectives == EnumPartyObjectives.All) {
|
|
return ValueUtil.clamp(count, 0, this.questItem.stackSize * party.getPlayerNames().size());
|
|
}
|
|
}
|
|
|
|
return ValueUtil.clamp(count, 0, this.questItem.stackSize);
|
|
}
|
|
|
|
public void setProgress(int progress) {
|
|
throw new CustomNPCsException("Cant set the progress of ItemQuests", new Object[0]);
|
|
}
|
|
|
|
@Override
|
|
public void setPlayerProgress(String playerName, int progress) {
|
|
throw new CustomNPCsException("Cant set the progress of ItemQuests", new Object[0]);
|
|
}
|
|
|
|
public int getMaxProgress() {
|
|
if (party != null && party.getObjectiveRequirement() != null) {
|
|
EnumPartyObjectives objectives = party.getObjectiveRequirement();
|
|
if (objectives == EnumPartyObjectives.All) {
|
|
return this.questItem.stackSize * party.getPlayerNames().size();
|
|
}
|
|
}
|
|
|
|
return this.questItem.stackSize;
|
|
}
|
|
|
|
public boolean isCompleted() {
|
|
if (player != null)
|
|
return NoppesUtilPlayer.compareItems(this.player, this.questItem, this.parent.ignoreDamage, this.parent.ignoreNBT);
|
|
else if (party != null)
|
|
return comparePartyItems(this.party, this.questItem, this.parent.ignoreDamage, this.parent.ignoreNBT);
|
|
|
|
return false;
|
|
}
|
|
|
|
public boolean comparePartyItems(Party party, ItemStack item, boolean ignoreDamage, boolean ignoreNBT) {
|
|
int size = 0;
|
|
if (party.getObjectiveRequirement() == null)
|
|
return false;
|
|
|
|
EnumPartyObjectives objectives = party.getObjectiveRequirement();
|
|
for (String name : party.getPlayerNames()) {
|
|
EntityPlayer playerMP = NoppesUtilServer.getPlayerByName(name);
|
|
if (playerMP == null)
|
|
continue;
|
|
|
|
if (objectives == EnumPartyObjectives.Leader && !playerMP.getUniqueID().equals(party.getLeaderUUID()))
|
|
continue;
|
|
|
|
int amount = 0;
|
|
for (ItemStack is : playerMP.inventory.mainInventory) {
|
|
if (NoppesUtilPlayer.compareItems(item, is, ignoreDamage, ignoreNBT))
|
|
amount += is.stackSize;
|
|
}
|
|
|
|
if (objectives == EnumPartyObjectives.All) {
|
|
size += ValueUtil.clamp(amount, 0, this.questItem.stackSize);
|
|
} else {
|
|
size += amount;
|
|
}
|
|
}
|
|
|
|
if (objectives == EnumPartyObjectives.All) {
|
|
return size >= item.stackSize * party.getPlayerNames().size();
|
|
}
|
|
|
|
return size >= item.stackSize;
|
|
}
|
|
|
|
public String getText() {
|
|
return this.questItem.getDisplayName() + ": " + this.getProgress() + "/" + this.getMaxProgress();
|
|
}
|
|
|
|
@Override
|
|
public String getAdditionalText() {
|
|
if (party != null && party.getObjectiveRequirement() == EnumPartyObjectives.All) {
|
|
List<String> incompletePlayers = new ArrayList<>();
|
|
EnumPartyObjectives objectives = party.getObjectiveRequirement();
|
|
for (String name : party.getPlayerNames()) {
|
|
EntityPlayer playerMP = NoppesUtilServer.getPlayerByName(name);
|
|
if (playerMP == null) {
|
|
incompletePlayers.add(name + ": " + "N/A");
|
|
continue;
|
|
}
|
|
|
|
int amount = 0;
|
|
for (ItemStack is : playerMP.inventory.mainInventory) {
|
|
if (NoppesUtilPlayer.compareItems(this.questItem, is, ignoreDamage, ignoreNBT))
|
|
amount += is.stackSize;
|
|
}
|
|
|
|
int completedSize = ValueUtil.clamp(amount, 0, this.questItem.stackSize);
|
|
if (completedSize < this.questItem.stackSize)
|
|
incompletePlayers.add(name + ": " + completedSize);
|
|
}
|
|
if (!incompletePlayers.isEmpty())
|
|
return "[" + String.join(", ", incompletePlayers) + "]";
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|