mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-12 20:07:32 +00:00
Claude
57f9b706bf
- Add auction permission nodes (use, list, bid, buyout, admin) - Create AuctionActionPacket for client-server communication - Supports: CreateListing, PlaceBid, Buyout, CancelListing, ClaimItem, ClaimProceeds - Includes permission checks and validation - Register packet in PacketHandler - Add auction scripting API methods to ScriptPlayer: - getAuctionListingCount() - getMaxAuctionListings() - hasAuctionClaims() - getAuctionClaimCount() - getActiveAuctionBidCount()
1084 lines
34 KiB
Java
1084 lines
34 KiB
Java
package noppes.npcs.scripted.entity;
|
|
|
|
import kamkeel.npcs.controllers.AttributeController;
|
|
import kamkeel.npcs.network.PacketHandler;
|
|
import kamkeel.npcs.network.packets.data.AchievementPacket;
|
|
import kamkeel.npcs.network.packets.data.ChatAlertPacket;
|
|
import kamkeel.npcs.network.packets.data.gui.GuiClosePacket;
|
|
import kamkeel.npcs.network.packets.data.script.ScriptOverlayClosePacket;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.stats.Achievement;
|
|
import net.minecraft.stats.StatBase;
|
|
import net.minecraft.stats.StatList;
|
|
import net.minecraft.util.ChatComponentTranslation;
|
|
import net.minecraft.util.ChatStyle;
|
|
import net.minecraft.util.ChunkCoordinates;
|
|
import net.minecraft.util.EnumChatFormatting;
|
|
import net.minecraft.world.WorldSettings;
|
|
import noppes.npcs.CustomNpcsPermissions;
|
|
import noppes.npcs.NoppesStringUtils;
|
|
import noppes.npcs.NoppesUtilPlayer;
|
|
import noppes.npcs.NoppesUtilServer;
|
|
import noppes.npcs.api.IBlock;
|
|
import noppes.npcs.api.IContainer;
|
|
import noppes.npcs.api.IParticle;
|
|
import noppes.npcs.api.IPixelmonPlayerData;
|
|
import noppes.npcs.api.IPos;
|
|
import noppes.npcs.api.IScreenSize;
|
|
import noppes.npcs.api.ITimers;
|
|
import noppes.npcs.api.IWorld;
|
|
import noppes.npcs.api.entity.IEntity;
|
|
import noppes.npcs.api.entity.IPlayer;
|
|
import noppes.npcs.api.gui.ICustomGui;
|
|
import noppes.npcs.api.handler.IActionManager;
|
|
import noppes.npcs.api.handler.IOverlayHandler;
|
|
import noppes.npcs.api.handler.data.IAnimationData;
|
|
import noppes.npcs.api.handler.data.IDialog;
|
|
import noppes.npcs.api.handler.data.IMagicData;
|
|
import noppes.npcs.api.handler.data.IParty;
|
|
import noppes.npcs.api.handler.data.IPlayerAttributes;
|
|
import noppes.npcs.api.handler.data.IQuest;
|
|
import noppes.npcs.api.handler.data.ISound;
|
|
import noppes.npcs.api.item.IItemStack;
|
|
import noppes.npcs.api.overlay.ICustomOverlay;
|
|
import noppes.npcs.compat.PixelmonHelper;
|
|
import noppes.npcs.config.ConfigScript;
|
|
import noppes.npcs.constants.EnumQuestType;
|
|
import noppes.npcs.containers.ContainerCustomGui;
|
|
import noppes.npcs.controllers.AuctionController;
|
|
import noppes.npcs.controllers.CurrencyController;
|
|
import noppes.npcs.controllers.CustomGuiController;
|
|
import noppes.npcs.controllers.DialogController;
|
|
import noppes.npcs.controllers.PartyController;
|
|
import noppes.npcs.controllers.PlayerQuestController;
|
|
import noppes.npcs.controllers.QuestController;
|
|
import noppes.npcs.controllers.VaultHelper;
|
|
import noppes.npcs.controllers.data.Dialog;
|
|
import noppes.npcs.controllers.data.Party;
|
|
import noppes.npcs.controllers.data.PlayerData;
|
|
import noppes.npcs.controllers.data.PlayerDialogData;
|
|
import noppes.npcs.controllers.data.PlayerQuestData;
|
|
import noppes.npcs.controllers.data.Quest;
|
|
import noppes.npcs.controllers.data.QuestData;
|
|
import noppes.npcs.entity.EntityDialogNpc;
|
|
import noppes.npcs.scripted.CustomNPCsException;
|
|
import noppes.npcs.scripted.NpcAPI;
|
|
import noppes.npcs.scripted.ScriptPixelmonPlayerData;
|
|
import noppes.npcs.scripted.ScriptSound;
|
|
import noppes.npcs.scripted.constants.EntityType;
|
|
import noppes.npcs.scripted.gui.ScriptGui;
|
|
import noppes.npcs.scripted.overlay.ScriptOverlay;
|
|
import noppes.npcs.util.ValueUtil;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
|
|
public class ScriptPlayer<T extends EntityPlayerMP> extends ScriptLivingBase<T> implements IPlayer {
|
|
public T player;
|
|
private PlayerData data;
|
|
|
|
public ScriptPlayer(T player) {
|
|
super(player);
|
|
this.player = player;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the displayed name of the player
|
|
*/
|
|
public String getDisplayName() {
|
|
return player.getDisplayName();
|
|
}
|
|
|
|
/**
|
|
* @return Returns the players name
|
|
*/
|
|
public String getName() {
|
|
return player.getCommandSenderName();
|
|
}
|
|
|
|
public void kick(String reason) {
|
|
player.playerNetServerHandler.kickPlayerFromServer(reason);
|
|
}
|
|
|
|
@Override
|
|
public void spawnParticle(IParticle entityParticle) {
|
|
entityParticle.spawnOnEntity(this);
|
|
}
|
|
|
|
@Override
|
|
public void setPosition(double x, double y, double z) {
|
|
NoppesUtilPlayer.teleportPlayer(player, x, y, z, player.dimension);
|
|
}
|
|
|
|
public void setPos(double x, double y, double z) {
|
|
this.setPosition(x, y, z);
|
|
}
|
|
|
|
public void setPosition(IPos pos) {
|
|
this.setPosition(pos.getXD(), pos.getYD(), pos.getZD());
|
|
}
|
|
|
|
public void setPos(IPos pos) {
|
|
this.setPosition(pos);
|
|
}
|
|
|
|
public void setPosition(double x, double y, double z, int dimensionId) {
|
|
if (NpcAPI.Instance().getIWorld(dimensionId) == null)
|
|
return;
|
|
|
|
NoppesUtilPlayer.teleportPlayer(player, x, y, z, dimensionId);
|
|
}
|
|
|
|
public void setPos(double x, double y, double z, int dimensionId) {
|
|
this.setPosition(x, y, z, dimensionId);
|
|
}
|
|
|
|
public void setPosition(double x, double y, double z, IWorld world) {
|
|
this.setPosition(x, y, z, world.getDimensionID());
|
|
}
|
|
|
|
public void setPos(double x, double y, double z, IWorld world) {
|
|
this.setPos(x, y, z, world.getDimensionID());
|
|
}
|
|
|
|
public void setPosition(IPos pos, int dimensionId) {
|
|
this.setPosition(pos.getXD(), pos.getYD(), pos.getZD(), dimensionId);
|
|
}
|
|
|
|
public void setPos(IPos pos, int dimensionId) {
|
|
this.setPosition(pos, dimensionId);
|
|
}
|
|
|
|
public void setPosition(IPos pos, IWorld world) {
|
|
this.setPosition(pos.getXD(), pos.getYD(), pos.getZD(), world.getDimensionID());
|
|
}
|
|
|
|
public void setPos(IPos pos, IWorld world) {
|
|
this.setPosition(pos, world.getDimensionID());
|
|
}
|
|
|
|
public void setDimension(int dimension) {
|
|
this.setPosition(this.getPos(), dimension);
|
|
}
|
|
|
|
public void setDimension(IWorld world) {
|
|
this.setDimension(world.getDimensionID());
|
|
}
|
|
|
|
public int getHunger() {
|
|
return player.getFoodStats().getFoodLevel();
|
|
}
|
|
|
|
public void setHunger(int hunger) {
|
|
int prevHunger = this.getHunger();
|
|
if (hunger < 0)
|
|
hunger = 0;
|
|
|
|
player.getFoodStats().addStats(hunger - prevHunger, 0);
|
|
}
|
|
|
|
public float getSaturation() {
|
|
return player.getFoodStats().getSaturationLevel();
|
|
}
|
|
|
|
public void setSaturation(float saturation) {
|
|
float prevSaturation = this.getHunger();
|
|
if (saturation < 0)
|
|
saturation = 0;
|
|
|
|
player.getFoodStats().addStats(0, saturation - prevSaturation);
|
|
}
|
|
|
|
public void showDialog(IDialog dialog) {
|
|
if (dialog != null) {
|
|
showDialog(dialog.getId());
|
|
}
|
|
}
|
|
|
|
public boolean hasReadDialog(IDialog dialog) {
|
|
if (dialog != null) {
|
|
return hasReadDialog(dialog.getId());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void readDialog(IDialog dialog) {
|
|
if (dialog != null) {
|
|
this.readDialog(dialog.getId());
|
|
}
|
|
}
|
|
|
|
public void unreadDialog(IDialog dialog) {
|
|
if (dialog != null) {
|
|
this.unreadDialog(dialog.getId());
|
|
}
|
|
}
|
|
|
|
public void showDialog(int id) {
|
|
Dialog dialog = (Dialog) DialogController.Instance.get(id);
|
|
if (dialog == null)
|
|
return;
|
|
|
|
NoppesUtilServer.openDialog(player, new EntityDialogNpc(this.player.worldObj), dialog, 0);
|
|
}
|
|
|
|
public boolean hasReadDialog(int id) {
|
|
PlayerDialogData data = PlayerData.get(player).dialogData;
|
|
return data.dialogsRead.contains(id);
|
|
}
|
|
|
|
public void readDialog(int id) {
|
|
PlayerData playerData = PlayerData.get(player);
|
|
playerData.dialogData.dialogsRead.add(id);
|
|
playerData.updateClient = true;
|
|
}
|
|
|
|
public void unreadDialog(int id) {
|
|
PlayerData playerData = PlayerData.get(player);
|
|
playerData.dialogData.dialogsRead.remove(id);
|
|
playerData.updateClient = true;
|
|
}
|
|
|
|
public boolean hasFinishedQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return false;
|
|
return hasFinishedQuest(quest.getId());
|
|
}
|
|
|
|
public boolean hasActiveQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return false;
|
|
return hasActiveQuest(quest.getId());
|
|
}
|
|
|
|
public void startQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return;
|
|
startQuest(quest.getId());
|
|
}
|
|
|
|
public void finishQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return;
|
|
finishQuest(quest.getId());
|
|
}
|
|
|
|
public void stopQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return;
|
|
stopQuest(quest.getId());
|
|
}
|
|
|
|
public void removeQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return;
|
|
removeQuest(quest.getId());
|
|
}
|
|
|
|
public boolean hasFinishedQuest(int id) {
|
|
PlayerQuestData data = PlayerData.get(player).questData;
|
|
return data.finishedQuests.containsKey(id);
|
|
}
|
|
|
|
public boolean hasActiveQuest(int id) {
|
|
PlayerQuestData data = PlayerData.get(player).questData;
|
|
return data.activeQuests.containsKey(id);
|
|
}
|
|
|
|
/**
|
|
* Add the quest from active quest list
|
|
*
|
|
* @param id The Quest ID
|
|
*/
|
|
public void startQuest(int id) {
|
|
Quest quest = QuestController.Instance.quests.get(id);
|
|
if (quest == null)
|
|
return;
|
|
PlayerData data = PlayerData.get(player);
|
|
if (data.questData.activeQuests.containsKey(id))
|
|
return;
|
|
QuestData questdata = new QuestData(quest);
|
|
data.questData.activeQuests.put(id, questdata);
|
|
|
|
AchievementPacket.sendAchievement((EntityPlayerMP) player, false, "quest.newquest", quest.title);
|
|
ChatAlertPacket.sendChatAlert((EntityPlayerMP) player, "quest.newquest", ": ", quest.title);
|
|
data.updateClient = true;
|
|
}
|
|
|
|
/**
|
|
* Add the quest from finished quest list
|
|
*
|
|
* @param id The Quest ID
|
|
*/
|
|
public void finishQuest(int id) {
|
|
Quest quest = QuestController.Instance.quests.get(id);
|
|
if (quest == null)
|
|
return;
|
|
PlayerData data = PlayerData.get(player);
|
|
PlayerQuestController.setQuestFinishedUtil(player, quest, data.questData);
|
|
data.updateClient = true;
|
|
}
|
|
|
|
/**
|
|
* Removes the quest from active quest list
|
|
*
|
|
* @param id The Quest ID
|
|
*/
|
|
public void stopQuest(int id) {
|
|
Quest quest = QuestController.Instance.quests.get(id);
|
|
if (quest == null)
|
|
return;
|
|
PlayerData data = PlayerData.get(player);
|
|
data.questData.activeQuests.remove(id);
|
|
data.updateClient = true;
|
|
}
|
|
|
|
/**
|
|
* Removes the quest from active and finished quest list
|
|
*
|
|
* @param id The Quest ID
|
|
*/
|
|
public void removeQuest(int id) {
|
|
Quest quest = QuestController.Instance.quests.get(id);
|
|
if (quest == null)
|
|
return;
|
|
PlayerData data = PlayerData.get(player);
|
|
data.questData.activeQuests.remove(id);
|
|
data.questData.finishedQuests.remove(id);
|
|
data.updateClient = true;
|
|
}
|
|
|
|
@Override
|
|
public int getType() {
|
|
return EntityType.PLAYER;
|
|
}
|
|
|
|
@Override
|
|
public boolean typeOf(int type) {
|
|
return type == EntityType.PLAYER ? true : super.typeOf(type);
|
|
}
|
|
|
|
/**
|
|
* @param faction The faction id
|
|
* @param points The points to increase. Use negative values to decrease
|
|
*/
|
|
public void addFactionPoints(int faction, int points) {
|
|
PlayerData data = PlayerData.get(player);
|
|
data.factionData.increasePoints(faction, points, player);
|
|
}
|
|
|
|
/**
|
|
* @param faction The faction id
|
|
* @param points The new point value for this faction
|
|
*/
|
|
public void setFactionPoints(int faction, int points) {
|
|
PlayerData data = PlayerData.get(player);
|
|
data.factionData.increasePoints(faction, points - getFactionPoints(faction), player);
|
|
}
|
|
|
|
/**
|
|
* @param faction The faction id
|
|
* @return points
|
|
*/
|
|
public int getFactionPoints(int faction) {
|
|
PlayerData data = PlayerData.get(player);
|
|
return data.factionData.getFactionPoints(faction);
|
|
}
|
|
|
|
public void sendMessage(String message) {
|
|
player.addChatMessage(new ChatComponentTranslation(NoppesStringUtils.formatText(message, player)));
|
|
}
|
|
|
|
public void sendMessage(String message, String color, boolean bold, boolean italic, boolean underlined) {
|
|
sendMessage(message, color, bold, italic, underlined, false, false);
|
|
}
|
|
|
|
public void sendMessage(String message, String color, boolean bold, boolean italic, boolean obfuscated, boolean strikethrough, boolean underlined) {
|
|
EnumChatFormatting c = getColor(color);
|
|
|
|
if (c == null)
|
|
return;
|
|
|
|
ChatComponentTranslation chat = new ChatComponentTranslation(NoppesStringUtils.formatText(message, player));
|
|
ChatStyle style = new ChatStyle();
|
|
style.setColor(c);
|
|
style.setBold(bold);
|
|
style.setItalic(italic);
|
|
style.setObfuscated(obfuscated);
|
|
style.setStrikethrough(strikethrough);
|
|
style.setUnderlined(underlined);
|
|
chat.setChatStyle(style);
|
|
|
|
player.addChatMessage(chat);
|
|
}
|
|
|
|
private EnumChatFormatting getColor(String color) {
|
|
switch (color) {
|
|
case "black":
|
|
return EnumChatFormatting.BLACK;
|
|
case "dark_blue":
|
|
return EnumChatFormatting.DARK_BLUE;
|
|
case "dark_green":
|
|
return EnumChatFormatting.DARK_GREEN;
|
|
case "dark_aqua":
|
|
return EnumChatFormatting.DARK_AQUA;
|
|
case "dark_red":
|
|
return EnumChatFormatting.DARK_RED;
|
|
case "dark_purple":
|
|
return EnumChatFormatting.DARK_PURPLE;
|
|
case "gold":
|
|
return EnumChatFormatting.GOLD;
|
|
case "gray":
|
|
return EnumChatFormatting.GRAY;
|
|
case "dark_gray":
|
|
return EnumChatFormatting.DARK_GRAY;
|
|
case "blue":
|
|
return EnumChatFormatting.BLUE;
|
|
case "green":
|
|
return EnumChatFormatting.GREEN;
|
|
case "aqua":
|
|
return EnumChatFormatting.AQUA;
|
|
case "red":
|
|
return EnumChatFormatting.RED;
|
|
case "light_purple":
|
|
return EnumChatFormatting.LIGHT_PURPLE;
|
|
case "yellow":
|
|
return EnumChatFormatting.YELLOW;
|
|
case "white":
|
|
return EnumChatFormatting.WHITE;
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return Return gamemode. 0: Survival, 1: Creative, 2: Adventure
|
|
*/
|
|
public int getMode() {
|
|
return player.theItemInWorldManager.getGameType().getID();
|
|
}
|
|
|
|
/**
|
|
* @param type The gamemode type. 0:SURVIVAL, 1:CREATIVE, 2:ADVENTURE
|
|
*/
|
|
public void setMode(int type) {
|
|
player.setGameType(WorldSettings.getGameTypeById(type));
|
|
}
|
|
|
|
/**
|
|
* @return Returns a IItemStack array size 36
|
|
* @since 1.7.10d
|
|
*/
|
|
public IItemStack[] getInventory() {
|
|
IItemStack[] items = new IItemStack[36];
|
|
for (int i = 0; i < player.inventory.mainInventory.length; i++) {
|
|
ItemStack item = player.inventory.mainInventory[i];
|
|
if (item != null)
|
|
items[i] = NpcAPI.Instance().getIItemStack(item);
|
|
}
|
|
return items;
|
|
}
|
|
|
|
public int inventoryItemCount(IItemStack item) {
|
|
return inventoryItemCount(item, true, true);
|
|
}
|
|
|
|
/**
|
|
* @param item The item to be checked
|
|
* @return How many of this item the player has
|
|
*/
|
|
public int inventoryItemCount(IItemStack item, boolean ignoreNBT, boolean ignoreDamage) {
|
|
int i = 0;
|
|
for (ItemStack is : player.inventory.mainInventory) {
|
|
if (is != null && NoppesUtilPlayer.compareItems(is, item.getMCItemStack(), ignoreDamage, ignoreNBT)) {
|
|
i += is.stackSize;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
/**
|
|
* @param id The items name
|
|
* @param damage The damage value
|
|
* @param amount How many will be removed
|
|
* @return Returns true if the items were removed succesfully. Returns false incase a bigger amount than what the player has was given or item doesnt exist
|
|
* @since 1.7.10c
|
|
*/
|
|
public boolean removeItem(String id, int damage, int amount) {
|
|
Item item = (Item) Item.itemRegistry.getObject(id);
|
|
if (item == null)
|
|
return false;
|
|
return removeItem(NpcAPI.Instance().getIItemStack(new ItemStack(item, 1, damage)), amount);
|
|
}
|
|
|
|
public boolean removeItem(IItemStack item, int amount) {
|
|
return removeItem(item, amount, true, true);
|
|
}
|
|
|
|
/**
|
|
* @param item The Item type to be removed
|
|
* @param amount How many will be removed
|
|
* @return Returns true if the items were removed succesfully. Returns false incase a bigger amount than what the player has was given
|
|
*/
|
|
public boolean removeItem(IItemStack item, int amount, boolean ignoreNBT, boolean ignoreDamage) {
|
|
int count = inventoryItemCount(item, ignoreNBT, ignoreDamage);
|
|
if (amount > count) {
|
|
return false;
|
|
} else if (count == amount) {
|
|
removeAllItems(item, ignoreNBT, ignoreDamage);
|
|
} else {
|
|
for (int i = 0; i < player.inventory.mainInventory.length; i++) {
|
|
ItemStack is = player.inventory.mainInventory[i];
|
|
if (is != null && NoppesUtilPlayer.compareItems(is, item.getMCItemStack(), ignoreDamage, ignoreNBT)) {
|
|
if (amount > is.stackSize) {
|
|
player.inventory.mainInventory[i] = null;
|
|
amount -= is.stackSize;
|
|
} else {
|
|
is.splitStack(amount);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.updatePlayerInventory();
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param item The item to be removed from the players inventory
|
|
*/
|
|
public int removeAllItems(IItemStack item, boolean ignoreNBT, boolean ignoreDamage) {
|
|
int removed = 0;
|
|
|
|
for (int i = 0; i < player.inventory.mainInventory.length; i++) {
|
|
ItemStack is = player.inventory.mainInventory[i];
|
|
if (is != null && NoppesUtilPlayer.compareItems(is, item.getMCItemStack(), ignoreDamage, ignoreNBT)) {
|
|
player.inventory.mainInventory[i] = null;
|
|
removed++;
|
|
}
|
|
}
|
|
|
|
return removed;
|
|
}
|
|
|
|
/**
|
|
* @param item Item to be added
|
|
* @param amount The amount of the item to be added
|
|
* @return Returns whether or not it gave the item succesfully
|
|
* @since 1.7.10c
|
|
*/
|
|
public boolean giveItem(IItemStack item, int amount) {
|
|
if (item != null && item.getMCItemStack() != null) {
|
|
item.setStackSize(amount);
|
|
boolean bool = this.player.inventory.addItemStackToInventory(item.getMCItemStack());
|
|
this.updatePlayerInventory();
|
|
return bool;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param id The items name
|
|
* @param damage The damage value
|
|
* @param amount The amount of the item to be added
|
|
* @return Returns whether or not it gave the item succesfully
|
|
* @since 1.7.10c
|
|
*/
|
|
public boolean giveItem(String id, int damage, int amount) {
|
|
Item item = (Item) Item.itemRegistry.getObject(id);
|
|
if (item == null)
|
|
return false;
|
|
return player.inventory.addItemStackToInventory(new ItemStack(item, amount, damage));
|
|
}
|
|
|
|
/**
|
|
* Same as the /spawnpoint command
|
|
*
|
|
* @param x The x position
|
|
* @param y The y position
|
|
* @param z The z position
|
|
*/
|
|
public void setSpawnpoint(int x, int y, int z) {
|
|
x = ValueUtil.clamp(x, -30000000, 30000000);
|
|
z = ValueUtil.clamp(z, -30000000, 30000000);
|
|
y = ValueUtil.clamp(y, 0, 256);
|
|
player.setSpawnChunk(new ChunkCoordinates(x, y, z), true);
|
|
}
|
|
|
|
public void setSpawnpoint(IPos pos) {
|
|
this.setSpawnpoint(pos.getX(), pos.getY(), pos.getZ());
|
|
}
|
|
|
|
public void resetSpawnpoint() {
|
|
player.setSpawnChunk(null, false);
|
|
}
|
|
|
|
public void clearInventory() {
|
|
for (int i = 0; i < player.inventory.mainInventory.length; i++) player.inventory.mainInventory[i] = null;
|
|
for (int i = 0; i < player.inventory.armorInventory.length; i++) player.inventory.armorInventory[i] = null;
|
|
}
|
|
|
|
public void setRotation(float rotationYaw) {
|
|
NoppesUtilPlayer.teleportPlayer(player, player.posX, player.posY, player.posZ, rotationYaw, player.rotationPitch, player.dimension);
|
|
}
|
|
|
|
public void setRotation(float rotationYaw, float rotationPitch) {
|
|
NoppesUtilPlayer.teleportPlayer(player, player.posX, player.posY, player.posZ, rotationYaw, rotationPitch, player.dimension);
|
|
}
|
|
|
|
@Override
|
|
public float getRotation() {
|
|
return entity.rotationYaw;
|
|
}
|
|
|
|
public void swingHand() {
|
|
NoppesUtilPlayer.swingPlayerArm(player);
|
|
}
|
|
|
|
public void disableMouseInput(long time, int... buttonIds) {
|
|
NoppesUtilPlayer.disableMouseInput(player, time, buttonIds);
|
|
}
|
|
|
|
public void stopUsingItem() {
|
|
player.stopUsingItem();
|
|
}
|
|
|
|
public void clearItemInUse() {
|
|
player.clearItemInUse();
|
|
}
|
|
|
|
public void playSound(String name, float volume, float pitch) {
|
|
player.playSound(name, volume, pitch);
|
|
}
|
|
|
|
public void playSound(int id, ISound sound) {
|
|
NoppesUtilPlayer.playSoundTo(player, id, (ScriptSound) sound);
|
|
}
|
|
|
|
public void playSound(ISound sound) {
|
|
NoppesUtilPlayer.playSoundTo(player, (ScriptSound) sound);
|
|
}
|
|
|
|
public void stopSound(int id) {
|
|
NoppesUtilPlayer.stopSoundFor(player, id);
|
|
}
|
|
|
|
public void pauseSounds() {
|
|
NoppesUtilPlayer.pauseSoundsFor(player);
|
|
}
|
|
|
|
public void continueSounds() {
|
|
NoppesUtilPlayer.continueSoundsFor(player);
|
|
}
|
|
|
|
public void stopSounds() {
|
|
NoppesUtilPlayer.stopSoundsFor(player);
|
|
}
|
|
|
|
public void mountEntity(Entity ridingEntity) {
|
|
player.mountEntity(ridingEntity);
|
|
}
|
|
|
|
public IEntity dropOneItem(boolean dropStack) {
|
|
return NpcAPI.Instance().getIEntity(player.dropOneItem(dropStack));
|
|
}
|
|
|
|
public boolean canHarvestBlock(IBlock block) {
|
|
return player.canHarvestBlock(block.getMCBlock());
|
|
}
|
|
|
|
public boolean interactWith(IEntity entity) {
|
|
return player.interactWith(entity.getMCEntity());
|
|
}
|
|
|
|
/**
|
|
* @param achievement The achievement id. For a complete list see http://minecraft.wiki/w/Achievements
|
|
* @return Returns whether or not the player has this achievement
|
|
*/
|
|
public boolean hasAchievement(String achievement) {
|
|
StatBase statbase = StatList.func_151177_a(achievement);
|
|
if (statbase == null || !(statbase instanceof Achievement)) {
|
|
return false;
|
|
}
|
|
return player.func_147099_x().hasAchievementUnlocked((Achievement) statbase);
|
|
}
|
|
|
|
/**
|
|
* @param permission Bukkit/Cauldron permission
|
|
* @return Returns whether or not the player has the permission
|
|
*/
|
|
public boolean hasBukkitPermission(String permission) {
|
|
return CustomNpcsPermissions.hasPermissionString(player, permission);
|
|
}
|
|
|
|
/**
|
|
* @return Returns the exp level
|
|
* @since 1.7.10c
|
|
*/
|
|
public int getExpLevel() {
|
|
return player.experienceLevel;
|
|
}
|
|
|
|
/**
|
|
* @param level The new exp level you want to set
|
|
* @since 1.7.10c
|
|
*/
|
|
public void setExpLevel(int level) {
|
|
player.experienceLevel = level;
|
|
player.addExperienceLevel(0);
|
|
}
|
|
|
|
/**
|
|
* Requires pixelmon to be installed
|
|
*
|
|
* @since 1.7.10d
|
|
*/
|
|
public IPixelmonPlayerData getPixelmonData() {
|
|
if (!PixelmonHelper.Enabled)
|
|
return null;
|
|
return new ScriptPixelmonPlayerData(player);
|
|
}
|
|
|
|
public ITimers getTimers() {
|
|
return PlayerData.get(player).timers;
|
|
}
|
|
|
|
@Override
|
|
public IScreenSize getScreenSize() {
|
|
PlayerData data = PlayerData.get(player);
|
|
return data.getScreenSize();
|
|
}
|
|
|
|
public void updatePlayerInventory() {
|
|
((EntityPlayerMP) this.entity).inventoryContainer.detectAndSendChanges();
|
|
PlayerData playerData = PlayerData.get(player);
|
|
PlayerQuestData questData = playerData.questData;
|
|
Party playerParty = playerData.getPlayerParty();
|
|
if (playerParty != null)
|
|
PartyController.Instance().checkQuestCompletion(playerParty, EnumQuestType.Item);
|
|
|
|
questData.checkQuestCompletion(playerData, EnumQuestType.Item);
|
|
}
|
|
|
|
@Deprecated
|
|
public boolean checkGUIOpen() {
|
|
NoppesUtilPlayer.isGUIOpen(player);
|
|
PlayerData data = PlayerData.get(player);
|
|
return data.getGUIOpen();
|
|
}
|
|
|
|
@Deprecated
|
|
public ScriptDBCPlayer<T> getDBCPlayer() {
|
|
return this instanceof ScriptDBCPlayer ? (ScriptDBCPlayer<T>) this : null;
|
|
}
|
|
|
|
public boolean blocking() {
|
|
return player.isBlocking();
|
|
}
|
|
|
|
public PlayerData getData() {
|
|
if (this.data == null) {
|
|
this.data = PlayerData.get(player);
|
|
}
|
|
|
|
return this.data;
|
|
}
|
|
|
|
public boolean isScriptingDev() {
|
|
return ConfigScript.isScriptDev(player);
|
|
}
|
|
|
|
public IQuest[] getActiveQuests() {
|
|
PlayerQuestData data = (PlayerQuestData) this.getData().getQuestData();
|
|
List<IQuest> quests = new ArrayList();
|
|
Iterator var3 = data.activeQuests.keySet().iterator();
|
|
|
|
while (var3.hasNext()) {
|
|
int id = (Integer) var3.next();
|
|
IQuest quest = (IQuest) QuestController.Instance.quests.get(id);
|
|
if (quest != null) {
|
|
quests.add(quest);
|
|
}
|
|
}
|
|
|
|
return (IQuest[]) quests.toArray(new IQuest[quests.size()]);
|
|
}
|
|
|
|
public IContainer getOpenContainer() {
|
|
return NpcAPI.Instance().getIContainer(((EntityPlayerMP) this.entity).openContainer);
|
|
}
|
|
|
|
public void showCustomGui(ICustomGui gui) {
|
|
CustomGuiController.openGui(this, (ScriptGui) gui);
|
|
}
|
|
|
|
public ICustomGui getCustomGui() {
|
|
return ((EntityPlayerMP) this.entity).openContainer instanceof ContainerCustomGui ? ((ContainerCustomGui) ((EntityPlayerMP) this.entity).openContainer).customGui : null;
|
|
}
|
|
|
|
public void closeGui() {
|
|
((EntityPlayerMP) this.entity).closeContainer();
|
|
GuiClosePacket.closeGUI(player, -1, new NBTTagCompound());
|
|
}
|
|
|
|
public void showCustomOverlay(ICustomOverlay overlay) {
|
|
CustomGuiController.openOverlay(this, (ScriptOverlay) overlay);
|
|
}
|
|
|
|
public void closeOverlay(int id) {
|
|
PacketHandler.Instance.sendToPlayer(new ScriptOverlayClosePacket(id), (EntityPlayerMP) this.entity);
|
|
}
|
|
|
|
public IOverlayHandler getOverlays() {
|
|
return this.getData().skinOverlays;
|
|
}
|
|
|
|
public IAnimationData getAnimationData() {
|
|
return this.getData().animationData;
|
|
}
|
|
|
|
public IQuest[] getFinishedQuests() {
|
|
PlayerQuestData data = this.getData().questData;
|
|
List<IQuest> quests = new ArrayList();
|
|
Iterator var3 = data.finishedQuests.keySet().iterator();
|
|
|
|
while (var3.hasNext()) {
|
|
int id = (Integer) var3.next();
|
|
IQuest quest = (IQuest) QuestController.Instance.quests.get(id);
|
|
if (quest != null) {
|
|
quests.add(quest);
|
|
}
|
|
}
|
|
|
|
return (IQuest[]) quests.toArray(new IQuest[quests.size()]);
|
|
}
|
|
|
|
public void setConqueredEnd(boolean conqueredEnd) {
|
|
this.player.playerConqueredTheEnd = conqueredEnd;
|
|
}
|
|
|
|
public boolean conqueredEnd() {
|
|
return this.player.playerConqueredTheEnd;
|
|
}
|
|
|
|
public IMagicData getMagicData() {
|
|
return this.getData().magicData;
|
|
}
|
|
|
|
public IPlayerAttributes getAttributes() {
|
|
return AttributeController.getTracker(this.player);
|
|
}
|
|
|
|
@Override
|
|
public IActionManager getActionManager() {
|
|
if (getData().actionManager.getName().isEmpty())
|
|
data.actionManager.setName(player.getDisplayName());
|
|
|
|
return data.actionManager;
|
|
}
|
|
|
|
|
|
@Override
|
|
public IPlayer[] getPartyMembers(){
|
|
Party party = this.getData().getPlayerParty();
|
|
if (party == null) {
|
|
throw new CustomNPCsException("Player is not in party");
|
|
}
|
|
List<IPlayer> list = new ArrayList<>();
|
|
for(int i = 0; i < party.getPlayerNamesList().size();i++){
|
|
IPlayer player = NpcAPI.Instance().getPlayer(party.getPlayerNamesList().get(i));
|
|
if (player == null) continue;
|
|
list.add(player);
|
|
}
|
|
return (IPlayer[]) list.toArray(new IPlayer[list.size()]);
|
|
}
|
|
|
|
// ==================== CURRENCY METHODS ====================
|
|
|
|
/**
|
|
* Get the player's current currency balance.
|
|
* Uses Vault if available, otherwise uses internal currency system.
|
|
* @return The player's currency balance
|
|
* @since 1.11
|
|
*/
|
|
public long getCurrencyBalance() {
|
|
if (CurrencyController.Instance == null) {
|
|
return 0;
|
|
}
|
|
return CurrencyController.Instance.getBalance(player);
|
|
}
|
|
|
|
/**
|
|
* Add currency to the player's balance.
|
|
* @param amount The amount to add (must be positive)
|
|
* @return true if successful, false if failed (e.g., would exceed max balance)
|
|
* @since 1.11
|
|
*/
|
|
public boolean addCurrency(long amount) {
|
|
if (CurrencyController.Instance == null) {
|
|
return false;
|
|
}
|
|
return CurrencyController.Instance.deposit(player, amount);
|
|
}
|
|
|
|
/**
|
|
* Remove currency from the player's balance.
|
|
* @param amount The amount to remove (must be positive)
|
|
* @return true if successful, false if insufficient funds
|
|
* @since 1.11
|
|
*/
|
|
public boolean removeCurrency(long amount) {
|
|
if (CurrencyController.Instance == null) {
|
|
return false;
|
|
}
|
|
return CurrencyController.Instance.withdraw(player, amount);
|
|
}
|
|
|
|
/**
|
|
* Check if the player can afford a specific amount.
|
|
* @param amount The amount to check
|
|
* @return true if player has sufficient balance
|
|
* @since 1.11
|
|
*/
|
|
public boolean canAffordCurrency(long amount) {
|
|
if (CurrencyController.Instance == null) {
|
|
return false;
|
|
}
|
|
return CurrencyController.Instance.canAfford(player, amount);
|
|
}
|
|
|
|
/**
|
|
* Get the configured currency name (e.g., "Gold").
|
|
* @return The currency name
|
|
* @since 1.11
|
|
*/
|
|
public String getCurrencyName() {
|
|
if (VaultHelper.Instance == null) {
|
|
return "Currency";
|
|
}
|
|
return VaultHelper.Instance.getCurrencyName();
|
|
}
|
|
|
|
/**
|
|
* Format a currency amount for display (e.g., "1,000 Gold").
|
|
* @param amount The amount to format
|
|
* @return Formatted string
|
|
* @since 1.11
|
|
*/
|
|
public String formatCurrency(long amount) {
|
|
if (CurrencyController.Instance == null) {
|
|
return String.valueOf(amount);
|
|
}
|
|
return CurrencyController.Instance.formatAmount(amount);
|
|
}
|
|
|
|
/**
|
|
* Check if the player has pending currency claims.
|
|
* Claims are created by auction refunds, NPC payments, etc.
|
|
* @return true if there are pending claims
|
|
* @since 1.11
|
|
*/
|
|
public boolean hasPendingClaims() {
|
|
if (CurrencyController.Instance == null) {
|
|
return false;
|
|
}
|
|
return CurrencyController.Instance.hasPendingClaims(player);
|
|
}
|
|
|
|
/**
|
|
* Get the total amount of pending currency claims.
|
|
* @return Total pending claim amount
|
|
* @since 1.11
|
|
*/
|
|
public long getPendingClaimsTotal() {
|
|
if (CurrencyController.Instance == null) {
|
|
return 0;
|
|
}
|
|
return CurrencyController.Instance.getTotalPendingClaims(player);
|
|
}
|
|
|
|
/**
|
|
* Claim all pending currency claims and add them to balance.
|
|
* @return The total amount claimed
|
|
* @since 1.11
|
|
*/
|
|
public long claimAllCurrency() {
|
|
if (CurrencyController.Instance == null) {
|
|
return 0;
|
|
}
|
|
return CurrencyController.Instance.claimAll(player);
|
|
}
|
|
|
|
// ==================== AUCTION METHODS ====================
|
|
|
|
/**
|
|
* Get the number of active auction listings the player has.
|
|
* @return Number of active listings
|
|
* @since 1.11
|
|
*/
|
|
public int getAuctionListingCount() {
|
|
if (AuctionController.Instance == null) {
|
|
return 0;
|
|
}
|
|
return AuctionController.Instance.getActiveListingsCount(player.getUniqueID());
|
|
}
|
|
|
|
/**
|
|
* Get the maximum number of auction listings the player is allowed.
|
|
* @return Maximum listing count
|
|
* @since 1.11
|
|
*/
|
|
public int getMaxAuctionListings() {
|
|
if (AuctionController.Instance == null) {
|
|
return 0;
|
|
}
|
|
return AuctionController.Instance.getMaxListings(player);
|
|
}
|
|
|
|
/**
|
|
* Check if the player has auction items waiting to be claimed.
|
|
* This includes won items, expired listings, and sale proceeds.
|
|
* @return true if there are claimable items
|
|
* @since 1.11
|
|
*/
|
|
public boolean hasAuctionClaims() {
|
|
if (AuctionController.Instance == null) {
|
|
return false;
|
|
}
|
|
return !AuctionController.Instance.getClaimableListings(player.getUniqueID()).isEmpty();
|
|
}
|
|
|
|
/**
|
|
* Get the number of auction items waiting to be claimed.
|
|
* @return Number of claimable items/listings
|
|
* @since 1.11
|
|
*/
|
|
public int getAuctionClaimCount() {
|
|
if (AuctionController.Instance == null) {
|
|
return 0;
|
|
}
|
|
return AuctionController.Instance.getClaimableListings(player.getUniqueID()).size();
|
|
}
|
|
|
|
/**
|
|
* Get the number of auctions where the player is the current high bidder.
|
|
* @return Number of active bids
|
|
* @since 1.11
|
|
*/
|
|
public int getActiveAuctionBidCount() {
|
|
if (AuctionController.Instance == null) {
|
|
return 0;
|
|
}
|
|
return (int) AuctionController.Instance.getListingsAsBidder(player.getUniqueID())
|
|
.stream()
|
|
.filter(l -> l.isActive())
|
|
.count();
|
|
}
|
|
}
|