Auction Merge

This commit is contained in:
Kam committed 2026-01-20 21:07:18 -05:00
commit 04e2a57cb4
44 files changed
+7453 -1837

No files matched your search

@@ -0,0 +1,308 @@
package kamkeel.npcs.controllers.data.attribute;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import noppes.npcs.controllers.data.PlayerData;
import java.util.UUID;
/**
* Utility class for managing item trade restrictions.
* Checks and sets attributes that control whether items can be traded/auctioned.
*/
public class ItemTradeAttribute {
// New untradeable attribute - prevents all trading
public static final String TAG_UNTRADEABLE = "CNPC_Untradeable";
// Existing requirement keys (from ProfileSlotRequirement and SoulbindRequirement)
public static final String TAG_PROFILE_SLOT = "cnpc_profile_slot";
public static final String TAG_SOULBIND = "cnpc_soulbind";
// ==================== Trade Check Methods ====================
/**
* Check if item can be traded/auctioned by the given player.
* An item cannot be traded if:
* - It has the Untradeable flag
* - It is bound to a specific profile slot (ProfileSlot Bound)
* - It is soulbound to a different player
*
* @param item The item to check
* @param player The player trying to trade (null to check without player context)
* @return true if the item can be traded
*/
public static boolean canTrade(ItemStack item, EntityPlayer player) {
if (item == null) {
return true;
}
if (!item.hasTagCompound()) {
return true;
}
NBTTagCompound tag = item.getTagCompound();
// Check untradeable flag - always blocks trading
if (tag.getBoolean(TAG_UNTRADEABLE)) {
return false;
}
// Check profile slot bound - blocks trading as it's tied to a slot
if (tag.hasKey(TAG_PROFILE_SLOT)) {
return false;
}
// Check soulbound - blocks trading as it's tied to a player
if (tag.hasKey(TAG_SOULBIND)) {
// If we have a player context, check if they're the owner
if (player != null) {
String soulbindUUID = tag.getString(TAG_SOULBIND);
if (soulbindUUID != null && !soulbindUUID.isEmpty()) {
// Even if bound to this player, still can't trade
return false;
}
}
return false;
}
return true;
}
/**
* Check if item can be traded (without player context)
*/
public static boolean canTrade(ItemStack item) {
return canTrade(item, null);
}
/**
* Get the reason why an item cannot be traded.
* Returns a translation key for localization.
*
* @param item The item to check
* @return Translation key for the block reason, or null if tradeable
*/
public static String getTradeBlockReason(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return null;
}
NBTTagCompound tag = item.getTagCompound();
if (tag.getBoolean(TAG_UNTRADEABLE)) {
return "gui.auction.untradeable";
}
if (tag.hasKey(TAG_PROFILE_SLOT)) {
return "gui.auction.profileslotbound";
}
if (tag.hasKey(TAG_SOULBIND)) {
return "gui.auction.soulbound";
}
return null;
}
// ==================== Untradeable Methods ====================
/**
* Check if item is marked as untradeable
*/
public static boolean isUntradeable(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return false;
}
return item.getTagCompound().getBoolean(TAG_UNTRADEABLE);
}
/**
* Set the untradeable flag on an item
*/
public static void setUntradeable(ItemStack item, boolean untradeable) {
if (item == null) {
return;
}
if (!item.hasTagCompound()) {
item.setTagCompound(new NBTTagCompound());
}
if (untradeable) {
item.getTagCompound().setBoolean(TAG_UNTRADEABLE, true);
} else {
item.getTagCompound().removeTag(TAG_UNTRADEABLE);
}
}
// ==================== Profile Slot Bound Methods ====================
/**
* Check if item is bound to a profile slot
*/
public static boolean isProfileSlotBound(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return false;
}
return item.getTagCompound().hasKey(TAG_PROFILE_SLOT);
}
/**
* Get the profile slot an item is bound to
* @return The profile slot ID, or -1 if not bound
*/
public static int getProfileSlot(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return -1;
}
if (item.getTagCompound().hasKey(TAG_PROFILE_SLOT)) {
return item.getTagCompound().getInteger(TAG_PROFILE_SLOT);
}
return -1;
}
/**
* Bind an item to a specific profile slot
*/
public static void setProfileSlotBound(ItemStack item, int slot) {
if (item == null) {
return;
}
if (!item.hasTagCompound()) {
item.setTagCompound(new NBTTagCompound());
}
if (slot >= 0) {
item.getTagCompound().setInteger(TAG_PROFILE_SLOT, slot);
} else {
item.getTagCompound().removeTag(TAG_PROFILE_SLOT);
}
}
/**
* Bind an item to the player's current profile slot
*/
public static void bindToCurrentSlot(ItemStack item, EntityPlayer player) {
if (item == null || player == null) {
return;
}
PlayerData data = PlayerData.get(player);
if (data != null) {
setProfileSlotBound(item, data.profileSlot);
}
}
// ==================== Soulbind Methods ====================
/**
* Check if item is soulbound to any player
*/
public static boolean isSoulbound(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return false;
}
return item.getTagCompound().hasKey(TAG_SOULBIND);
}
/**
* Check if item is soulbound to a specific player
*/
public static boolean isSoulboundTo(ItemStack item, EntityPlayer player) {
if (item == null || player == null || !item.hasTagCompound()) {
return false;
}
if (!item.getTagCompound().hasKey(TAG_SOULBIND)) {
return false;
}
String soulbindUUID = item.getTagCompound().getString(TAG_SOULBIND);
return player.getUniqueID().toString().equals(soulbindUUID);
}
/**
* Get the UUID of the player the item is soulbound to
* @return The UUID string, or null if not soulbound
*/
public static String getSoulbindOwner(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return null;
}
if (item.getTagCompound().hasKey(TAG_SOULBIND)) {
return item.getTagCompound().getString(TAG_SOULBIND);
}
return null;
}
/**
* Soulbind an item to a player
*/
public static void setSoulbound(ItemStack item, EntityPlayer player) {
if (item == null || player == null) {
return;
}
if (!item.hasTagCompound()) {
item.setTagCompound(new NBTTagCompound());
}
item.getTagCompound().setString(TAG_SOULBIND, player.getUniqueID().toString());
}
/**
* Soulbind an item to a player by UUID
*/
public static void setSoulbound(ItemStack item, UUID playerUUID) {
if (item == null || playerUUID == null) {
return;
}
if (!item.hasTagCompound()) {
item.setTagCompound(new NBTTagCompound());
}
item.getTagCompound().setString(TAG_SOULBIND, playerUUID.toString());
}
/**
* Remove soulbind from an item
*/
public static void removeSoulbind(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return;
}
item.getTagCompound().removeTag(TAG_SOULBIND);
}
// ==================== Utility Methods ====================
/**
* Clear all trade restriction attributes from an item
*/
public static void clearAllRestrictions(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return;
}
NBTTagCompound tag = item.getTagCompound();
tag.removeTag(TAG_UNTRADEABLE);
tag.removeTag(TAG_PROFILE_SLOT);
tag.removeTag(TAG_SOULBIND);
}
/**
* Get a display string describing all trade restrictions on an item
* @return Human-readable string of restrictions, or empty if none
*/
public static String getRestrictionSummary(ItemStack item) {
if (item == null || !item.hasTagCompound()) {
return "";
}
StringBuilder summary = new StringBuilder();
NBTTagCompound tag = item.getTagCompound();
if (tag.getBoolean(TAG_UNTRADEABLE)) {
summary.append("Untradeable");
}
if (tag.hasKey(TAG_PROFILE_SLOT)) {
if (summary.length() > 0) summary.append(", ");
summary.append("Profile Slot Bound (Slot ").append(tag.getInteger(TAG_PROFILE_SLOT)).append(")");
}
if (tag.hasKey(TAG_SOULBIND)) {
if (summary.length() > 0) summary.append(", ");
summary.append("Soulbound");
}
return summary.toString();
}
}
@@ -36,6 +36,7 @@ import kamkeel.npcs.network.packets.data.gui.GuiWaypointPacket;
import kamkeel.npcs.network.packets.data.gui.IsGuiOpenPacket;
import kamkeel.npcs.network.packets.data.large.GuiDataPacket;
import kamkeel.npcs.network.packets.data.large.PartyDataPacket;
import kamkeel.npcs.network.packets.data.large.AuctionDataPacket;
import kamkeel.npcs.network.packets.data.large.ScrollDataPacket;
import kamkeel.npcs.network.packets.data.large.ScrollListPacket;
import kamkeel.npcs.network.packets.data.large.SyncEffectPacket;
@@ -51,6 +52,7 @@ import kamkeel.npcs.network.packets.data.script.ScriptOverlayDataPacket;
import kamkeel.npcs.network.packets.data.script.ScriptedParticlePacket;
import kamkeel.npcs.network.packets.data.ability.TelegraphSpawnPacket;
import kamkeel.npcs.network.packets.data.ability.TelegraphRemovePacket;
import kamkeel.npcs.network.packets.player.AuctionActionPacket;
import kamkeel.npcs.network.packets.player.BankActionPacket;
import kamkeel.npcs.network.packets.player.CheckPlayerValue;
import kamkeel.npcs.network.packets.player.CompanionActionPacket;
@@ -564,6 +566,9 @@ public class PacketHandler {
// Data | Ability Packets
DATA_PACKET.registerPacket(new TelegraphSpawnPacket());
DATA_PACKET.registerPacket(new TelegraphRemovePacket());
// Auction Data
DATA_PACKET.registerPacket(new AuctionDataPacket());
}
public void registerPlayerPackets() {
@@ -625,6 +630,9 @@ public class PacketHandler {
PLAYER_PACKET.registerPacket(new PartyAcceptInvitePacket());
PLAYER_PACKET.registerPacket(new PartyIgnoreInvitePacket());
PLAYER_PACKET.registerPacket(new PartyLogToServerPacket());
// Auction Packets
PLAYER_PACKET.registerPacket(new AuctionActionPacket());
}
public void registerChannels() {
@@ -62,4 +62,7 @@ public enum EnumDataPacket {
// Ability System
TELEGRAPH_SPAWN,
TELEGRAPH_REMOVE,
// Auction
AUCTION_DATA,
}
@@ -33,4 +33,7 @@ public enum EnumPlayerPacket {
ProfileGet,
ProfileGetInfo,
SyncRevisionInfo,
// Auction
AuctionAction,
}
@@ -0,0 +1,218 @@
package kamkeel.npcs.network.packets.data.large;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import kamkeel.npcs.network.LargeAbstractPacket;
import kamkeel.npcs.network.PacketChannel;
import kamkeel.npcs.network.PacketHandler;
import kamkeel.npcs.network.enums.EnumDataPacket;
import kamkeel.npcs.util.ByteBufUtils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import noppes.npcs.controllers.AuctionController;
import noppes.npcs.controllers.data.AuctionFilter;
import noppes.npcs.controllers.data.AuctionListing;
import java.io.IOException;
import java.util.List;
/**
* Large packet for sending auction listing data from server to client.
* Used for initial load and search/filter queries.
*/
public final class AuctionDataPacket extends LargeAbstractPacket {
public static final String packetName = "Large|AuctionData";
private DataType dataType;
private List<AuctionListing> listings;
private int totalResults;
private int currentPage;
private int totalPages;
private long playerBalance;
public AuctionDataPacket() {
}
private AuctionDataPacket(DataType type, List<AuctionListing> listings,
int totalResults, int currentPage, int totalPages,
long playerBalance) {
this.dataType = type;
this.listings = listings;
this.totalResults = totalResults;
this.currentPage = currentPage;
this.totalPages = totalPages;
this.playerBalance = playerBalance;
}
/**
* Send filtered listing results to client
*/
public static void sendFilteredListings(EntityPlayerMP player, AuctionFilter filter) {
if (AuctionController.Instance == null) {
return;
}
AuctionController.FilterResult result = AuctionController.Instance.getFilteredListings(filter);
long balance = 0;
if (noppes.npcs.controllers.CurrencyController.Instance != null) {
balance = noppes.npcs.controllers.CurrencyController.Instance.getBalance(player);
}
AuctionDataPacket packet = new AuctionDataPacket(
DataType.FILTERED_LISTINGS,
result.listings,
result.totalResults,
result.currentPage,
result.totalPages,
balance
);
PacketHandler.Instance.sendToPlayer(packet, player);
}
/**
* Send player's own listings
*/
public static void sendMyListings(EntityPlayerMP player) {
if (AuctionController.Instance == null) {
return;
}
List<AuctionListing> myListings = AuctionController.Instance
.getListingsBySeller(player.getUniqueID());
long balance = 0;
if (noppes.npcs.controllers.CurrencyController.Instance != null) {
balance = noppes.npcs.controllers.CurrencyController.Instance.getBalance(player);
}
AuctionDataPacket packet = new AuctionDataPacket(
DataType.MY_LISTINGS,
myListings,
myListings.size(),
0,
1,
balance
);
PacketHandler.Instance.sendToPlayer(packet, player);
}
/**
* Send player's active bids
*/
public static void sendMyBids(EntityPlayerMP player) {
if (AuctionController.Instance == null) {
return;
}
List<AuctionListing> myBids = AuctionController.Instance
.getListingsAsBidder(player.getUniqueID());
long balance = 0;
if (noppes.npcs.controllers.CurrencyController.Instance != null) {
balance = noppes.npcs.controllers.CurrencyController.Instance.getBalance(player);
}
AuctionDataPacket packet = new AuctionDataPacket(
DataType.MY_BIDS,
myBids,
myBids.size(),
0,
1,
balance
);
PacketHandler.Instance.sendToPlayer(packet, player);
}
/**
* Send player's claimable items
*/
public static void sendClaimable(EntityPlayerMP player) {
if (AuctionController.Instance == null) {
return;
}
List<AuctionListing> claimable = AuctionController.Instance
.getClaimableListings(player.getUniqueID());
long balance = 0;
if (noppes.npcs.controllers.CurrencyController.Instance != null) {
balance = noppes.npcs.controllers.CurrencyController.Instance.getBalance(player);
}
AuctionDataPacket packet = new AuctionDataPacket(
DataType.CLAIMABLE,
claimable,
claimable.size(),
0,
1,
balance
);
PacketHandler.Instance.sendToPlayer(packet, player);
}
@Override
public Enum getType() {
return EnumDataPacket.AUCTION_DATA;
}
@Override
public PacketChannel getChannel() {
return PacketHandler.DATA_PACKET;
}
@Override
protected byte[] getData() throws IOException {
ByteBuf buffer = Unpooled.buffer();
buffer.writeInt(dataType.ordinal());
buffer.writeInt(totalResults);
buffer.writeInt(currentPage);
buffer.writeInt(totalPages);
buffer.writeLong(playerBalance);
// Write listings as NBT
NBTTagList listingList = new NBTTagList();
if (listings != null) {
for (AuctionListing listing : listings) {
listingList.appendTag(listing.writeToNBT(new NBTTagCompound()));
}
}
NBTTagCompound compound = new NBTTagCompound();
compound.setTag("Listings", listingList);
ByteBufUtils.writeNBT(buffer, compound);
byte[] bytes = new byte[buffer.readableBytes()];
buffer.readBytes(bytes);
return bytes;
}
@Override
protected void handleCompleteData(ByteBuf data, EntityPlayer player) throws IOException {
// Client-side handling will be done in a client util class
// Similar to NoppesUtil.setScrollData()
int typeOrdinal = data.readInt();
int totalResults = data.readInt();
int currentPage = data.readInt();
int totalPages = data.readInt();
long playerBalance = data.readLong();
NBTTagCompound compound = ByteBufUtils.readNBT(data);
DataType type = DataType.values()[typeOrdinal];
// Store data for client GUI to access
// This will be implemented in the client-side GUI handler
noppes.npcs.client.NoppesUtil.setAuctionData(type.ordinal(), compound,
totalResults, currentPage, totalPages, playerBalance);
}
public enum DataType {
FILTERED_LISTINGS,
MY_LISTINGS,
MY_BIDS,
CLAIMABLE
}
}
@@ -0,0 +1,579 @@
package kamkeel.npcs.network.packets.player;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import io.netty.buffer.ByteBuf;
import kamkeel.npcs.network.AbstractPacket;
import kamkeel.npcs.network.PacketChannel;
import kamkeel.npcs.network.PacketClient;
import kamkeel.npcs.network.PacketHandler;
import kamkeel.npcs.network.enums.EnumPlayerPacket;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ChatComponentText;
import noppes.npcs.CustomNpcsPermissions;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.constants.EnumAuctionDuration;
import noppes.npcs.constants.EnumRoleType;
import noppes.npcs.containers.ContainerAuction;
import noppes.npcs.controllers.AuctionController;
import noppes.npcs.controllers.CurrencyController;
import noppes.npcs.controllers.data.AuctionFilter;
import noppes.npcs.controllers.data.AuctionListing;
import noppes.npcs.util.NBTJsonUtil;
import kamkeel.npcs.network.packets.data.large.AuctionDataPacket;
import java.io.IOException;
/**
* Packet for all auction-related player actions.
* Client -> Server for actions, Server -> Client for responses.
*/
public class AuctionActionPacket extends AbstractPacket {
public static final String packetName = "Player|Auction";
private Action action;
private int listingId;
private long amount;
private long buyoutPrice;
private int durationOrdinal;
private NBTTagCompound itemData;
private NBTTagCompound filterData; // For query operations
private String responseMessage;
private boolean success;
public AuctionActionPacket() {
}
private AuctionActionPacket(Action action) {
this.action = action;
}
@Override
public boolean needsNPC() {
return true;
}
// ==================== Client -> Server Actions ====================
/**
* Create a new auction listing
*/
@SideOnly(Side.CLIENT)
public static void CreateListing(ItemStack item, long startingPrice, long buyoutPrice, EnumAuctionDuration duration) {
AuctionActionPacket packet = new AuctionActionPacket(Action.CreateListing);
packet.amount = startingPrice;
packet.buyoutPrice = buyoutPrice;
packet.durationOrdinal = duration.ordinal();
packet.itemData = item.writeToNBT(new NBTTagCompound());
PacketClient.sendClient(packet);
}
/**
* Place a bid on an auction
*/
@SideOnly(Side.CLIENT)
public static void PlaceBid(int listingId, long bidAmount) {
AuctionActionPacket packet = new AuctionActionPacket(Action.PlaceBid);
packet.listingId = listingId;
packet.amount = bidAmount;
PacketClient.sendClient(packet);
}
/**
* Execute buyout on an auction
*/
@SideOnly(Side.CLIENT)
public static void Buyout(int listingId) {
AuctionActionPacket packet = new AuctionActionPacket(Action.Buyout);
packet.listingId = listingId;
PacketClient.sendClient(packet);
}
/**
* Cancel own listing
*/
@SideOnly(Side.CLIENT)
public static void CancelListing(int listingId) {
AuctionActionPacket packet = new AuctionActionPacket(Action.CancelListing);
packet.listingId = listingId;
PacketClient.sendClient(packet);
}
/**
* Claim item from won/expired/cancelled auction
*/
@SideOnly(Side.CLIENT)
public static void ClaimItem(int listingId) {
AuctionActionPacket packet = new AuctionActionPacket(Action.ClaimItem);
packet.listingId = listingId;
PacketClient.sendClient(packet);
}
/**
* Claim proceeds from sold auction
*/
@SideOnly(Side.CLIENT)
public static void ClaimProceeds(int listingId) {
AuctionActionPacket packet = new AuctionActionPacket(Action.ClaimProceeds);
packet.listingId = listingId;
PacketClient.sendClient(packet);
}
/**
* Query filtered listings
*/
@SideOnly(Side.CLIENT)
public static void QueryListings(AuctionFilter filter) {
AuctionActionPacket packet = new AuctionActionPacket(Action.QueryListings);
packet.filterData = filter.writeToNBT(new NBTTagCompound());
PacketClient.sendClient(packet);
}
/**
* Request player's own listings
*/
@SideOnly(Side.CLIENT)
public static void QueryMyListings() {
AuctionActionPacket packet = new AuctionActionPacket(Action.QueryMyListings);
PacketClient.sendClient(packet);
}
/**
* Request player's active bids
*/
@SideOnly(Side.CLIENT)
public static void QueryMyBids() {
AuctionActionPacket packet = new AuctionActionPacket(Action.QueryMyBids);
PacketClient.sendClient(packet);
}
/**
* Request player's claimable items
*/
@SideOnly(Side.CLIENT)
public static void QueryClaimable() {
AuctionActionPacket packet = new AuctionActionPacket(Action.QueryClaimable);
PacketClient.sendClient(packet);
}
@Override
public Enum getType() {
return EnumPlayerPacket.AuctionAction;
}
@Override
public PacketChannel getChannel() {
return PacketHandler.PLAYER_PACKET;
}
@Override
@SideOnly(Side.CLIENT)
public void sendData(ByteBuf out) throws IOException {
out.writeInt(action.ordinal());
switch (action) {
case CreateListing:
out.writeLong(amount);
out.writeLong(buyoutPrice);
out.writeInt(durationOrdinal);
String itemJson = NBTJsonUtil.Convert(itemData);
byte[] itemBytes = itemJson.getBytes("UTF-8");
out.writeInt(itemBytes.length);
out.writeBytes(itemBytes);
break;
case PlaceBid:
out.writeInt(listingId);
out.writeLong(amount);
break;
case Buyout:
case CancelListing:
case ClaimItem:
case ClaimProceeds:
out.writeInt(listingId);
break;
case QueryListings:
String filterJson = NBTJsonUtil.Convert(filterData);
byte[] filterBytes = filterJson.getBytes("UTF-8");
out.writeInt(filterBytes.length);
out.writeBytes(filterBytes);
break;
case QueryMyListings:
case QueryMyBids:
case QueryClaimable:
// No additional data needed
break;
}
}
@Override
public void receiveData(ByteBuf in, EntityPlayer player) throws IOException {
Action requestedAction = Action.values()[in.readInt()];
if (!(player instanceof EntityPlayerMP)) {
return;
}
EntityPlayerMP playerMP = (EntityPlayerMP) player;
// Verify NPC is an Auctioneer
if (npc == null || npc.advanced.role != EnumRoleType.Auctioneer) {
return;
}
// Check if auction system is enabled
if (!ConfigMarket.AuctionEnabled) {
sendResponse(playerMP, false, "Auction system is disabled");
return;
}
// Check controller exists
if (AuctionController.Instance == null) {
sendResponse(playerMP, false, "Auction controller not initialized");
return;
}
switch (requestedAction) {
case CreateListing:
handleCreateListing(in, playerMP);
break;
case PlaceBid:
handlePlaceBid(in, playerMP);
break;
case Buyout:
handleBuyout(in, playerMP);
break;
case CancelListing:
handleCancelListing(in, playerMP);
break;
case ClaimItem:
handleClaimItem(in, playerMP);
break;
case ClaimProceeds:
handleClaimProceeds(in, playerMP);
break;
case QueryListings:
handleQueryListings(in, playerMP);
break;
case QueryMyListings:
handleQueryMyListings(playerMP);
break;
case QueryMyBids:
handleQueryMyBids(playerMP);
break;
case QueryClaimable:
handleQueryClaimable(playerMP);
break;
}
}
private void handleCreateListing(ByteBuf in, EntityPlayerMP player) throws IOException {
// Check permission
if (!CustomNpcsPermissions.hasPermission(player, CustomNpcsPermissions.AUCTION_LIST)) {
sendResponse(player, false, "You don't have permission to create listings");
return;
}
long startingPrice = in.readLong();
long buyoutPrice = in.readLong();
int durationOrdinal = in.readInt();
int itemBytesLength = in.readInt();
byte[] itemBytes = new byte[itemBytesLength];
in.readBytes(itemBytes);
String itemJson = new String(itemBytes, "UTF-8");
try {
NBTTagCompound itemNBT = NBTJsonUtil.Convert(itemJson);
ItemStack requestedItem = ItemStack.loadItemStackFromNBT(itemNBT);
if (!(player.openContainer instanceof ContainerAuction)) {
sendResponse(player, false, "Open the auction listing screen to create a listing");
return;
}
ContainerAuction container = (ContainerAuction) player.openContainer;
ItemStack slotItem = container.getListingItem();
if (requestedItem == null || slotItem == null) {
sendResponse(player, false, "Place an item in the listing slot");
return;
}
if (!ItemStack.areItemStacksEqual(slotItem, requestedItem) || slotItem.stackSize != requestedItem.stackSize) {
sendResponse(player, false, "Listing item mismatch");
return;
}
// Validate duration
EnumAuctionDuration duration;
if (durationOrdinal >= 0 && durationOrdinal < EnumAuctionDuration.values().length) {
duration = EnumAuctionDuration.values()[durationOrdinal];
} else {
duration = EnumAuctionDuration.MEDIUM;
}
// Validate prices
if (startingPrice < 1) {
sendResponse(player, false, "Starting price must be at least 1");
return;
}
if (buyoutPrice > 0 && buyoutPrice < startingPrice) {
sendResponse(player, false, "Buyout price must be higher than starting price");
return;
}
// Create the listing
AuctionListing listing = AuctionController.Instance.createListing(
player, slotItem, startingPrice, buyoutPrice, duration);
if (listing != null) {
container.clearListingSlot();
sendResponse(player, true, "Listing created successfully");
} else {
sendResponse(player, false, "Failed to create listing. Check your balance and listing limit.");
}
} catch (Exception e) {
sendResponse(player, false, "Error creating listing: " + e.getMessage());
}
}
private void handlePlaceBid(ByteBuf in, EntityPlayerMP player) throws IOException {
// Check permission
if (!CustomNpcsPermissions.hasPermission(player, CustomNpcsPermissions.AUCTION_BID)) {
sendResponse(player, false, "You don't have permission to bid");
return;
}
int listingId = in.readInt();
long bidAmount = in.readLong();
AuctionListing listing = AuctionController.Instance.getListing(listingId);
if (listing == null) {
sendResponse(player, false, "Listing not found");
return;
}
if (!listing.isActive()) {
sendResponse(player, false, "This auction has ended");
return;
}
if (bidAmount < listing.getMinimumBid()) {
sendResponse(player, false, "Bid must be at least " + listing.getMinimumBid());
return;
}
if (!CurrencyController.Instance.canAfford(player, bidAmount)) {
sendResponse(player, false, "You cannot afford this bid");
return;
}
if (AuctionController.Instance.placeBid(listingId, player, bidAmount)) {
sendResponse(player, true, "Bid placed successfully");
} else {
sendResponse(player, false, "Failed to place bid");
}
}
private void handleBuyout(ByteBuf in, EntityPlayerMP player) throws IOException {
// Check permission
if (!CustomNpcsPermissions.hasPermission(player, CustomNpcsPermissions.AUCTION_BUYOUT)) {
sendResponse(player, false, "You don't have permission to use buyout");
return;
}
int listingId = in.readInt();
AuctionListing listing = AuctionController.Instance.getListing(listingId);
if (listing == null) {
sendResponse(player, false, "Listing not found");
return;
}
if (!listing.isActive()) {
sendResponse(player, false, "This auction has ended");
return;
}
if (listing.buyoutPrice <= 0) {
sendResponse(player, false, "This listing has no buyout option");
return;
}
if (!CurrencyController.Instance.canAfford(player, listing.buyoutPrice)) {
sendResponse(player, false, "You cannot afford the buyout price");
return;
}
if (AuctionController.Instance.buyout(listingId, player)) {
sendResponse(player, true, "Buyout successful! Claim your item.");
} else {
sendResponse(player, false, "Failed to execute buyout");
}
}
private void handleCancelListing(ByteBuf in, EntityPlayerMP player) throws IOException {
int listingId = in.readInt();
AuctionListing listing = AuctionController.Instance.getListing(listingId);
if (listing == null) {
sendResponse(player, false, "Listing not found");
return;
}
// Admin can cancel any listing
boolean isAdmin = CustomNpcsPermissions.hasPermission(player, CustomNpcsPermissions.AUCTION_ADMIN);
if (!listing.sellerUUID.equals(player.getUniqueID()) && !isAdmin) {
sendResponse(player, false, "You can only cancel your own listings");
return;
}
if (listing.hasBids() && !isAdmin) {
sendResponse(player, false, "Cannot cancel listing with active bids");
return;
}
if (AuctionController.Instance.cancelListing(listingId, player, isAdmin)) {
sendResponse(player, true, "Listing cancelled. Claim your item.");
} else {
sendResponse(player, false, "Failed to cancel listing");
}
}
private void handleClaimItem(ByteBuf in, EntityPlayerMP player) throws IOException {
int listingId = in.readInt();
AuctionListing listing = AuctionController.Instance.getListing(listingId);
if (listing == null) {
sendResponse(player, false, "Listing not found");
return;
}
ItemStack claimed = null;
// Try buyer claim first
if (listing.highBidderUUID != null && listing.highBidderUUID.equals(player.getUniqueID())) {
claimed = AuctionController.Instance.claimBuyerItem(listingId, player);
}
// Then try seller reclaim (for expired/cancelled)
else if (listing.sellerUUID.equals(player.getUniqueID())) {
claimed = AuctionController.Instance.claimExpiredItem(listingId, player);
}
if (claimed != null) {
// Give item to player
if (!player.inventory.addItemStackToInventory(claimed)) {
// Drop if inventory full
player.entityDropItem(claimed, 0.5f);
}
sendResponse(player, true, "Item claimed");
} else {
sendResponse(player, false, "Cannot claim item");
}
}
private void handleClaimProceeds(ByteBuf in, EntityPlayerMP player) throws IOException {
int listingId = in.readInt();
AuctionListing listing = AuctionController.Instance.getListing(listingId);
if (listing == null) {
sendResponse(player, false, "Listing not found");
return;
}
if (AuctionController.Instance.claimSellerProceeds(listingId, player)) {
long proceeds = listing.getSellerProceeds();
sendResponse(player, true, "Claimed " + proceeds + " " + ConfigMarket.CurrencyName);
} else {
sendResponse(player, false, "Cannot claim proceeds");
}
}
// ==================== Query Handlers ====================
private void handleQueryListings(ByteBuf in, EntityPlayerMP player) throws IOException {
// Check permission
if (!CustomNpcsPermissions.hasPermission(player, CustomNpcsPermissions.AUCTION_USE)) {
sendResponse(player, false, "You don't have permission to view auctions");
return;
}
int filterBytesLength = in.readInt();
byte[] filterBytes = new byte[filterBytesLength];
in.readBytes(filterBytes);
String filterJson = new String(filterBytes, "UTF-8");
try {
NBTTagCompound filterNBT = NBTJsonUtil.Convert(filterJson);
AuctionFilter filter = new AuctionFilter();
filter.readFromNBT(filterNBT);
// Send filtered listings to client
AuctionDataPacket.sendFilteredListings(player, filter);
} catch (Exception e) {
sendResponse(player, false, "Error parsing filter");
}
}
private void handleQueryMyListings(EntityPlayerMP player) {
// Check permission
if (!CustomNpcsPermissions.hasPermission(player, CustomNpcsPermissions.AUCTION_USE)) {
sendResponse(player, false, "You don't have permission to view auctions");
return;
}
AuctionDataPacket.sendMyListings(player);
}
private void handleQueryMyBids(EntityPlayerMP player) {
// Check permission
if (!CustomNpcsPermissions.hasPermission(player, CustomNpcsPermissions.AUCTION_USE)) {
sendResponse(player, false, "You don't have permission to view auctions");
return;
}
AuctionDataPacket.sendMyBids(player);
}
private void handleQueryClaimable(EntityPlayerMP player) {
// Check permission
if (!CustomNpcsPermissions.hasPermission(player, CustomNpcsPermissions.AUCTION_USE)) {
sendResponse(player, false, "You don't have permission to view auctions");
return;
}
AuctionDataPacket.sendClaimable(player);
}
/**
* Send a response message to the player
*/
private void sendResponse(EntityPlayerMP player, boolean success, String message) {
// Use chat message for now; can be extended to use GUI updates
if (message != null && !message.isEmpty()) {
player.addChatMessage(new ChatComponentText("[Auction] " + message));
}
}
private enum Action {
CreateListing,
PlaceBid,
Buyout,
CancelListing,
ClaimItem,
ClaimProceeds,
QueryListings,
QueryMyListings,
QueryMyBids,
QueryClaimable
}
}
@@ -15,6 +15,7 @@ import noppes.npcs.api.IWorld;
import noppes.npcs.blocks.tiles.TileNpcContainer;
import noppes.npcs.constants.EnumGuiType;
import noppes.npcs.containers.ContainerAnvilRepair;
import noppes.npcs.containers.ContainerAuction;
import noppes.npcs.containers.ContainerCarpentryBench;
import noppes.npcs.containers.ContainerCrate;
import noppes.npcs.containers.ContainerCustomGui;
@@ -131,6 +132,9 @@ public class CommonProxy implements IGuiHandler {
if (gui == EnumGuiType.CompanionInv)
return new ContainerNPCCompanion(npc, player);
if (gui == EnumGuiType.PlayerAuction)
return new ContainerAuction(npc, player);
return null;
}
@@ -59,6 +59,10 @@ import noppes.npcs.controllers.GlobalDataController;
import noppes.npcs.controllers.LinkedItemController;
import noppes.npcs.controllers.LinkedNpcController;
import noppes.npcs.controllers.MagicController;
import noppes.npcs.controllers.VaultHelper;
import noppes.npcs.controllers.CurrencyController;
import noppes.npcs.controllers.AuctionBlacklist;
import noppes.npcs.controllers.AuctionController;
import noppes.npcs.controllers.PlayerDataController;
import noppes.npcs.controllers.QuestController;
import noppes.npcs.controllers.RecipeController;
@@ -310,6 +314,10 @@ public class CustomNpcs {
//Loading items in the about to start event was corrupting items with a damage value
@EventHandler
public void started(FMLServerStartedEvent event) {
new VaultHelper();
new CurrencyController();
new AuctionBlacklist();
new AuctionController();
RecipeController.Instance.load();
new BankController();
DialogController.Instance.load();
@@ -92,6 +92,13 @@ public class CustomNpcsPermissions {
public static final Permission SOULSTONE_ALL = new Permission("customnpcs.soulstone.all");
// Auction System
public static final Permission AUCTION_USE = new Permission("customnpcs.auction.use");
public static final Permission AUCTION_LIST = new Permission("customnpcs.auction.list");
public static final Permission AUCTION_BID = new Permission("customnpcs.auction.bid");
public static final Permission AUCTION_BUYOUT = new Permission("customnpcs.auction.buyout");
public static final Permission AUCTION_ADMIN = new Permission("customnpcs.auction.admin");
// Modify / Save Scripts
public static final Permission SCRIPT = new Permission("customnpcs.script");
public static final Permission SCRIPT_NPC = new Permission("customnpcs.script.npc");
@@ -18,6 +18,7 @@ import noppes.npcs.roles.JobGuard;
import noppes.npcs.roles.JobHealer;
import noppes.npcs.roles.JobItemGiver;
import noppes.npcs.roles.JobSpawner;
import noppes.npcs.roles.RoleAuctioneer;
import noppes.npcs.roles.RoleBank;
import noppes.npcs.roles.RoleCompanion;
import noppes.npcs.roles.RoleFollower;
@@ -218,6 +219,8 @@ public class DataAdvanced {
npc.roleInterface = new RoleCompanion(npc);
else if (role == EnumRoleType.Mount && !(npc.roleInterface instanceof RoleMount))
npc.roleInterface = new RoleMount(npc);
else if (role == EnumRoleType.Auctioneer && !(npc.roleInterface instanceof RoleAuctioneer))
npc.roleInterface = new RoleAuctioneer(npc);
}
public void setJob(int i) {
@@ -10,6 +10,7 @@ import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
import net.minecraft.world.WorldServer;
import noppes.npcs.client.AnalyticsTracking;
import noppes.npcs.controllers.AuctionController;
import noppes.npcs.controllers.data.PlayerData;
import noppes.npcs.entity.EntityNPCInterface;
import noppes.npcs.controllers.data.action.ActionManager;
@@ -65,6 +66,11 @@ public class ServerTickHandler {
ProfileController.Instance.login(player);
SyncController.beginLogin(player);
SyncController.syncEffects(player);
// Send pending auction notifications
if (AuctionController.Instance != null) {
AuctionController.Instance.onPlayerLogin(player);
}
}
@SubscribeEvent
@@ -104,6 +104,7 @@ import noppes.npcs.client.gui.player.GuiCrate;
import noppes.npcs.client.gui.player.GuiMailbox;
import noppes.npcs.client.gui.player.GuiMailmanWrite;
import noppes.npcs.client.gui.player.GuiNPCBankChest;
import noppes.npcs.client.gui.player.GuiAuction;
import noppes.npcs.client.gui.player.GuiNPCTrader;
import noppes.npcs.client.gui.player.GuiNpcAnvil;
import noppes.npcs.client.gui.player.GuiNpcCarpentryBench;
@@ -179,6 +180,7 @@ import noppes.npcs.config.ConfigMain;
import noppes.npcs.config.StringCache;
import noppes.npcs.constants.EnumGuiType;
import noppes.npcs.containers.ContainerAnvilRepair;
import noppes.npcs.containers.ContainerAuction;
import noppes.npcs.containers.ContainerCarpentryBench;
import noppes.npcs.containers.ContainerCrate;
import noppes.npcs.containers.ContainerCustomGui;
@@ -574,6 +576,9 @@ public class ClientProxy extends CommonProxy {
else if (gui == EnumGuiType.MagicBook)
return new GuiNpcMagicBook();
else if (gui == EnumGuiType.PlayerAuction)
return new GuiAuction(npc, (ContainerAuction) container);
else if (gui == EnumGuiType.GlobalRemote)
return new GuiNPCGlobalMainMenu(null);
@@ -182,6 +182,67 @@ public class NoppesUtil {
data = new HashMap<String, Integer>();
}
// ==================== Auction Data ====================
// Static storage for auction data that the GUI can access
private static NBTTagCompound auctionListingData;
private static int auctionDataType;
private static int auctionTotalResults;
private static int auctionCurrentPage;
private static int auctionTotalPages;
private static long auctionPlayerBalance;
public static void setAuctionData(int dataType, NBTTagCompound compound,
int totalResults, int currentPage, int totalPages,
long playerBalance) {
auctionDataType = dataType;
auctionListingData = compound;
auctionTotalResults = totalResults;
auctionCurrentPage = currentPage;
auctionTotalPages = totalPages;
auctionPlayerBalance = playerBalance;
// Notify the current GUI if it's an auction GUI
GuiScreen gui = Minecraft.getMinecraft().currentScreen;
if (gui instanceof IAuctionData) {
((IAuctionData) gui).onAuctionDataReceived(dataType, compound,
totalResults, currentPage, totalPages, playerBalance);
}
}
public static NBTTagCompound getAuctionListingData() {
return auctionListingData;
}
public static int getAuctionDataType() {
return auctionDataType;
}
public static int getAuctionTotalResults() {
return auctionTotalResults;
}
public static int getAuctionCurrentPage() {
return auctionCurrentPage;
}
public static int getAuctionTotalPages() {
return auctionTotalPages;
}
public static long getAuctionPlayerBalance() {
return auctionPlayerBalance;
}
/**
* Interface for GUIs that receive auction data
*/
public interface IAuctionData {
void onAuctionDataReceived(int dataType, NBTTagCompound data,
int totalResults, int currentPage, int totalPages,
long playerBalance);
}
public static void guiQuestCompletion(EntityPlayer player, NBTTagCompound read) {
Quest quest = new Quest();
quest.readNBT(read);
@@ -26,6 +26,7 @@ import noppes.npcs.client.gui.roles.GuiNpcFollowerJob;
import noppes.npcs.client.gui.roles.GuiNpcGuard;
import noppes.npcs.client.gui.roles.GuiNpcHealer;
import noppes.npcs.client.gui.roles.GuiNpcSpawner;
import noppes.npcs.client.gui.roles.GuiNpcAuctioneer;
import noppes.npcs.client.gui.roles.GuiNpcMount;
import noppes.npcs.client.gui.roles.GuiNpcTransporter;
import noppes.npcs.client.gui.util.GuiNPCInterface2;
@@ -49,7 +50,7 @@ public class GuiNpcAdvanced extends GuiNPCInterface2 implements IGuiData {
super.initGui();
int y = guiTop + 10;
this.addButton(new GuiNpcButton(3, guiLeft + 85 + 160, y, 52, 20, "selectServer.edit"));
this.addButton(new GuiNpcButton(8, guiLeft + 85, y, 155, 20, new String[]{"role.none", "role.trader", "role.follower", "role.bank", "role.transporter", "role.mailman", NoppesStringUtils.translate("role.companion", "(WIP)"), "role.mount"}, npc.advanced.role.ordinal()));
this.addButton(new GuiNpcButton(8, guiLeft + 85, y, 155, 20, new String[]{"role.none", "role.trader", "role.follower", "role.bank", "role.transporter", "role.mailman", NoppesStringUtils.translate("role.companion", "(WIP)"), "role.mount", "role.auctioneer"}, npc.advanced.role.ordinal()));
getButton(3).setEnabled(npc.advanced.role != EnumRoleType.None && npc.advanced.role != EnumRoleType.Postman);
this.addButton(new GuiNpcButton(4, guiLeft + 85 + 160, y += 22, 52, 20, "selectServer.edit"));
@@ -157,6 +158,8 @@ public class GuiNpcAdvanced extends GuiNPCInterface2 implements IGuiData {
displayGuiScreen(new GuiNpcCompanion(npc));
else if (npc.advanced.role == EnumRoleType.Mount)
displayGuiScreen(new GuiNpcMount(npc));
else if (npc.advanced.role == EnumRoleType.Auctioneer)
displayGuiScreen(new GuiNpcAuctioneer(npc));
} else if (compound.hasKey("JobData")) {
if (npc.jobInterface != null)
npc.jobInterface.readFromNBT(compound);
@@ -0,0 +1,841 @@
package noppes.npcs.client.gui.player;
import kamkeel.npcs.network.packets.player.AuctionActionPacket;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.inventory.Slot;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.StatCollector;
import noppes.npcs.client.CustomNpcResourceListener;
import noppes.npcs.client.NoppesUtil;
import noppes.npcs.client.gui.util.*;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.containers.ContainerAuction;
import noppes.npcs.constants.EnumAuctionDuration;
import noppes.npcs.constants.EnumAuctionStatus;
import noppes.npcs.controllers.data.AuctionFilter;
import noppes.npcs.controllers.data.AuctionListing;
import noppes.npcs.entity.EntityNPCInterface;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* Main auction house browse GUI.
* Displays listings with search, sort, and pagination.
*/
public class GuiAuction extends GuiContainerNPCInterface implements IGuiData,
ICustomScrollListener, NoppesUtil.IAuctionData {
private static final ResourceLocation BG_TEXTURE = new ResourceLocation("customnpcs", "textures/gui/standardbg.png");
private static final int LEFT_PANEL_X = 8;
private static final int LEFT_PANEL_WIDTH = 190;
private static final int RIGHT_PANEL_X = 210;
private static final int ACTION_BUTTON_WIDTH = 98;
private static final int LISTING_SCROLL_HEIGHT = 100;
private static final int LISTING_SCROLL_WIDTH = 190;
private static final int PAGE_BUTTON_WIDTH = 60;
private static final int SEARCH_FIELD_WIDTH = 140;
private static final int SEARCH_BUTTON_WIDTH = 46;
private static final int HIDDEN_SLOT_POSITION = -1000;
private static final int INVENTORY_START_X = 8;
private static final int INVENTORY_START_Y = 166;
private static final int HOTBAR_Y_OFFSET = 58;
// GUI Components
private GuiNpcTextField searchField;
private GuiNpcTextField startingPriceField;
private GuiNpcTextField buyoutPriceField;
private GuiCustomScroll listingScroll;
// Current state
private AuctionFilter currentFilter = new AuctionFilter();
private List<AuctionListing> listings = new ArrayList<>();
private int totalResults = 0;
private int currentPage = 0;
private int totalPages = 0;
private long playerBalance = 0;
// Tab state (0=Browse, 1=My Listings, 2=My Bids, 3=Claims, 4=Create)
private int currentTab = 0;
private int selectedDuration = 1;
// Selected listing for details
private int selectedListingIndex = -1;
// Countdown update timer
private long lastCountdownUpdate = 0;
private enum ActionMode {
BID,
CANCEL,
CLAIM
}
public GuiAuction(EntityNPCInterface npc, ContainerAuction container) {
super(npc, container);
this.title = "";
this.xSize = 319;
this.ySize = 238;
this.closeOnEsc = true;
this.drawDefaultBackground = true;
// Request initial data
AuctionActionPacket.QueryListings(currentFilter);
}
@Override
public void initGui() {
super.initGui();
int leftX = guiLeft + LEFT_PANEL_X;
int rightX = guiLeft + RIGHT_PANEL_X;
int actionY = guiTop + 44;
boolean isCreateTab = currentTab == 4;
boolean isBrowseTab = currentTab == 0;
updateListingSlotPosition(isCreateTab);
// Tab buttons at top
GuiMenuTopButton browseButton = new GuiMenuTopButton(0, guiLeft + 4, guiTop - 17, StatCollector.translateToLocal("auction.browse"));
addTopButton(browseButton);
GuiMenuTopButton myListingsButton = new GuiMenuTopButton(1, browseButton, StatCollector.translateToLocal("auction.myListings"));
addTopButton(myListingsButton);
GuiMenuTopButton myBidsButton = new GuiMenuTopButton(2, myListingsButton, StatCollector.translateToLocal("auction.myBids"));
addTopButton(myBidsButton);
GuiMenuTopButton claimsButton = new GuiMenuTopButton(3, myBidsButton, StatCollector.translateToLocal("auction.claims"));
addTopButton(claimsButton);
GuiMenuTopButton sellButton = new GuiMenuTopButton(4, claimsButton, StatCollector.translateToLocal("auction.sell"));
addTopButton(sellButton);
getTopButton(currentTab).setEnabled(false);
if (isCreateTab) {
addCreateControls(leftX, rightX);
} else {
if (isBrowseTab) {
// Search field
searchField = new GuiNpcTextField(10, this, leftX, guiTop + 6, SEARCH_FIELD_WIDTH, 14, currentFilter.searchText);
searchField.setMaxStringLength(50);
addTextField(searchField);
// Search button
addButton(new GuiNpcButton(11, leftX + SEARCH_FIELD_WIDTH + 4, guiTop + 5, SEARCH_BUTTON_WIDTH, 16,
StatCollector.translateToLocal("auction.search")));
// Sort button
addButton(new GuiNpcButton(30, leftX, guiTop + 24, LEFT_PANEL_WIDTH, 16, currentFilter.sortOrder.getDisplayName()));
}
// Listing scroll area
listingScroll = new GuiCustomScroll(this, 0);
listingScroll.guiLeft = leftX;
listingScroll.guiTop = guiTop + 44;
listingScroll.setSize(LISTING_SCROLL_WIDTH, LISTING_SCROLL_HEIGHT);
addScroll(listingScroll);
updateListingDisplay();
if (isBrowseTab) {
// Pagination buttons
addButton(new GuiNpcButton(40, leftX, guiTop + 148, PAGE_BUTTON_WIDTH, 16,
StatCollector.translateToLocal("auction.prevPage")));
addLabel(new GuiNpcLabel(41, getPageLabel(), leftX + 70, guiTop + 152, CustomNpcResourceListener.DefaultTextColor));
addButton(new GuiNpcButton(42, leftX + LEFT_PANEL_WIDTH - PAGE_BUTTON_WIDTH, guiTop + 148, PAGE_BUTTON_WIDTH, 16,
StatCollector.translateToLocal("auction.nextPage")));
}
// Action buttons (right side)
addActionButtons(rightX, actionY);
// Balance display
addLabel(new GuiNpcLabel(60, String.format(StatCollector.translateToLocal("auction.balance"), formatCurrency(playerBalance)),
rightX, guiTop + 170, 0x00AA00));
}
updateButtonStates();
}
@Override
public void updateScreen() {
super.updateScreen();
// Update countdowns every second
long now = System.currentTimeMillis();
if (now - lastCountdownUpdate >= 1000) {
lastCountdownUpdate = now;
updateListingDisplay();
}
if (currentTab == 4 && inventorySlots instanceof ContainerAuction) {
ItemStack item = ((ContainerAuction) inventorySlots).getListingItem();
GuiNpcLabel itemLabel = getLabel(102);
GuiNpcButton createButton = getButton(71);
if (item != null) {
if (itemLabel != null) {
itemLabel.label = StatCollector.translateToLocal("auction.item") + " " + item.getDisplayName();
itemLabel.color = 0x008800;
}
if (createButton != null) {
createButton.setEnabled(true);
}
} else {
if (itemLabel != null) {
itemLabel.label = StatCollector.translateToLocal("auction.noItemSelected");
itemLabel.color = 0x888888;
}
if (createButton != null) {
createButton.setEnabled(false);
}
}
}
}
@Override
public void actionPerformed(GuiButton button) {
super.actionPerformed(button);
int id = button.id;
// Tab buttons
if (id >= 0 && id <= 4) {
switchTab(id);
}
// Search button
else if (id == 11) {
if (currentTab == 0) {
performSearch();
}
}
// Sort button
else if (id == 30) {
if (currentTab == 0) {
cycleSortOrder();
}
}
// Pagination
else if (id == 40) {
if (currentTab == 0) {
previousPage();
}
} else if (id == 42) {
if (currentTab == 0) {
nextPage();
}
}
// Actions
else if (id == 50) {
viewDetails();
} else if (id == 51) {
ActionMode mode = getActionMode();
if (mode == ActionMode.BID) {
placeBid();
} else if (mode == ActionMode.CANCEL) {
cancelListing();
} else if (mode == ActionMode.CLAIM) {
claimListing();
}
} else if (id == 52) {
if (getActionMode() == ActionMode.BID) {
buyout();
}
} else if (id == 53) {
refresh();
} else if (id == 70) {
selectedDuration = (selectedDuration + 1) % EnumAuctionDuration.values().length;
initGui();
} else if (id == 71) {
createListing();
} else if (id == 72) {
switchTab(0);
}
}
private void switchTab(int tab) {
currentTab = tab;
currentPage = 0;
selectedListingIndex = -1;
switch (tab) {
case 0: // Browse
AuctionActionPacket.QueryListings(currentFilter);
break;
case 1: // My Listings
AuctionActionPacket.QueryMyListings();
break;
case 2: // My Bids
AuctionActionPacket.QueryMyBids();
break;
case 3: // Claims
AuctionActionPacket.QueryClaimable();
break;
case 4:
break;
}
initGui();
}
private void performSearch() {
currentFilter.searchText = searchField.getText();
currentFilter.page = 0;
currentPage = 0;
AuctionActionPacket.QueryListings(currentFilter);
}
private void cycleSortOrder() {
currentFilter.sortOrder = currentFilter.sortOrder.next();
currentFilter.page = 0;
currentPage = 0;
AuctionActionPacket.QueryListings(currentFilter);
initGui();
}
private void previousPage() {
if (currentPage > 0) {
currentPage--;
currentFilter.page = currentPage;
AuctionActionPacket.QueryListings(currentFilter);
}
}
private void nextPage() {
if (currentPage < totalPages - 1) {
currentPage++;
currentFilter.page = currentPage;
AuctionActionPacket.QueryListings(currentFilter);
}
}
private void viewDetails() {
if (selectedListingIndex >= 0 && selectedListingIndex < listings.size()) {
AuctionListing listing = listings.get(selectedListingIndex);
if (listing.item == null) {
return;
}
setSubGui(new SubGuiAuctionDetails(this, listing));
}
}
private void placeBid() {
if (selectedListingIndex >= 0 && selectedListingIndex < listings.size()) {
AuctionListing listing = listings.get(selectedListingIndex);
if (listing.item == null) {
return;
}
setSubGui(new SubGuiAuctionBid(this, listing, playerBalance));
}
}
private void buyout() {
if (selectedListingIndex >= 0 && selectedListingIndex < listings.size()) {
AuctionListing listing = listings.get(selectedListingIndex);
if (listing.buyoutPrice > 0 && playerBalance >= listing.buyoutPrice) {
AuctionActionPacket.Buyout(listing.id);
refresh();
}
}
}
private void refresh() {
switch (currentTab) {
case 0:
AuctionActionPacket.QueryListings(currentFilter);
break;
case 1:
AuctionActionPacket.QueryMyListings();
break;
case 2:
AuctionActionPacket.QueryMyBids();
break;
case 3:
AuctionActionPacket.QueryClaimable();
break;
}
}
private void updateListingDisplay() {
if (listingScroll == null) return;
List<String> displayList = new ArrayList<>();
for (AuctionListing listing : listings) {
String line = formatListingLine(listing);
displayList.add(line);
}
listingScroll.setList(displayList, true, false);
if (selectedListingIndex >= 0 && selectedListingIndex < displayList.size()) {
listingScroll.selected = selectedListingIndex;
} else {
selectedListingIndex = -1;
listingScroll.selected = -1;
}
}
private String formatListingLine(AuctionListing listing) {
String itemName = listing.item == null
? "Unknown"
: listing.item.getDisplayName();
if (itemName.length() > 15) {
itemName = itemName.substring(0, 12) + "...";
}
long price = listing.currentBid > 0 ? listing.currentBid : listing.startingPrice;
String priceStr = formatCurrency(price);
String timeStr = formatTimeRemaining(listing.getTimeRemaining());
return String.format("%s - %s (%s)", itemName, priceStr, timeStr);
}
private String formatTimeRemaining(long millis) {
if (millis <= 0) return StatCollector.translateToLocal("auction.ended");
long seconds = millis / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;
if (days > 0) {
return days + "d " + (hours % 24) + "h";
} else if (hours > 0) {
return hours + "h " + (minutes % 60) + "m";
} else if (minutes > 0) {
return minutes + "m " + (seconds % 60) + "s";
} else {
return seconds + "s";
}
}
private String formatCurrency(long amount) {
if (amount >= 1000000) {
return String.format("%.1fM", amount / 1000000.0);
} else if (amount >= 1000) {
return String.format("%.1fK", amount / 1000.0);
}
return String.valueOf(amount);
}
private String getPageLabel() {
if (totalPages == 0) {
return StatCollector.translateToLocal("auction.noResults");
}
return String.format(StatCollector.translateToLocal("auction.page"), currentPage + 1, totalPages);
}
private void updateButtonStates() {
ActionMode mode = getActionMode();
AuctionListing listing = getSelectedListing();
boolean hasSelection = listing != null;
// Pagination buttons
if (getButton(40) != null) getButton(40).setEnabled(currentPage > 0);
if (getButton(42) != null) getButton(42).setEnabled(currentPage < totalPages - 1);
// Action buttons based on selection
if (getButton(50) != null) getButton(50).setEnabled(hasSelection);
if (getButton(51) != null) {
if (!hasSelection) {
getButton(51).setEnabled(false);
} else if (mode == ActionMode.BID) {
getButton(51).setEnabled(canPlaceBid(listing));
} else if (mode == ActionMode.CANCEL) {
getButton(51).setEnabled(canCancelListing(listing));
} else {
getButton(51).setEnabled(getClaimAction(listing) != ClaimAction.NONE);
}
}
if (getButton(52) != null) {
if (!hasSelection || mode != ActionMode.BID) {
getButton(52).setEnabled(false);
} else {
getButton(52).setEnabled(canBuyout(listing));
}
}
}
private void updateListingSlotPosition(boolean showInventory) {
if (!(inventorySlots instanceof ContainerAuction)) {
return;
}
ContainerAuction container = (ContainerAuction) inventorySlots;
if (showInventory) {
container.listingSlot.xDisplayPosition = RIGHT_PANEL_X + 41;
container.listingSlot.yDisplayPosition = 64;
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 9; col++) {
int slotIndex = 1 + col + row * 9;
Slot slot = (Slot) container.inventorySlots.get(slotIndex);
slot.xDisplayPosition = INVENTORY_START_X + col * 18;
slot.yDisplayPosition = INVENTORY_START_Y + row * 18;
}
}
for (int col = 0; col < 9; col++) {
int slotIndex = 28 + col;
Slot slot = (Slot) container.inventorySlots.get(slotIndex);
slot.xDisplayPosition = INVENTORY_START_X + col * 18;
slot.yDisplayPosition = INVENTORY_START_Y + HOTBAR_Y_OFFSET;
}
} else {
container.listingSlot.xDisplayPosition = HIDDEN_SLOT_POSITION;
container.listingSlot.yDisplayPosition = HIDDEN_SLOT_POSITION;
for (int slotIndex = 1; slotIndex < container.inventorySlots.size(); slotIndex++) {
Slot slot = (Slot) container.inventorySlots.get(slotIndex);
slot.xDisplayPosition = HIDDEN_SLOT_POSITION;
slot.yDisplayPosition = HIDDEN_SLOT_POSITION;
}
}
}
private void addCreateControls(int leftX, int rightX) {
addLabel(new GuiNpcLabel(100, StatCollector.translateToLocal("auction.createListing"), leftX, guiTop + 8, 0x404040));
addLabel(new GuiNpcLabel(101, StatCollector.translateToLocal("auction.placeItemBelow"), rightX, guiTop + 32, 0x404040));
ItemStack item = ((ContainerAuction) inventorySlots).getListingItem();
if (item != null) {
addLabel(new GuiNpcLabel(102, StatCollector.translateToLocal("auction.item") + " " + item.getDisplayName(),
rightX, guiTop + 86, 0x008800));
} else {
addLabel(new GuiNpcLabel(102, StatCollector.translateToLocal("auction.noItemSelected"), rightX, guiTop + 86, 0x888888));
}
addLabel(new GuiNpcLabel(110, StatCollector.translateToLocal("auction.startingPrice"), leftX, guiTop + 36, 0x404040));
startingPriceField = new GuiNpcTextField(111, this, leftX + 120, guiTop + 34, 90, 14, "100");
startingPriceField.setIntegersOnly();
startingPriceField.setMinMaxDefault(1, 999999999, 100);
addTextField(startingPriceField);
addLabel(new GuiNpcLabel(120, StatCollector.translateToLocal("auction.buyoutPrice"), leftX, guiTop + 58, 0x404040));
buyoutPriceField = new GuiNpcTextField(121, this, leftX + 120, guiTop + 56, 90, 14, "0");
buyoutPriceField.setIntegersOnly();
buyoutPriceField.setMinMaxDefault(0, 999999999, 0);
addTextField(buyoutPriceField);
addLabel(new GuiNpcLabel(122, StatCollector.translateToLocal("auction.noBuyoutHint"), leftX + 214, guiTop + 58, 0x888888));
addLabel(new GuiNpcLabel(130, StatCollector.translateToLocal("auction.duration"), leftX, guiTop + 80, 0x404040));
addButton(new GuiNpcButton(70, leftX + 120, guiTop + 76, 110, 20, getDurationDisplay()));
long fee = getListingFee();
addLabel(new GuiNpcLabel(140, StatCollector.translateToLocal("auction.listingFee") + " " + fee + " " + ConfigMarket.CurrencyName,
leftX, guiTop + 104, fee > 0 ? 0xAA0000 : 0x008800));
addButton(new GuiNpcButton(71, leftX, guiTop + 126, 90, 20, StatCollector.translateToLocal("auction.create")));
addButton(new GuiNpcButton(72, leftX + 100, guiTop + 126, 90, 20, StatCollector.translateToLocal("gui.cancel")));
if (getButton(71) != null) {
getButton(71).setEnabled(item != null);
}
}
private String getDurationDisplay() {
EnumAuctionDuration duration = EnumAuctionDuration.values()[selectedDuration];
return duration.getDisplayName();
}
private long getListingFee() {
EnumAuctionDuration duration = EnumAuctionDuration.values()[selectedDuration];
return duration.getListingFee();
}
private void createListing() {
ContainerAuction container = (ContainerAuction) inventorySlots;
ItemStack item = container.getListingItem();
if (item == null) {
return;
}
long startingPrice = parsePrice(startingPriceField, 1);
long buyoutPrice = parsePrice(buyoutPriceField, 0);
if (startingPrice < 1) {
startingPrice = 1;
}
if (buyoutPrice > 0 && buyoutPrice < startingPrice) {
return;
}
EnumAuctionDuration duration = EnumAuctionDuration.values()[selectedDuration];
AuctionActionPacket.CreateListing(item, startingPrice, buyoutPrice, duration);
container.clearListingSlot();
switchTab(0);
}
private void cancelListing() {
AuctionListing listing = getSelectedListing();
if (!canCancelListing(listing)) {
return;
}
AuctionActionPacket.CancelListing(listing.id);
refresh();
}
private void claimListing() {
AuctionListing listing = getSelectedListing();
if (listing == null) {
return;
}
ClaimAction action = getClaimAction(listing);
if (action == ClaimAction.ITEM) {
AuctionActionPacket.ClaimItem(listing.id);
} else if (action == ClaimAction.PROCEEDS) {
AuctionActionPacket.ClaimProceeds(listing.id);
} else {
return;
}
refresh();
}
private ActionMode getActionMode() {
if (currentTab == 1) {
return ActionMode.CANCEL;
}
if (currentTab == 3) {
return ActionMode.CLAIM;
}
return ActionMode.BID;
}
private String getPrimaryActionLabel(ActionMode mode) {
if (mode == ActionMode.CANCEL) {
return StatCollector.translateToLocal("auction.cancel");
}
if (mode == ActionMode.CLAIM) {
return StatCollector.translateToLocal("auction.claim");
}
return StatCollector.translateToLocal("auction.placeBid");
}
private void addActionButtons(int rightX, int actionY) {
ActionMode mode = getActionMode();
addButton(new GuiNpcButton(50, rightX, actionY, ACTION_BUTTON_WIDTH, 20,
StatCollector.translateToLocal("auction.viewDetails")));
addButton(new GuiNpcButton(51, rightX, actionY + 24, ACTION_BUTTON_WIDTH, 20,
getPrimaryActionLabel(mode)));
if (mode == ActionMode.BID) {
addButton(new GuiNpcButton(52, rightX, actionY + 48, ACTION_BUTTON_WIDTH, 20,
StatCollector.translateToLocal("auction.buyout")));
addButton(new GuiNpcButton(53, rightX, actionY + 72, ACTION_BUTTON_WIDTH, 20,
StatCollector.translateToLocal("auction.refresh")));
} else {
addButton(new GuiNpcButton(53, rightX, actionY + 48, ACTION_BUTTON_WIDTH, 20,
StatCollector.translateToLocal("auction.refresh")));
}
}
private AuctionListing getSelectedListing() {
if (selectedListingIndex < 0 || selectedListingIndex >= listings.size()) {
return null;
}
AuctionListing listing = listings.get(selectedListingIndex);
if (listing == null || listing.item == null) {
return null;
}
return listing;
}
private boolean canPlaceBid(AuctionListing listing) {
if (listing == null || !listing.isActive()) {
return false;
}
if (isPlayerSeller(listing)) {
return false;
}
return playerBalance >= listing.getMinimumBid();
}
private boolean canBuyout(AuctionListing listing) {
if (listing == null || !listing.isActive()) {
return false;
}
if (listing.buyoutPrice <= 0) {
return false;
}
if (isPlayerSeller(listing)) {
return false;
}
return playerBalance >= listing.buyoutPrice;
}
private boolean canCancelListing(AuctionListing listing) {
if (listing == null || listing.item == null) {
return false;
}
return listing.status == EnumAuctionStatus.ACTIVE && !listing.hasBids();
}
private boolean isPlayerSeller(AuctionListing listing) {
if (mc == null || mc.thePlayer == null || listing == null || listing.sellerUUID == null) {
return false;
}
UUID playerId = mc.thePlayer.getUniqueID();
return listing.sellerUUID.equals(playerId);
}
private enum ClaimAction {
ITEM,
PROCEEDS,
NONE
}
private ClaimAction getClaimAction(AuctionListing listing) {
if (listing == null || mc == null || mc.thePlayer == null) {
return ClaimAction.NONE;
}
UUID playerId = mc.thePlayer.getUniqueID();
if (listing.sellerUUID != null && listing.sellerUUID.equals(playerId) && !listing.sellerClaimed) {
if (listing.status == EnumAuctionStatus.SOLD) {
return ClaimAction.PROCEEDS;
}
if (listing.status == EnumAuctionStatus.CANCELLED || listing.status == EnumAuctionStatus.EXPIRED) {
return ClaimAction.ITEM;
}
}
if (listing.highBidderUUID != null && listing.highBidderUUID.equals(playerId)
&& listing.status == EnumAuctionStatus.SOLD && !listing.buyerClaimed) {
return ClaimAction.ITEM;
}
return ClaimAction.NONE;
}
private long parsePrice(GuiNpcTextField field, long defaultValue) {
if (field == null) {
return defaultValue;
}
try {
return Long.parseLong(field.getText());
} catch (NumberFormatException e) {
return defaultValue;
}
}
@Override
protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
drawDefaultBackground();
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
// Draw background
mc.renderEngine.bindTexture(BG_TEXTURE);
drawTexturedModalRect(guiLeft, guiTop, 0, 0, 252, ySize);
drawTexturedModalRect(guiLeft + 252, guiTop, 188, 0, xSize - 252, ySize);
// Draw selected item preview
if (selectedListingIndex >= 0 && selectedListingIndex < listings.size()) {
AuctionListing listing = listings.get(selectedListingIndex);
drawItemPreview(listing, guiLeft + RIGHT_PANEL_X + 41, guiTop + 192);
}
super.drawGuiContainerBackgroundLayer(partialTicks, mouseX, mouseY);
}
private void drawItemPreview(AuctionListing listing, int x, int y) {
if (listing == null || listing.item == null) return;
RenderHelper.enableGUIStandardItemLighting();
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
GL11.glEnable(GL11.GL_COLOR_MATERIAL);
GL11.glEnable(GL11.GL_LIGHTING);
itemRender.renderItemAndEffectIntoGUI(fontRendererObj, mc.renderEngine, listing.item, x, y);
itemRender.renderItemOverlayIntoGUI(fontRendererObj, mc.renderEngine, listing.item, x, y);
RenderHelper.disableStandardItemLighting();
}
@Override
protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
// Title
String titleText = getTabTitle();
fontRendererObj.drawString(titleText, (xSize - fontRendererObj.getStringWidth(titleText)) / 2, -8,
CustomNpcResourceListener.DefaultTextColor);
if (currentTab != 4) {
String listingsLabel = String.format(StatCollector.translateToLocal("auction.listings"), totalResults);
fontRendererObj.drawString(listingsLabel, LEFT_PANEL_X, 36, 0x666666);
}
}
private String getTabTitle() {
switch (currentTab) {
case 0: return StatCollector.translateToLocal("auction.browseTitle");
case 1: return StatCollector.translateToLocal("auction.myListingsTitle");
case 2: return StatCollector.translateToLocal("auction.myBidsTitle");
case 3: return StatCollector.translateToLocal("auction.claimsTitle");
case 4: return StatCollector.translateToLocal("auction.sellTitle");
default: return StatCollector.translateToLocal("auction.title");
}
}
// ICustomScrollListener
@Override
public void customScrollClicked(int mouseX, int mouseY, int mouseButton, GuiCustomScroll scroll) {
int index = scroll.selected;
selectedListingIndex = index;
updateButtonStates();
}
@Override
public void customScrollDoubleClicked(String selection, GuiCustomScroll scroll) {
if (selectedListingIndex >= 0 && selectedListingIndex < listings.size()) {
viewDetails();
}
}
// IGuiData
@Override
public void setGuiData(NBTTagCompound compound) {
// This can be used for initial setup data
}
// IAuctionData
@Override
public void onAuctionDataReceived(int dataType, NBTTagCompound data,
int totalResults, int currentPage, int totalPages,
long playerBalance) {
this.totalResults = totalResults;
this.currentPage = currentPage;
this.totalPages = totalPages;
this.playerBalance = playerBalance;
// Parse listings from NBT
listings.clear();
NBTTagList listingList = data.getTagList("Listings", 10);
for (int i = 0; i < listingList.tagCount(); i++) {
NBTTagCompound listingNBT = listingList.getCompoundTagAt(i);
AuctionListing listing = new AuctionListing();
listing.readFromNBT(listingNBT);
listings.add(listing);
}
selectedListingIndex = -1;
updateListingDisplay();
updateButtonStates();
// Update labels
if (getLabel(41) != null) {
getLabel(41).label = getPageLabel();
}
if (getLabel(60) != null) {
getLabel(60).label = String.format(StatCollector.translateToLocal("auction.balance"), formatCurrency(playerBalance));
}
}
@Override
public void save() {
// Nothing to save
}
}
@@ -0,0 +1,221 @@
package noppes.npcs.client.gui.player;
import kamkeel.npcs.network.packets.player.AuctionActionPacket;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.util.StatCollector;
import noppes.npcs.client.gui.util.GuiNpcButton;
import noppes.npcs.client.gui.util.GuiNpcLabel;
import noppes.npcs.client.gui.util.GuiNpcTextField;
import noppes.npcs.client.gui.util.SubGuiInterface;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.controllers.data.AuctionListing;
/**
* Sub GUI for placing a bid on an auction.
*/
public class SubGuiAuctionBid extends SubGuiInterface {
private AuctionListing listing;
private long playerBalance;
private GuiNpcTextField bidField;
private long lastUpdate = 0;
public SubGuiAuctionBid(GuiAuction parent, AuctionListing listing, long playerBalance) {
this.listing = listing;
this.playerBalance = playerBalance;
setBackground("menubg.png");
xSize = 240;
ySize = 165;
closeOnEsc = true;
}
@Override
public void initGui() {
super.initGui();
int y = guiTop + 10;
int labelColor = 0x404040;
if (listing.item == null) {
addLabel(new GuiNpcLabel(0, StatCollector.translateToLocal("auction.noItemSelected"), guiLeft + 60, y, 0xAA0000));
addButton(new GuiNpcButton(31, guiLeft + 80, guiTop + 125, 80, 20, StatCollector.translateToLocal("gui.cancel")));
return;
}
// Title
addLabel(new GuiNpcLabel(0, StatCollector.translateToLocal("auction.placeBid"), guiLeft + 90, y, labelColor));
y += 18;
// Item name
addLabel(new GuiNpcLabel(1, StatCollector.translateToLocal("auction.item") + " " + listing.item.getDisplayName(), guiLeft + 15, y, 0x000000));
y += 14;
// Current price
long currentPrice = listing.currentBid > 0 ? listing.currentBid : listing.startingPrice;
addLabel(new GuiNpcLabel(2, StatCollector.translateToLocal("auction.currentPrice"), guiLeft + 15, y, labelColor));
addLabel(new GuiNpcLabel(3, formatCurrency(currentPrice), guiLeft + 120, y, 0x008800));
y += 14;
// Minimum bid
long minBid = listing.getMinimumBid();
addLabel(new GuiNpcLabel(4, StatCollector.translateToLocal("auction.minimumBid"), guiLeft + 15, y, labelColor));
addLabel(new GuiNpcLabel(5, formatCurrency(minBid), guiLeft + 120, y, 0x0066AA));
y += 14;
// Your balance
addLabel(new GuiNpcLabel(6, StatCollector.translateToLocal("auction.yourBalance"), guiLeft + 15, y, labelColor));
addLabel(new GuiNpcLabel(7, formatCurrency(playerBalance), guiLeft + 120, y,
playerBalance >= minBid ? 0x008800 : 0xAA0000));
y += 14;
// Time remaining
addLabel(new GuiNpcLabel(8, StatCollector.translateToLocal("auction.timeLeft"), guiLeft + 15, y, labelColor));
addLabel(new GuiNpcLabel(9, formatTimeRemaining(listing.getTimeRemaining()), guiLeft + 120, y,
getTimeColor(listing.getTimeRemaining())));
y += 18;
// Bid input
addLabel(new GuiNpcLabel(10, StatCollector.translateToLocal("auction.yourBid"), guiLeft + 15, y + 3, labelColor));
bidField = new GuiNpcTextField(11, this, guiLeft + 100, y, 110, 16, String.valueOf(minBid));
bidField.setIntegersOnly();
int minBidInt = (int) Math.min(Integer.MAX_VALUE, Math.max(1L, minBid));
bidField.setMinMaxDefault(minBidInt, Integer.MAX_VALUE, minBidInt);
addTextField(bidField);
y += 24;
// Quick bid buttons
addButton(new GuiNpcButton(20, guiLeft + 15, y, 60, 16, StatCollector.translateToLocal("auction.minBid")));
addButton(new GuiNpcButton(21, guiLeft + 79, y, 60, 16, StatCollector.translateToLocal("auction.bidPlus10")));
addButton(new GuiNpcButton(22, guiLeft + 143, y, 60, 16, StatCollector.translateToLocal("auction.bidPlus25")));
y += 22;
// Place bid button
GuiNpcButton bidButton = new GuiNpcButton(30, guiLeft + 35, y, 80, 20, StatCollector.translateToLocal("auction.placeBid"));
bidButton.setEnabled(playerBalance >= minBid && listing.isActive());
addButton(bidButton);
// Cancel button
addButton(new GuiNpcButton(31, guiLeft + 125, y, 80, 20, StatCollector.translateToLocal("gui.cancel")));
// Error message area
if (playerBalance < minBid) {
addLabel(new GuiNpcLabel(40, StatCollector.translateToLocal("auction.insufficientFunds"), guiLeft + 70, guiTop + ySize - 15, 0xAA0000));
} else if (!listing.isActive()) {
addLabel(new GuiNpcLabel(40, StatCollector.translateToLocal("auction.auctionEnded"), guiLeft + 70, guiTop + ySize - 15, 0xAA0000));
}
}
private String formatCurrency(long amount) {
return String.format("%,d %s", amount, ConfigMarket.CurrencyName);
}
private String formatTimeRemaining(long millis) {
if (millis <= 0) return StatCollector.translateToLocal("auction.ended");
long seconds = millis / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
if (hours > 0) {
return String.format("%dh %dm", hours, minutes % 60);
} else if (minutes > 0) {
return String.format("%dm %ds", minutes, seconds % 60);
} else {
return String.format("%ds", seconds);
}
}
private int getTimeColor(long millis) {
if (millis <= 0) return 0xAA0000;
if (millis < 5 * 60 * 1000) return 0xFF0000;
if (millis < 30 * 60 * 1000) return 0xFF6600;
return 0x008800;
}
@Override
public void updateScreen() {
super.updateScreen();
// Update time remaining every second
long now = System.currentTimeMillis();
if (now - lastUpdate >= 1000) {
lastUpdate = now;
GuiNpcLabel timeLabel = getLabel(9);
if (timeLabel != null) {
long remaining = listing.getTimeRemaining();
timeLabel.label = formatTimeRemaining(remaining);
timeLabel.color = getTimeColor(remaining);
}
// Disable bid button if auction ended
GuiNpcButton bidButton = getButton(30);
if (bidButton != null && !listing.isActive()) {
bidButton.setEnabled(false);
}
}
}
@Override
public void actionPerformed(GuiButton button) {
int id = button.id;
long minBid = listing.getMinimumBid();
if (id == 20) {
// Min bid
bidField.setText(String.valueOf(minBid));
} else if (id == 21) {
// +10%
long newBid = (long) (minBid * 1.10);
if (newBid <= playerBalance) {
bidField.setText(String.valueOf(newBid));
}
} else if (id == 22) {
// +25%
long newBid = (long) (minBid * 1.25);
if (newBid <= playerBalance) {
bidField.setText(String.valueOf(newBid));
}
} else if (id == 30) {
// Place bid
placeBid();
} else if (id == 31) {
// Cancel
close();
}
}
private void placeBid() {
long bidAmount = parseBid(bidField);
long minBid = listing.getMinimumBid();
if (bidAmount < minBid) {
return;
}
if (bidAmount > playerBalance) {
return;
}
if (!listing.isActive()) {
return;
}
// Send bid to server
AuctionActionPacket.PlaceBid(listing.id, bidAmount);
close();
}
private long parseBid(GuiNpcTextField field) {
try {
return Long.parseLong(field.getText());
} catch (NumberFormatException e) {
return 0L;
}
}
@Override
public void save() {
// Nothing to save
}
}
@@ -0,0 +1,178 @@
package noppes.npcs.client.gui.player;
import kamkeel.npcs.network.packets.player.AuctionActionPacket;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.item.ItemStack;
import net.minecraft.util.StatCollector;
import noppes.npcs.client.gui.util.GuiNpcButton;
import noppes.npcs.client.gui.util.GuiNpcLabel;
import noppes.npcs.client.gui.util.GuiNpcTextField;
import noppes.npcs.client.gui.util.SubGuiInterface;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.constants.EnumAuctionDuration;
import noppes.npcs.containers.ContainerAuction;
/**
* Sub GUI for creating a new auction listing.
*/
public class SubGuiAuctionCreate extends SubGuiInterface {
private ContainerAuction container;
private GuiNpcTextField startingPriceField;
private GuiNpcTextField buyoutPriceField;
private int selectedDuration = 1; // Default to MEDIUM
public SubGuiAuctionCreate(GuiAuction parent, ContainerAuction container) {
this.container = container;
setBackground("menubg.png");
xSize = 260;
ySize = 190;
closeOnEsc = true;
}
@Override
public void initGui() {
super.initGui();
// Title
addLabel(new GuiNpcLabel(0, StatCollector.translateToLocal("auction.createListing"), guiLeft + 80, guiTop + 8, 0x404040));
// Item slot instructions
addLabel(new GuiNpcLabel(1, StatCollector.translateToLocal("auction.placeItemBelow"), guiLeft + 20, guiTop + 28, 0x404040));
// Item info (shows when item is in slot)
ItemStack item = container.getListingItem();
if (item != null) {
addLabel(new GuiNpcLabel(2, StatCollector.translateToLocal("auction.item") + " " + item.getDisplayName(), guiLeft + 20, guiTop + 50, 0x008800));
} else {
addLabel(new GuiNpcLabel(2, StatCollector.translateToLocal("auction.noItemSelected"), guiLeft + 20, guiTop + 50, 0x888888));
}
// Starting price
addLabel(new GuiNpcLabel(10, StatCollector.translateToLocal("auction.startingPrice"), guiLeft + 20, guiTop + 74, 0x404040));
startingPriceField = new GuiNpcTextField(11, this, guiLeft + 120, guiTop + 72, 90, 14, "100");
startingPriceField.setIntegersOnly();
startingPriceField.setMinMaxDefault(1, 999999999, 100);
addTextField(startingPriceField);
// Buyout price (optional)
addLabel(new GuiNpcLabel(20, StatCollector.translateToLocal("auction.buyoutPrice"), guiLeft + 20, guiTop + 96, 0x404040));
buyoutPriceField = new GuiNpcTextField(21, this, guiLeft + 120, guiTop + 94, 90, 14, "0");
buyoutPriceField.setIntegersOnly();
buyoutPriceField.setMinMaxDefault(0, 999999999, 0);
addTextField(buyoutPriceField);
addLabel(new GuiNpcLabel(22, StatCollector.translateToLocal("auction.noBuyoutHint"), guiLeft + 215, guiTop + 96, 0x888888));
// Duration selection
addLabel(new GuiNpcLabel(30, StatCollector.translateToLocal("auction.duration"), guiLeft + 20, guiTop + 118, 0x404040));
addButton(new GuiNpcButton(31, guiLeft + 120, guiTop + 114, 110, 20, getDurationDisplay()));
// Fee display
long fee = getListingFee();
addLabel(new GuiNpcLabel(40, StatCollector.translateToLocal("auction.listingFee") + " " + fee + " " + ConfigMarket.CurrencyName,
guiLeft + 20, guiTop + 142, fee > 0 ? 0xAA0000 : 0x008800));
// Create button
addButton(new GuiNpcButton(50, guiLeft + 30, guiTop + 162, 90, 20, StatCollector.translateToLocal("auction.create")));
getButton(50).setEnabled(item != null);
// Cancel button
addButton(new GuiNpcButton(51, guiLeft + 140, guiTop + 162, 90, 20, StatCollector.translateToLocal("gui.cancel")));
}
private String getDurationDisplay() {
EnumAuctionDuration duration = EnumAuctionDuration.values()[selectedDuration];
return duration.getDisplayName();
}
private long getListingFee() {
EnumAuctionDuration duration = EnumAuctionDuration.values()[selectedDuration];
return duration.getListingFee();
}
@Override
public void actionPerformed(GuiButton button) {
int id = button.id;
if (id == 31) {
// Cycle duration
selectedDuration = (selectedDuration + 1) % EnumAuctionDuration.values().length;
initGui();
} else if (id == 50) {
// Create listing
createListing();
} else if (id == 51) {
// Cancel
close();
}
}
private void createListing() {
ItemStack item = container.getListingItem();
if (item == null) {
return;
}
long startingPrice = parsePrice(startingPriceField, 1);
long buyoutPrice = parsePrice(buyoutPriceField, 0);
if (startingPrice < 1) {
startingPrice = 1;
}
if (buyoutPrice > 0 && buyoutPrice < startingPrice) {
// Show error - buyout must be higher than starting
return;
}
EnumAuctionDuration duration = EnumAuctionDuration.values()[selectedDuration];
// Send to server
AuctionActionPacket.CreateListing(item, startingPrice, buyoutPrice, duration);
// Clear slot and close
container.clearListingSlot();
close();
}
private long parsePrice(GuiNpcTextField field, long defaultValue) {
try {
return Long.parseLong(field.getText());
} catch (NumberFormatException e) {
return defaultValue;
}
}
@Override
public void updateScreen() {
super.updateScreen();
// Update item display if it changed
ItemStack item = container.getListingItem();
GuiNpcLabel itemLabel = getLabel(2);
GuiNpcButton createButton = getButton(50);
if (item != null) {
if (itemLabel != null) {
itemLabel.label = StatCollector.translateToLocal("auction.item") + " " + item.getDisplayName();
itemLabel.color = 0x008800;
}
if (createButton != null) {
createButton.setEnabled(true);
}
} else {
if (itemLabel != null) {
itemLabel.label = StatCollector.translateToLocal("auction.noItemSelected");
itemLabel.color = 0x888888;
}
if (createButton != null) {
createButton.setEnabled(false);
}
}
}
@Override
public void save() {
// Nothing to save
}
}
@@ -0,0 +1,200 @@
package noppes.npcs.client.gui.player;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.util.StatCollector;
import noppes.npcs.client.gui.util.GuiNpcButton;
import noppes.npcs.client.gui.util.GuiNpcLabel;
import noppes.npcs.client.gui.util.SubGuiInterface;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.controllers.data.AuctionListing;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
/**
* Sub GUI for viewing auction listing details.
*/
public class SubGuiAuctionDetails extends SubGuiInterface {
private AuctionListing listing;
private long lastUpdate = 0;
public SubGuiAuctionDetails(GuiAuction parent, AuctionListing listing) {
this.listing = listing;
setBackground("menubg.png");
xSize = 280;
ySize = 210;
closeOnEsc = true;
}
@Override
public void initGui() {
super.initGui();
int y = guiTop + 8;
int labelColor = 0x404040;
int valueColor = 0x000000;
if (listing.item == null) {
addLabel(new GuiNpcLabel(0, StatCollector.translateToLocal("auction.noItemSelected"), guiLeft + 80, y, 0xAA0000));
addButton(new GuiNpcButton(50, guiLeft + 100, guiTop + 185, 80, 20, StatCollector.translateToLocal("gui.close")));
return;
}
// Title
addLabel(new GuiNpcLabel(0, StatCollector.translateToLocal("auction.auctionDetails"), guiLeft + 100, y, labelColor));
y += 16;
// Item name
addLabel(new GuiNpcLabel(1, StatCollector.translateToLocal("auction.item"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(2, listing.item.getDisplayName(), guiLeft + 100, y, valueColor));
y += 14;
// Quantity
addLabel(new GuiNpcLabel(3, StatCollector.translateToLocal("auction.quantity"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(4, String.valueOf(listing.item.stackSize), guiLeft + 100, y, valueColor));
y += 14;
// Seller
addLabel(new GuiNpcLabel(5, StatCollector.translateToLocal("auction.seller"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(6, listing.sellerName, guiLeft + 100, y, valueColor));
y += 14;
// Starting price
addLabel(new GuiNpcLabel(10, StatCollector.translateToLocal("auction.startingPrice"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(11, formatCurrency(listing.startingPrice), guiLeft + 120, y, valueColor));
y += 14;
// Current bid
if (listing.currentBid > 0) {
addLabel(new GuiNpcLabel(12, StatCollector.translateToLocal("auction.currentBid"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(13, formatCurrency(listing.currentBid), guiLeft + 120, y, 0x008800));
y += 14;
// High bidder
addLabel(new GuiNpcLabel(14, StatCollector.translateToLocal("auction.highBidder"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(15, listing.highBidderName, guiLeft + 120, y, valueColor));
y += 14;
// Bid count
addLabel(new GuiNpcLabel(16, StatCollector.translateToLocal("auction.totalBids"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(17, String.valueOf(listing.bidCount), guiLeft + 120, y, valueColor));
y += 14;
} else {
addLabel(new GuiNpcLabel(12, StatCollector.translateToLocal("auction.currentBid"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(13, StatCollector.translateToLocal("auction.noBidsYet"), guiLeft + 120, y, 0x888888));
y += 14;
}
// Buyout price
if (listing.buyoutPrice > 0) {
addLabel(new GuiNpcLabel(20, StatCollector.translateToLocal("auction.buyoutPrice"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(21, formatCurrency(listing.buyoutPrice), guiLeft + 120, y, 0xAA6600));
y += 14;
}
// Minimum bid
addLabel(new GuiNpcLabel(22, StatCollector.translateToLocal("auction.minimumBid"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(23, formatCurrency(listing.getMinimumBid()), guiLeft + 120, y, 0x0066AA));
y += 14;
// Time remaining (will be updated)
addLabel(new GuiNpcLabel(30, StatCollector.translateToLocal("auction.timeLeft"), guiLeft + 20, y, labelColor));
addLabel(new GuiNpcLabel(31, formatTimeRemaining(listing.getTimeRemaining()), guiLeft + 120, y,
getTimeColor(listing.getTimeRemaining())));
y += 20;
// Close button
addButton(new GuiNpcButton(50, guiLeft + 100, guiTop + 185, 80, 20, StatCollector.translateToLocal("gui.close")));
}
private String formatCurrency(long amount) {
return String.format("%,d %s", amount, ConfigMarket.CurrencyName);
}
private String formatTimeRemaining(long millis) {
if (millis <= 0) return StatCollector.translateToLocal("auction.ended");
long seconds = millis / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;
if (days > 0) {
return String.format("%dd %dh %dm", days, hours % 24, minutes % 60);
} else if (hours > 0) {
return String.format("%dh %dm %ds", hours, minutes % 60, seconds % 60);
} else if (minutes > 0) {
return String.format("%dm %ds", minutes, seconds % 60);
} else {
return String.format("%ds", seconds);
}
}
private int getTimeColor(long millis) {
if (millis <= 0) return 0xAA0000;
if (millis < 5 * 60 * 1000) return 0xFF0000; // < 5 minutes - red
if (millis < 30 * 60 * 1000) return 0xFF6600; // < 30 minutes - orange
if (millis < 60 * 60 * 1000) return 0xAAAA00; // < 1 hour - yellow
return 0x008800; // green
}
@Override
public void updateScreen() {
super.updateScreen();
// Update time remaining every second
long now = System.currentTimeMillis();
if (now - lastUpdate >= 1000) {
lastUpdate = now;
GuiNpcLabel timeLabel = getLabel(31);
if (timeLabel != null) {
long remaining = listing.getTimeRemaining();
timeLabel.label = formatTimeRemaining(remaining);
timeLabel.color = getTimeColor(remaining);
}
}
}
@Override
public void drawScreen(int mouseX, int mouseY, float partialTicks) {
super.drawScreen(mouseX, mouseY, partialTicks);
// Draw item icon
if (listing.item != null) {
int itemX = guiLeft + 230;
int itemY = guiTop + 32;
RenderHelper.enableGUIStandardItemLighting();
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
GL11.glEnable(GL11.GL_COLOR_MATERIAL);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glScalef(2.0f, 2.0f, 2.0f);
itemRender.renderItemAndEffectIntoGUI(fontRendererObj, mc.renderEngine,
listing.item, itemX / 2, itemY / 2);
itemRender.renderItemOverlayIntoGUI(fontRendererObj, mc.renderEngine,
listing.item, itemX / 2, itemY / 2);
GL11.glScalef(0.5f, 0.5f, 0.5f);
RenderHelper.disableStandardItemLighting();
// Tooltip on hover
if (mouseX >= itemX && mouseX < itemX + 32 && mouseY >= itemY && mouseY < itemY + 32) {
renderToolTip(listing.item, mouseX, mouseY);
}
}
}
@Override
public void actionPerformed(GuiButton button) {
if (button.id == 50) {
close();
}
}
@Override
public void save() {
// Nothing to save
}
}
@@ -0,0 +1,144 @@
package noppes.npcs.client.gui.roles;
import kamkeel.npcs.network.PacketClient;
import kamkeel.npcs.network.packets.request.role.RoleSavePacket;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.nbt.NBTTagCompound;
import noppes.npcs.client.gui.util.GuiNPCInterface2;
import noppes.npcs.client.gui.util.GuiNpcButton;
import noppes.npcs.client.gui.util.GuiNpcLabel;
import noppes.npcs.client.gui.util.GuiNpcTextField;
import noppes.npcs.client.gui.util.ITextfieldListener;
import noppes.npcs.entity.EntityNPCInterface;
import noppes.npcs.roles.RoleAuctioneer;
public class GuiNpcAuctioneer extends GuiNPCInterface2 implements ITextfieldListener {
private final RoleAuctioneer role;
public GuiNpcAuctioneer(EntityNPCInterface npc) {
super(npc);
this.role = npc.roleInterface instanceof RoleAuctioneer ? (RoleAuctioneer) npc.roleInterface : null;
}
@Override
public void initGui() {
super.initGui();
if (role == null) {
close();
return;
}
int y = guiTop + 10;
// Left column - Tab visibility
addLabel(new GuiNpcLabel(0, "role.auctioneer.tabs", guiLeft + 10, y, 0x404040));
y += 18;
addLabel(new GuiNpcLabel(1, "role.auctioneer.showBrowse", guiLeft + 10, y + 5, 0x404040));
addButton(new GuiNpcButton(1, guiLeft + 140, y, 50, 20, new String[]{"gui.no", "gui.yes"}, role.showActiveListings ? 1 : 0));
y += 22;
addLabel(new GuiNpcLabel(2, "role.auctioneer.showMyListings", guiLeft + 10, y + 5, 0x404040));
addButton(new GuiNpcButton(2, guiLeft + 140, y, 50, 20, new String[]{"gui.no", "gui.yes"}, role.showMyListings ? 1 : 0));
y += 22;
addLabel(new GuiNpcLabel(3, "role.auctioneer.showMyBids", guiLeft + 10, y + 5, 0x404040));
addButton(new GuiNpcButton(3, guiLeft + 140, y, 50, 20, new String[]{"gui.no", "gui.yes"}, role.showMyBids ? 1 : 0));
y += 22;
addLabel(new GuiNpcLabel(4, "role.auctioneer.showClaims", guiLeft + 10, y + 5, 0x404040));
addButton(new GuiNpcButton(4, guiLeft + 140, y, 50, 20, new String[]{"gui.no", "gui.yes"}, role.showClaims ? 1 : 0));
y += 30;
// Actions
addLabel(new GuiNpcLabel(10, "role.auctioneer.actions", guiLeft + 10, y, 0x404040));
y += 18;
addLabel(new GuiNpcLabel(11, "role.auctioneer.allowCreate", guiLeft + 10, y + 5, 0x404040));
addButton(new GuiNpcButton(11, guiLeft + 140, y, 50, 20, new String[]{"gui.no", "gui.yes"}, role.allowCreatingListings ? 1 : 0));
y += 22;
addLabel(new GuiNpcLabel(12, "role.auctioneer.allowBid", guiLeft + 10, y + 5, 0x404040));
addButton(new GuiNpcButton(12, guiLeft + 140, y, 50, 20, new String[]{"gui.no", "gui.yes"}, role.allowBidding ? 1 : 0));
y += 22;
addLabel(new GuiNpcLabel(13, "role.auctioneer.allowBuyout", guiLeft + 10, y + 5, 0x404040));
addButton(new GuiNpcButton(13, guiLeft + 140, y, 50, 20, new String[]{"gui.no", "gui.yes"}, role.allowBuyout ? 1 : 0));
// Right column - Messages
int rightX = guiLeft + 210;
int rightY = guiTop + 10;
addLabel(new GuiNpcLabel(20, "role.auctioneer.messages", rightX, rightY, 0x404040));
rightY += 18;
addLabel(new GuiNpcLabel(21, "role.auctioneer.welcome", rightX, rightY + 5, 0x404040));
rightY += 18;
GuiNpcTextField welcomeField = new GuiNpcTextField(21, this, rightX, rightY, 180, 20, role.welcomeMessage);
welcomeField.setMaxStringLength(200);
addTextField(welcomeField);
rightY += 28;
addLabel(new GuiNpcLabel(22, "role.auctioneer.noAuction", rightX, rightY + 5, 0x404040));
rightY += 18;
GuiNpcTextField noAuctionField = new GuiNpcTextField(22, this, rightX, rightY, 180, 20, role.noAuctionMessage);
noAuctionField.setMaxStringLength(200);
addTextField(noAuctionField);
}
@Override
public void buttonEvent(GuiButton guibutton) {
if (role == null) return;
if (guibutton instanceof GuiNpcButton) {
GuiNpcButton button = (GuiNpcButton) guibutton;
boolean value = button.getValue() == 1;
switch (button.id) {
case 1:
role.showActiveListings = value;
break;
case 2:
role.showMyListings = value;
break;
case 3:
role.showMyBids = value;
break;
case 4:
role.showClaims = value;
break;
case 11:
role.allowCreatingListings = value;
break;
case 12:
role.allowBidding = value;
break;
case 13:
role.allowBuyout = value;
break;
}
}
}
@Override
public void unFocused(GuiNpcTextField textfield) {
if (role == null) return;
switch (textfield.id) {
case 21:
role.welcomeMessage = textfield.getText();
break;
case 22:
role.noAuctionMessage = textfield.getText();
break;
}
}
@Override
public void save() {
if (role != null) {
PacketClient.sendClient(new RoleSavePacket(role.writeToNBT(new NBTTagCompound())));
}
}
}
@@ -0,0 +1,245 @@
package noppes.npcs.config;
import cpw.mods.fml.common.FMLLog;
import net.minecraftforge.common.config.Configuration;
import net.minecraftforge.common.config.Property;
import org.apache.logging.log4j.Level;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
public class ConfigMarket {
public static Configuration config;
public final static String MARKET = "Market";
public final static String CURRENCY = "Market.Currency";
public final static String AUCTION = "Market.Auction";
public final static String TRADER = "Market.Trader";
// =========================================
// Market General
// =========================================
public static boolean MarketEnabled = true;
// =========================================
// Currency Settings
// =========================================
public static boolean UseVaultIfAvailable = true;
public static String CurrencyName = "Gold";
public static String FallbackCurrencyItem = "customnpcs:npcCoinGold";
public static long FallbackItemRatio = 1;
public static long StartingBalance = 1000;
public static long MaxBalance = 999999999999L;
// =========================================
// Auction Settings
// =========================================
public static boolean AuctionEnabled = true;
public static int DefaultMaxListings = 5;
public static double ListingFeePercent = 0.0;
public static double SalesTaxPercent = 0.05;
public static boolean RequireAuctioneerNPC = true;
public static int ClaimExpirationDays = 30;
public static double MinBidIncrementPercent = 0.05;
public static int SnipeProtectionMinutes = 5;
public static int SnipeProtectionThreshold = 5;
// Auction Duration Settings (in hours)
public static int AuctionDurationShort = 2;
public static int AuctionDurationMedium = 12;
public static int AuctionDurationLong = 24;
public static int AuctionDurationVeryLong = 48;
// Auction Duration Fees (flat currency amount)
public static long AuctionFeeShort = 0;
public static long AuctionFeeMedium = 0;
public static long AuctionFeeLong = 0;
public static long AuctionFeeVeryLong = 0;
// =========================================
// Trader Settings
// =========================================
public static boolean EnableStockByDefault = false;
public static String DefaultResetType = "NONE";
public static void init(File configFile) {
config = new Configuration(configFile);
try {
config.load();
// =========================================
// Market General
// =========================================
MarketEnabled = config.get(MARKET, "Enable Market System", true,
"Enable the market/economy system").getBoolean(true);
// =========================================
// Currency Settings
// =========================================
config.setCategoryComment(CURRENCY, "Currency system settings for the virtual economy");
UseVaultIfAvailable = config.get(CURRENCY, "Use Vault If Available", true,
"Use VaultAPI if available on Bukkit hybrid servers").getBoolean(true);
CurrencyName = config.get(CURRENCY, "Currency Name", "Gold",
"Display name for the currency").getString();
FallbackCurrencyItem = config.get(CURRENCY, "Fallback Currency Item", "customnpcs:npcCoinGold",
"Item registry name to use as currency when Vault is unavailable. Leave empty to disable.").getString();
FallbackItemRatio = config.get(CURRENCY, "Fallback Item Ratio", 1,
"Conversion ratio: 1 fallback item = X virtual currency").getInt(1);
StartingBalance = config.get(CURRENCY, "Starting Balance", 1000,
"Starting balance for new players (only used when Vault is not available)").getInt(1000);
Property maxBalanceProp = config.get(CURRENCY, "Maximum Balance", String.valueOf(MaxBalance),
"Maximum balance a player can have (only used when Vault is not available)");
try {
MaxBalance = Long.parseLong(maxBalanceProp.getString());
} catch (NumberFormatException e) {
MaxBalance = 999999999999L;
}
if (MaxBalance < 0) {
MaxBalance = 0;
}
// =========================================
// Auction Settings
// =========================================
config.setCategoryComment(AUCTION, "Auction house settings");
AuctionEnabled = config.get(AUCTION, "Enable Auction House", true,
"Enable/disable the auction house system").getBoolean(true);
DefaultMaxListings = config.get(AUCTION, "Default Max Listings", 5,
"Default maximum auction listings per player (without permission override)").getInt(5);
ListingFeePercent = config.get(AUCTION, "Listing Fee Percent", 0.0,
"Listing fee as percentage of starting price (0.0 = no fee)").getDouble(0.0);
SalesTaxPercent = config.get(AUCTION, "Sales Tax Percent", 0.05,
"Sales tax as percentage taken from final sale price (0.05 = 5%)").getDouble(0.05);
RequireAuctioneerNPC = config.get(AUCTION, "Require Auctioneer NPC", true,
"Require an Auctioneer NPC to access auction house").getBoolean(true);
ClaimExpirationDays = config.get(AUCTION, "Claim Expiration Days", 30,
"Claim expiration in days (claims auto-expire after this period, 0 = never)").getInt(30);
MinBidIncrementPercent = config.get(AUCTION, "Min Bid Increment Percent", 0.05,
"Minimum bid increment as percentage (0.05 = 5% minimum increase)").getDouble(0.05);
SnipeProtectionMinutes = config.get(AUCTION, "Snipe Protection Minutes", 5,
"Extend auction TO this many minutes when bid placed near end. Set to 0 to disable.").getInt(5);
SnipeProtectionThreshold = config.get(AUCTION, "Snipe Protection Threshold", 5,
"How many minutes before end triggers snipe protection").getInt(5);
// Duration settings
AuctionDurationShort = config.get(AUCTION, "Duration Short Hours", 2,
"Short auction duration in hours").getInt(2);
AuctionDurationMedium = config.get(AUCTION, "Duration Medium Hours", 12,
"Medium auction duration in hours").getInt(12);
AuctionDurationLong = config.get(AUCTION, "Duration Long Hours", 24,
"Long auction duration in hours").getInt(24);
AuctionDurationVeryLong = config.get(AUCTION, "Duration Very Long Hours", 48,
"Very long auction duration in hours").getInt(48);
// Duration fees
AuctionFeeShort = config.get(AUCTION, "Fee Short Duration", 0,
"Flat fee for short duration auctions").getInt(0);
AuctionFeeMedium = config.get(AUCTION, "Fee Medium Duration", 0,
"Flat fee for medium duration auctions").getInt(0);
AuctionFeeLong = config.get(AUCTION, "Fee Long Duration", 0,
"Flat fee for long duration auctions").getInt(0);
AuctionFeeVeryLong = config.get(AUCTION, "Fee Very Long Duration", 0,
"Flat fee for very long duration auctions").getInt(0);
// =========================================
// Trader Settings
// =========================================
config.setCategoryComment(TRADER, "Trader stock system settings");
EnableStockByDefault = config.get(TRADER, "Enable Stock By Default", false,
"Enable stock system by default for new traders").getBoolean(false);
DefaultResetType = config.get(TRADER, "Default Reset Type", "NONE",
"Default stock reset type (NONE, MCDAILY, MCWEEKLY, RLDAILY, RLWEEKLY)").getString();
// Set category order
config.setCategoryPropertyOrder(MARKET, new ArrayList<>(Arrays.asList(
"Enable Market System"
)));
config.setCategoryPropertyOrder(CURRENCY, new ArrayList<>(Arrays.asList(
"Use Vault If Available",
"Currency Name",
"Fallback Currency Item",
"Fallback Item Ratio",
"Starting Balance",
"Maximum Balance"
)));
config.setCategoryPropertyOrder(AUCTION, new ArrayList<>(Arrays.asList(
"Enable Auction House",
"Default Max Listings",
"Listing Fee Percent",
"Sales Tax Percent",
"Require Auctioneer NPC",
"Claim Expiration Days",
"Min Bid Increment Percent",
"Snipe Protection Minutes",
"Snipe Protection Threshold",
"Duration Short Hours",
"Duration Medium Hours",
"Duration Long Hours",
"Duration Very Long Hours",
"Fee Short Duration",
"Fee Medium Duration",
"Fee Long Duration",
"Fee Very Long Duration"
)));
config.setCategoryPropertyOrder(TRADER, new ArrayList<>(Arrays.asList(
"Enable Stock By Default",
"Default Reset Type"
)));
// Validation
if (DefaultMaxListings < 1) {
DefaultMaxListings = 1;
}
if (ClaimExpirationDays < 0) {
ClaimExpirationDays = 0;
}
if (SnipeProtectionMinutes < 0) {
SnipeProtectionMinutes = 0;
}
if (SnipeProtectionThreshold < 0) {
SnipeProtectionThreshold = 0;
}
if (StartingBalance < 0) {
StartingBalance = 0;
}
if (MaxBalance < 1) {
MaxBalance = 1;
}
} catch (Exception e) {
FMLLog.log(Level.ERROR, e, "CNPC+ has had a problem loading its market configuration");
} finally {
if (config.hasChanged()) {
config.save();
}
}
}
}
@@ -9,6 +9,7 @@ public class LoadConfiguration {
public static File debugConfigFile;
public static File clientConfigFile;
public static File experimentalConfigFile;
public static File marketConfigFile;
public static void init(String configpath) {
mainConfigFile = new File(configpath + "main.cfg");
@@ -17,6 +18,7 @@ public class LoadConfiguration {
scriptConfigFile = new File(configpath + "script.cfg");
debugConfigFile = new File(configpath + "debug.cfg");
experimentalConfigFile = new File(configpath + "experimental.cfg");
marketConfigFile = new File(configpath + "market.cfg");
ConfigMain.init(mainConfigFile);
ConfigItem.init(itemConfigFile);
@@ -24,5 +26,6 @@ public class LoadConfiguration {
ConfigScript.init(scriptConfigFile);
ConfigDebug.init(debugConfigFile);
ConfigExperimental.init(experimentalConfigFile);
ConfigMarket.init(marketConfigFile);
}
}
@@ -0,0 +1,82 @@
package noppes.npcs.constants;
import net.minecraft.util.StatCollector;
import noppes.npcs.config.ConfigMarket;
/**
* Duration options for auction listings.
* Values are configurable via ConfigMarket.
*/
public enum EnumAuctionDuration {
SHORT("auction.duration.short"),
MEDIUM("auction.duration.medium"),
LONG("auction.duration.long"),
VERY_LONG("auction.duration.veryLong");
private final String langKey;
EnumAuctionDuration(String langKey) {
this.langKey = langKey;
}
/**
* Get duration in milliseconds
*/
public long getMillis() {
switch (this) {
case SHORT:
return ConfigMarket.AuctionDurationShort * 60L * 60L * 1000L;
case MEDIUM:
return ConfigMarket.AuctionDurationMedium * 60L * 60L * 1000L;
case LONG:
return ConfigMarket.AuctionDurationLong * 60L * 60L * 1000L;
case VERY_LONG:
return ConfigMarket.AuctionDurationVeryLong * 60L * 60L * 1000L;
default:
return 24 * 60L * 60L * 1000L;
}
}
/**
* Get duration in hours
*/
public int getHours() {
switch (this) {
case SHORT:
return ConfigMarket.AuctionDurationShort;
case MEDIUM:
return ConfigMarket.AuctionDurationMedium;
case LONG:
return ConfigMarket.AuctionDurationLong;
case VERY_LONG:
return ConfigMarket.AuctionDurationVeryLong;
default:
return 24;
}
}
/**
* Get display name for GUI
*/
public String getDisplayName() {
return StatCollector.translateToLocal(langKey);
}
/**
* Get listing fee for this duration
*/
public long getListingFee() {
switch (this) {
case SHORT:
return ConfigMarket.AuctionFeeShort;
case MEDIUM:
return ConfigMarket.AuctionFeeMedium;
case LONG:
return ConfigMarket.AuctionFeeLong;
case VERY_LONG:
return ConfigMarket.AuctionFeeVeryLong;
default:
return 0;
}
}
}
@@ -0,0 +1,39 @@
package noppes.npcs.constants;
import net.minecraft.util.StatCollector;
/**
* Sorting options for auction listings.
*/
public enum EnumAuctionSort {
NEWEST_FIRST("auction.sort.newest"),
OLDEST_FIRST("auction.sort.oldest"),
PRICE_HIGH_TO_LOW("auction.sort.priceHigh"),
PRICE_LOW_TO_HIGH("auction.sort.priceLow"),
ENDING_SOON("auction.sort.endingSoon"),
MOST_TIME_LEFT("auction.sort.mostTime"),
NAME_A_TO_Z("auction.sort.nameAZ"),
NAME_Z_TO_A("auction.sort.nameZA"),
MOST_BIDS("auction.sort.mostBids"),
LEAST_BIDS("auction.sort.leastBids");
private final String langKey;
EnumAuctionSort(String langKey) {
this.langKey = langKey;
}
public String getDisplayName() {
return StatCollector.translateToLocal(langKey);
}
public EnumAuctionSort next() {
EnumAuctionSort[] values = values();
return values[(this.ordinal() + 1) % values.length];
}
public EnumAuctionSort previous() {
EnumAuctionSort[] values = values();
return values[(this.ordinal() - 1 + values.length) % values.length];
}
}
@@ -0,0 +1,54 @@
package noppes.npcs.constants;
/**
* Status of an auction listing.
*/
public enum EnumAuctionStatus {
ACTIVE, // Currently listed and accepting bids
SOLD, // Successfully sold (buyout or auction end with bids)
EXPIRED, // Ended without any bids
CANCELLED, // Cancelled by seller (only allowed before first bid)
CLAIMED; // Item/money has been claimed by respective parties
/**
* Get display name for GUI
*/
public String getDisplayName() {
switch (this) {
case ACTIVE: return "Active";
case SOLD: return "Sold";
case EXPIRED: return "Expired";
case CANCELLED: return "Cancelled";
case CLAIMED: return "Claimed";
default: return "Unknown";
}
}
/**
* Get display color for GUI (MC color codes)
*/
public char getColorCode() {
switch (this) {
case ACTIVE: return 'a'; // Green
case SOLD: return '6'; // Gold
case EXPIRED: return '7'; // Gray
case CANCELLED: return 'c'; // Red
case CLAIMED: return '8'; // Dark gray
default: return 'f'; // White
}
}
/**
* Check if listing can still receive bids
*/
public boolean canBid() {
return this == ACTIVE;
}
/**
* Check if listing needs claiming (item or money)
*/
public boolean needsClaiming() {
return this == SOLD || this == EXPIRED || this == CANCELLED;
}
}
@@ -64,5 +64,7 @@ public enum EnumGuiType {
ScriptBlock,
Paintbrush,
MagicBook,
ManageAbilities;
ManageAbilities,
PlayerAuction,
SetupAuctioneer;
}
@@ -2,5 +2,5 @@ package noppes.npcs.constants;
public enum EnumRoleType {
None, Trader, Follower, Bank, Transporter, Postman, Companion, Mount
None, Trader, Follower, Bank, Transporter, Postman, Companion, Mount, Auctioneer
}
@@ -0,0 +1,64 @@
package noppes.npcs.constants;
/**
* Stock reset types for Trader NPCs.
* Mirrors EnumQuestRepeat pattern for consistency.
*/
public enum EnumStockReset {
NONE, // Never resets
MCDAILY, // Every 24000 MC ticks (1 MC day)
MCWEEKLY, // Every 168000 MC ticks (7 MC days)
MCCUSTOM, // Custom MC tick interval
RLDAILY, // Every 24 real hours
RLWEEKLY, // Every 7 real days
RLCUSTOM; // Custom real-time interval
/**
* Get reset interval in milliseconds for real-time types
* or ticks for MC-time types
*/
public long getDefaultInterval() {
switch (this) {
case MCDAILY:
return 24000; // MC ticks
case MCWEEKLY:
return 168000; // MC ticks (7 days)
case RLDAILY:
return 86400000L; // 24 hours in ms
case RLWEEKLY:
return 604800000L; // 7 days in ms
default:
return 0;
}
}
/**
* Check if this reset type uses real-world time
*/
public boolean isRealTime() {
return this == RLDAILY || this == RLWEEKLY || this == RLCUSTOM;
}
/**
* Check if this reset type uses Minecraft time
*/
public boolean isMinecraftTime() {
return this == MCDAILY || this == MCWEEKLY || this == MCCUSTOM;
}
/**
* Get display name for GUI
*/
public String getDisplayName() {
switch (this) {
case NONE: return "Never";
case MCDAILY: return "MC Daily";
case MCWEEKLY: return "MC Weekly";
case MCCUSTOM: return "MC Custom";
case RLDAILY: return "Real Daily";
case RLWEEKLY: return "Real Weekly";
case RLCUSTOM: return "Real Custom";
default: return "Unknown";
}
}
}
@@ -0,0 +1,193 @@
package noppes.npcs.containers;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import noppes.npcs.entity.EntityNPCInterface;
/**
* Container for auction house GUI.
* Handles player inventory and item slot for creating listings.
*/
public class ContainerAuction extends Container {
public EntityNPCInterface npc;
public EntityPlayer player;
// Slot for item being listed
public SlotAuctionItem listingSlot;
private IInventory listingInventory;
public ContainerAuction(EntityNPCInterface npc, EntityPlayer player) {
this.npc = npc;
this.player = player;
// Create a single-slot inventory for the item being listed
listingInventory = new InventoryAuctionListing();
listingSlot = new SlotAuctionItem(listingInventory, 0, 251, 146);
addSlotToContainer(listingSlot);
// Player inventory slots (standard positioning)
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 9; col++) {
addSlotToContainer(new Slot(player.inventory, col + row * 9 + 9,
8 + col * 18, 166 + row * 18));
}
}
// Player hotbar
for (int col = 0; col < 9; col++) {
addSlotToContainer(new Slot(player.inventory, col, 8 + col * 18, 224));
}
}
@Override
public boolean canInteractWith(EntityPlayer player) {
return npc != null && npc.isEntityAlive() &&
player.getDistanceSqToEntity(npc) < 64.0D;
}
@Override
public ItemStack transferStackInSlot(EntityPlayer player, int slotIndex) {
ItemStack itemstack = null;
Slot slot = (Slot) inventorySlots.get(slotIndex);
if (slot != null && slot.getHasStack()) {
ItemStack stackInSlot = slot.getStack();
itemstack = stackInSlot.copy();
// If from listing slot, move to player inventory
if (slotIndex == 0) {
if (!mergeItemStack(stackInSlot, 1, 37, true)) {
return null;
}
}
// If from player inventory, move to listing slot
else {
if (!mergeItemStack(stackInSlot, 0, 1, false)) {
return null;
}
}
if (stackInSlot.stackSize == 0) {
slot.putStack(null);
} else {
slot.onSlotChanged();
}
}
return itemstack;
}
@Override
public void onContainerClosed(EntityPlayer player) {
super.onContainerClosed(player);
// Return any item in the listing slot to player
ItemStack stack = listingInventory.getStackInSlot(0);
if (stack != null) {
if (!player.inventory.addItemStackToInventory(stack)) {
player.entityDropItem(stack, 0.5f);
}
}
}
/**
* Get the item currently in the listing slot
*/
public ItemStack getListingItem() {
return listingInventory.getStackInSlot(0);
}
/**
* Clear the listing slot (after successful listing creation)
*/
public void clearListingSlot() {
listingInventory.setInventorySlotContents(0, null);
}
/**
* Simple inventory for the listing slot
*/
private class InventoryAuctionListing implements IInventory {
private ItemStack item;
@Override
public int getSizeInventory() { return 1; }
@Override
public ItemStack getStackInSlot(int slot) { return item; }
@Override
public ItemStack decrStackSize(int slot, int amount) {
if (item != null) {
ItemStack result;
if (item.stackSize <= amount) {
result = item;
item = null;
return result;
} else {
result = item.splitStack(amount);
if (item.stackSize == 0) {
item = null;
}
return result;
}
}
return null;
}
@Override
public ItemStack getStackInSlotOnClosing(int slot) {
ItemStack result = item;
item = null;
return result;
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack) {
item = stack;
}
@Override
public String getInventoryName() { return "AuctionListing"; }
@Override
public boolean hasCustomInventoryName() { return false; }
@Override
public int getInventoryStackLimit() { return 64; }
@Override
public void markDirty() {}
@Override
public boolean isUseableByPlayer(EntityPlayer player) { return true; }
@Override
public void openInventory() {}
@Override
public void closeInventory() {}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack) { return true; }
}
/**
* Custom slot for auction listings
*/
public class SlotAuctionItem extends Slot {
public SlotAuctionItem(IInventory inv, int index, int x, int y) {
super(inv, index, x, y);
}
@Override
public boolean isItemValid(ItemStack stack) {
// Check if item can be traded (not untradeable, soulbound, etc.)
return kamkeel.npcs.controllers.data.attribute.ItemTradeAttribute.canTrade(stack);
}
}
}
@@ -4,6 +4,7 @@ import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import noppes.npcs.NoppesUtilPlayer;
import noppes.npcs.controllers.CurrencyController;
import noppes.npcs.entity.EntityNPCInterface;
import noppes.npcs.roles.RoleTrader;
@@ -61,17 +62,43 @@ public class ContainerNPCTrader extends ContainerNpcInterface {
ItemStack item = slot.getStack();
if (!canGivePlayer(item, entityplayer))
return null;
if (!canBuy(i, entityplayer))
return null;
if (!isSlotEnabled(i, entityplayer))
return null;
NoppesUtilPlayer.consumeItem(entityplayer, role.inventoryCurrency.getStackInSlot(i), role.ignoreDamage, role.ignoreNBT);
NoppesUtilPlayer.consumeItem(entityplayer, role.inventoryCurrency.getStackInSlot(i + 18), role.ignoreDamage, role.ignoreNBT);
// Check stock availability
String playerName = entityplayer.getCommandSenderName();
if (!role.hasStock(i, playerName, 1)) {
return null; // Out of stock
}
// Handle currency-based purchase
if (role.hasSlotPrice(i)) {
long price = role.getSlotPrice(i);
if (CurrencyController.Instance == null) {
return null; // Currency system not available
}
if (!CurrencyController.Instance.canAfford(entityplayer, price)) {
return null; // Can't afford
}
// Withdraw currency
if (!CurrencyController.Instance.withdraw(entityplayer, price)) {
return null; // Withdrawal failed
}
} else {
// Item-based currency - existing logic
if (!canBuy(i, entityplayer))
return null;
NoppesUtilPlayer.consumeItem(entityplayer, role.inventoryCurrency.getStackInSlot(i), role.ignoreDamage, role.ignoreNBT);
NoppesUtilPlayer.consumeItem(entityplayer, role.inventoryCurrency.getStackInSlot(i + 18), role.ignoreDamage, role.ignoreNBT);
}
// Consume stock
role.consumeStock(i, playerName, 1);
ItemStack soldItem = item.copy();
givePlayer(soldItem, entityplayer);
role.addPurchase(i, entityplayer.getDisplayName());
return soldItem;
}
public boolean isSlotEnabled(int slot, EntityPlayer player) {
@@ -0,0 +1,419 @@
package noppes.npcs.controllers;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.CompressedStreamTools;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.nbt.NBTTagString;
import noppes.npcs.CustomNpcs;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.HashSet;
import java.util.Set;
/**
* Controller for managing auction house item blacklisting.
* Allows administrators to block specific items, entire mods,
* or items with certain NBT tags from being listed.
*/
public class AuctionBlacklist {
private static final Logger logger = LogManager.getLogger(CustomNpcs.class);
public static AuctionBlacklist Instance;
// Blacklist by item registry name (e.g., "minecraft:diamond_sword")
private Set<String> blacklistedItems = new HashSet<>();
// Blacklist by mod ID (e.g., "minecraft" blocks all vanilla items)
private Set<String> blacklistedMods = new HashSet<>();
// Blacklist by NBT tag presence (e.g., items with specific custom data)
private Set<String> blacklistedNBTTags = new HashSet<>();
public AuctionBlacklist() {
Instance = this;
load();
}
// ==================== Blacklist Checking ====================
/**
* Check if an item is blacklisted from the auction house.
*
* @param item The item to check
* @return true if the item is blacklisted
*/
public boolean isBlacklisted(ItemStack item) {
if (item == null || item.getItem() == null) {
return false;
}
// Check item registry name
String itemName = Item.itemRegistry.getNameForObject(item.getItem());
if (itemName != null) {
// Direct item blacklist
if (blacklistedItems.contains(itemName)) {
return true;
}
// Also check with metadata for specific variants
String itemNameWithMeta = itemName + ":" + item.getItemDamage();
if (blacklistedItems.contains(itemNameWithMeta)) {
return true;
}
// Check mod ID
String modId = getModIdFromName(itemName);
if (modId != null && blacklistedMods.contains(modId)) {
return true;
}
}
// Check NBT tags
if (item.hasTagCompound()) {
NBTTagCompound tag = item.getTagCompound();
for (String nbtTag : blacklistedNBTTags) {
if (hasNestedTag(tag, nbtTag)) {
return true;
}
}
}
return false;
}
/**
* Get the reason why an item is blacklisted
* @return Description of why blacklisted, or null if not blacklisted
*/
public String getBlacklistReason(ItemStack item) {
if (item == null || item.getItem() == null) {
return null;
}
String itemName = Item.itemRegistry.getNameForObject(item.getItem());
if (itemName != null) {
if (blacklistedItems.contains(itemName)) {
return "Item is blacklisted: " + itemName;
}
String itemNameWithMeta = itemName + ":" + item.getItemDamage();
if (blacklistedItems.contains(itemNameWithMeta)) {
return "Item variant is blacklisted: " + itemNameWithMeta;
}
String modId = getModIdFromName(itemName);
if (modId != null && blacklistedMods.contains(modId)) {
return "Mod is blacklisted: " + modId;
}
}
if (item.hasTagCompound()) {
NBTTagCompound tag = item.getTagCompound();
for (String nbtTag : blacklistedNBTTags) {
if (hasNestedTag(tag, nbtTag)) {
return "Item has blacklisted NBT tag: " + nbtTag;
}
}
}
return null;
}
/**
* Extract mod ID from registry name (e.g., "minecraft" from "minecraft:stone")
*/
private String getModIdFromName(String registryName) {
if (registryName == null) {
return null;
}
int colonIndex = registryName.indexOf(':');
if (colonIndex > 0) {
return registryName.substring(0, colonIndex);
}
return null;
}
/**
* Check for nested NBT tag (supports dot notation like "display.Name")
*/
private boolean hasNestedTag(NBTTagCompound tag, String path) {
if (tag == null || path == null || path.isEmpty()) {
return false;
}
String[] parts = path.split("\\.");
NBTTagCompound current = tag;
for (int i = 0; i < parts.length - 1; i++) {
if (!current.hasKey(parts[i])) {
return false;
}
if (current.hasKey(parts[i], 10)) { // 10 = Compound tag
current = current.getCompoundTag(parts[i]);
} else {
return false;
}
}
return current.hasKey(parts[parts.length - 1]);
}
// ==================== Item Blacklist Management ====================
/**
* Add an item to the blacklist by registry name
* @param itemName Registry name (e.g., "minecraft:diamond_sword" or "minecraft:wool:14")
*/
public void addItem(String itemName) {
if (itemName != null && !itemName.isEmpty()) {
blacklistedItems.add(itemName);
save();
logger.info("Added item to auction blacklist: " + itemName);
}
}
/**
* Add an item to the blacklist from an ItemStack
*/
public void addItem(ItemStack item, boolean includeMeta) {
if (item == null || item.getItem() == null) {
return;
}
String itemName = Item.itemRegistry.getNameForObject(item.getItem());
if (itemName != null) {
if (includeMeta && item.getHasSubtypes()) {
addItem(itemName + ":" + item.getItemDamage());
} else {
addItem(itemName);
}
}
}
/**
* Remove an item from the blacklist
*/
public void removeItem(String itemName) {
if (blacklistedItems.remove(itemName)) {
save();
logger.info("Removed item from auction blacklist: " + itemName);
}
}
/**
* Check if a specific item is blacklisted
*/
public boolean isItemBlacklisted(String itemName) {
return blacklistedItems.contains(itemName);
}
/**
* Get all blacklisted items
*/
public Set<String> getBlacklistedItems() {
return new HashSet<>(blacklistedItems);
}
// ==================== Mod Blacklist Management ====================
/**
* Add an entire mod to the blacklist
* @param modId The mod ID (e.g., "minecraft", "customnpcs")
*/
public void addMod(String modId) {
if (modId != null && !modId.isEmpty()) {
blacklistedMods.add(modId);
save();
logger.info("Added mod to auction blacklist: " + modId);
}
}
/**
* Remove a mod from the blacklist
*/
public void removeMod(String modId) {
if (blacklistedMods.remove(modId)) {
save();
logger.info("Removed mod from auction blacklist: " + modId);
}
}
/**
* Check if a mod is blacklisted
*/
public boolean isModBlacklisted(String modId) {
return blacklistedMods.contains(modId);
}
/**
* Get all blacklisted mods
*/
public Set<String> getBlacklistedMods() {
return new HashSet<>(blacklistedMods);
}
// ==================== NBT Tag Blacklist Management ====================
/**
* Add an NBT tag to the blacklist
* Items containing this tag will be blocked
* @param tagPath The tag path (e.g., "display.Name" or "CustomData")
*/
public void addNBTTag(String tagPath) {
if (tagPath != null && !tagPath.isEmpty()) {
blacklistedNBTTags.add(tagPath);
save();
logger.info("Added NBT tag to auction blacklist: " + tagPath);
}
}
/**
* Remove an NBT tag from the blacklist
*/
public void removeNBTTag(String tagPath) {
if (blacklistedNBTTags.remove(tagPath)) {
save();
logger.info("Removed NBT tag from auction blacklist: " + tagPath);
}
}
/**
* Check if an NBT tag is blacklisted
*/
public boolean isNBTTagBlacklisted(String tagPath) {
return blacklistedNBTTags.contains(tagPath);
}
/**
* Get all blacklisted NBT tags
*/
public Set<String> getBlacklistedNBTTags() {
return new HashSet<>(blacklistedNBTTags);
}
// ==================== Persistence ====================
public void save() {
File saveDir = CustomNpcs.getWorldSaveDirectory();
if (saveDir == null) {
return;
}
try {
NBTTagCompound compound = new NBTTagCompound();
// Save blacklisted items
NBTTagList itemList = new NBTTagList();
for (String item : blacklistedItems) {
itemList.appendTag(new NBTTagString(item));
}
compound.setTag("Items", itemList);
// Save blacklisted mods
NBTTagList modList = new NBTTagList();
for (String mod : blacklistedMods) {
modList.appendTag(new NBTTagString(mod));
}
compound.setTag("Mods", modList);
// Save blacklisted NBT tags
NBTTagList nbtList = new NBTTagList();
for (String nbt : blacklistedNBTTags) {
nbtList.appendTag(new NBTTagString(nbt));
}
compound.setTag("NBTTags", nbtList);
// Write to file
File file = new File(saveDir, "auction_blacklist.dat");
File backup = new File(saveDir, "auction_blacklist.dat_old");
if (file.exists()) {
if (backup.exists()) {
backup.delete();
}
file.renameTo(backup);
}
file = new File(saveDir, "auction_blacklist.dat");
FileOutputStream fos = new FileOutputStream(file);
CompressedStreamTools.writeCompressed(compound, fos);
fos.close();
} catch (Exception e) {
logger.error("Error saving auction blacklist", e);
}
}
public void load() {
File saveDir = CustomNpcs.getWorldSaveDirectory();
if (saveDir == null) {
return;
}
blacklistedItems.clear();
blacklistedMods.clear();
blacklistedNBTTags.clear();
try {
File file = new File(saveDir, "auction_blacklist.dat");
if (!file.exists()) {
// Try backup
file = new File(saveDir, "auction_blacklist.dat_old");
if (!file.exists()) {
return;
}
}
FileInputStream fis = new FileInputStream(file);
NBTTagCompound compound = CompressedStreamTools.readCompressed(fis);
fis.close();
// Load blacklisted items
NBTTagList itemList = compound.getTagList("Items", 8); // 8 = String tag
for (int i = 0; i < itemList.tagCount(); i++) {
blacklistedItems.add(itemList.getStringTagAt(i));
}
// Load blacklisted mods
NBTTagList modList = compound.getTagList("Mods", 8);
for (int i = 0; i < modList.tagCount(); i++) {
blacklistedMods.add(modList.getStringTagAt(i));
}
// Load blacklisted NBT tags
NBTTagList nbtList = compound.getTagList("NBTTags", 8);
for (int i = 0; i < nbtList.tagCount(); i++) {
blacklistedNBTTags.add(nbtList.getStringTagAt(i));
}
logger.info("Loaded auction blacklist: {} items, {} mods, {} NBT tags",
blacklistedItems.size(), blacklistedMods.size(), blacklistedNBTTags.size());
} catch (Exception e) {
logger.error("Error loading auction blacklist", e);
}
}
/**
* Clear all blacklist entries
*/
public void clearAll() {
blacklistedItems.clear();
blacklistedMods.clear();
blacklistedNBTTags.clear();
save();
logger.info("Cleared all auction blacklist entries");
}
/**
* Get total number of blacklist entries
*/
public int getTotalEntries() {
return blacklistedItems.size() + blacklistedMods.size() + blacklistedNBTTags.size();
}
}
@@ -0,0 +1,834 @@
package noppes.npcs.controllers;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.CompressedStreamTools;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.EnumChatFormatting;
import noppes.npcs.CustomNpcs;
import noppes.npcs.LogWriter;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.constants.EnumAuctionDuration;
import noppes.npcs.constants.EnumAuctionSort;
import noppes.npcs.constants.EnumAuctionStatus;
import noppes.npcs.controllers.data.AuctionFilter;
import noppes.npcs.controllers.data.AuctionListing;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* Controller for the global auction house.
* Manages all auction listings, bidding, claims, notifications, and logging.
*/
public class AuctionController {
private static final String LOG_PREFIX = "[Auction] ";
public static AuctionController Instance;
// All auction listings by ID
private Map<Integer, AuctionListing> listings = new ConcurrentHashMap<>();
// Next available listing ID
private int nextId = 1;
// Indices for fast lookup
private Map<UUID, List<Integer>> listingsBySeller = new ConcurrentHashMap<>();
private Map<UUID, List<Integer>> listingsByBidder = new ConcurrentHashMap<>();
// Pending notifications for offline players
private Map<UUID, List<String>> pendingNotifications = new ConcurrentHashMap<>();
public AuctionController() {
Instance = this;
load();
}
// ==================== Listing Management ====================
/**
* Create a new auction listing
* @return The new listing, or null if creation failed
*/
public AuctionListing createListing(EntityPlayer seller, ItemStack item,
long startingPrice, long buyoutPrice,
EnumAuctionDuration duration) {
// Validate item
String validation = AuctionListing.validateItem(item);
if (validation != null) {
LogWriter.info(LOG_PREFIX + "Listing validation failed: " + validation);
return null;
}
// Check seller's listing limit
int currentListings = getActiveListingsCount(seller.getUniqueID());
int maxListings = getMaxListings(seller);
if (currentListings >= maxListings) {
return null;
}
// Calculate and charge listing fee
AuctionListing listing = new AuctionListing(
seller.getUniqueID(),
seller.getCommandSenderName(),
item,
startingPrice,
buyoutPrice,
duration
);
long listingFee = listing.getListingFee();
if (listingFee > 0) {
if (!CurrencyController.Instance.canAfford(seller, listingFee)) {
return null;
}
CurrencyController.Instance.withdraw(seller, listingFee);
}
// Assign ID and store
listing.id = nextId++;
listings.put(listing.id, listing);
// Update indices
addToSellerIndex(seller.getUniqueID(), listing.id);
save();
// Log to CNPC+
logEvent("LISTING_CREATED", String.format("ID=%d, Seller=%s, Item=%s x%d, StartPrice=%d, Buyout=%s",
listing.id, listing.sellerName, item.getDisplayName(), item.stackSize,
listing.startingPrice, listing.buyoutPrice > 0 ? listing.buyoutPrice : "None"));
return listing;
}
/**
* Get a listing by ID
*/
public AuctionListing getListing(int id) {
return listings.get(id);
}
/**
* Get all active listings
*/
public List<AuctionListing> getActiveListings() {
processExpiredAuctions();
return listings.values().stream()
.filter(AuctionListing::isActive)
.collect(Collectors.toList());
}
/**
* Search listings by item name
*/
public List<AuctionListing> searchListings(String query) {
String lowerQuery = query.toLowerCase();
return getActiveListings().stream()
.filter(l -> l.item != null)
.filter(l -> l.item.getDisplayName().toLowerCase().contains(lowerQuery))
.collect(Collectors.toList());
}
// ==================== Filtering & Sorting ====================
/**
* Get filtered and sorted auction listings.
* @param filter The filter criteria
* @return FilterResult containing matching listings and metadata
*/
public FilterResult getFilteredListings(AuctionFilter filter) {
processExpiredAuctions();
// Get all active listings
List<AuctionListing> results = listings.values().stream()
.filter(AuctionListing::isActive)
.filter(filter::matches)
.collect(Collectors.toList());
// Sort the results
sortListings(results, filter.sortOrder);
// Calculate pagination
int totalResults = results.size();
int totalPages = totalResults == 0
? 0
: Math.max(1, (int) Math.ceil((double) totalResults / filter.pageSize));
int currentPage = Math.max(0, filter.page);
if (totalPages > 0 && currentPage >= totalPages) {
currentPage = totalPages - 1;
}
int startIndex = currentPage * filter.pageSize;
int endIndex = Math.min(startIndex + filter.pageSize, totalResults);
// Get the page slice
List<AuctionListing> pageResults;
if (startIndex >= totalResults) {
pageResults = new ArrayList<>();
} else {
pageResults = new ArrayList<>(results.subList(startIndex, endIndex));
}
return new FilterResult(pageResults, totalResults, currentPage, totalPages);
}
/**
* Sort listings according to the specified sort order
*/
public void sortListings(List<AuctionListing> listings, EnumAuctionSort sortOrder) {
if (listings == null || listings.isEmpty()) {
return;
}
Comparator<AuctionListing> comparator;
switch (sortOrder) {
case NEWEST_FIRST:
comparator = Comparator.comparingLong(l -> -l.listingTime);
break;
case OLDEST_FIRST:
comparator = Comparator.comparingLong(l -> l.listingTime);
break;
case PRICE_HIGH_TO_LOW:
comparator = Comparator.comparingLong((AuctionListing l) ->
-(l.currentBid > 0 ? l.currentBid : l.startingPrice));
break;
case PRICE_LOW_TO_HIGH:
comparator = Comparator.comparingLong(l ->
l.currentBid > 0 ? l.currentBid : l.startingPrice);
break;
case ENDING_SOON:
comparator = Comparator.comparingLong(l -> l.expirationTime);
break;
case MOST_TIME_LEFT:
comparator = Comparator.comparingLong(l -> -l.expirationTime);
break;
case NAME_A_TO_Z:
comparator = Comparator.comparing(l -> getListingName(l).toLowerCase());
break;
case NAME_Z_TO_A:
comparator = Comparator.comparing((AuctionListing l) ->
getListingName(l).toLowerCase()).reversed();
break;
case MOST_BIDS:
comparator = Comparator.comparingInt(l -> -l.bidCount);
break;
case LEAST_BIDS:
comparator = Comparator.comparingInt(l -> l.bidCount);
break;
default:
comparator = Comparator.comparingLong(l -> l.expirationTime);
}
listings.sort(comparator);
}
/**
* Result container for filtered queries
*/
public static class FilterResult {
public final List<AuctionListing> listings;
public final int totalResults;
public final int currentPage;
public final int totalPages;
public FilterResult(List<AuctionListing> listings, int totalResults,
int currentPage, int totalPages) {
this.listings = listings;
this.totalResults = totalResults;
this.currentPage = currentPage;
this.totalPages = totalPages;
}
public boolean hasNextPage() {
return currentPage < totalPages - 1;
}
public boolean hasPreviousPage() {
return currentPage > 0;
}
public boolean isEmpty() {
return listings == null || listings.isEmpty();
}
}
/**
* Get all listings by a seller
*/
public List<AuctionListing> getListingsBySeller(UUID sellerUUID) {
List<Integer> ids = listingsBySeller.get(sellerUUID);
if (ids == null) {
return new ArrayList<>();
}
return ids.stream()
.map(listings::get)
.filter(Objects::nonNull)
.collect(Collectors.toList());
}
/**
* Get active listing count for a seller
*/
public int getActiveListingsCount(UUID sellerUUID) {
return (int) getListingsBySeller(sellerUUID).stream()
.filter(l -> l.status == EnumAuctionStatus.ACTIVE)
.count();
}
/**
* Get listings where player is the high bidder
*/
public List<AuctionListing> getListingsAsBidder(UUID bidderUUID) {
List<Integer> ids = listingsByBidder.get(bidderUUID);
if (ids == null) {
return new ArrayList<>();
}
return ids.stream()
.map(listings::get)
.filter(Objects::nonNull)
.filter(AuctionListing::isActive)
.filter(l -> bidderUUID.equals(l.highBidderUUID))
.collect(Collectors.toList());
}
/**
* Get listings that need claiming by a player
*/
public List<AuctionListing> getClaimableListings(UUID playerUUID) {
List<AuctionListing> claimable = new ArrayList<>();
for (AuctionListing listing : listings.values()) {
// Seller can claim proceeds from sold items
if (listing.sellerUUID.equals(playerUUID) &&
listing.status == EnumAuctionStatus.SOLD &&
!listing.sellerClaimed) {
claimable.add(listing);
}
// Seller can claim back cancelled/expired items
if (listing.sellerUUID.equals(playerUUID) &&
(listing.status == EnumAuctionStatus.CANCELLED ||
listing.status == EnumAuctionStatus.EXPIRED) &&
!listing.sellerClaimed) {
claimable.add(listing);
}
// Buyer can claim won items
if (listing.highBidderUUID != null &&
listing.highBidderUUID.equals(playerUUID) &&
listing.status == EnumAuctionStatus.SOLD &&
!listing.buyerClaimed) {
claimable.add(listing);
}
}
return claimable;
}
// ==================== Bidding ====================
/**
* Place a bid on an auction
*/
public boolean placeBid(int listingId, EntityPlayer bidder, long amount) {
AuctionListing listing = listings.get(listingId);
if (listing == null) {
return false;
}
if (!CurrencyController.Instance.canAfford(bidder, amount)) {
return false;
}
// Store previous bidder for refund
UUID previousBidder = listing.highBidderUUID;
String previousBidderName = listing.highBidderName;
long previousBidAmount = listing.currentBid;
if (!listing.placeBid(bidder.getUniqueID(), bidder.getCommandSenderName(), amount)) {
return false;
}
CurrencyController.Instance.withdraw(bidder, amount);
// Refund previous bidder
if (previousBidder != null) {
CurrencyController.Instance.addClaim(previousBidder, previousBidAmount,
"Auction Outbid", String.valueOf(listingId));
// Notify outbid player
notifyPlayer(previousBidder, EnumChatFormatting.RED +
"You have been outbid on " + EnumChatFormatting.WHITE + listing.item.getDisplayName() +
EnumChatFormatting.RED + "! New bid: " + formatCurrency(amount));
logEvent("OUTBID", String.format("ID=%d, OutbidPlayer=%s, PrevBid=%d, NewBid=%d",
listingId, previousBidderName, previousBidAmount, amount));
}
// Notify seller
notifyPlayer(listing.sellerUUID, EnumChatFormatting.AQUA +
bidder.getCommandSenderName() + " placed a bid of " + formatCurrency(amount) +
" on your " + listing.item.getDisplayName() + "!");
addToBidderIndex(bidder.getUniqueID(), listingId);
save();
logEvent("BID_PLACED", String.format("ID=%d, Bidder=%s, Amount=%d",
listingId, bidder.getCommandSenderName(), amount));
return true;
}
/**
* Execute buyout on an auction
*/
public boolean buyout(int listingId, EntityPlayer buyer) {
AuctionListing listing = listings.get(listingId);
if (listing == null || listing.buyoutPrice <= 0) {
return false;
}
if (!CurrencyController.Instance.canAfford(buyer, listing.buyoutPrice)) {
return false;
}
UUID previousBidder = listing.highBidderUUID;
String previousBidderName = listing.highBidderName;
long previousBidAmount = listing.currentBid;
if (!listing.buyout(buyer.getUniqueID(), buyer.getCommandSenderName())) {
return false;
}
CurrencyController.Instance.withdraw(buyer, listing.buyoutPrice);
// Refund previous bidder
if (previousBidder != null) {
CurrencyController.Instance.addClaim(previousBidder, previousBidAmount,
"Auction Outbid (Buyout)", String.valueOf(listingId));
notifyPlayer(previousBidder, EnumChatFormatting.RED +
"Your bid on " + EnumChatFormatting.WHITE + listing.item.getDisplayName() +
EnumChatFormatting.RED + " was outbid by a buyout. Your " +
formatCurrency(previousBidAmount) + " has been refunded.");
}
addToBidderIndex(buyer.getUniqueID(), listingId);
save();
// Notify buyer and seller
notifyPlayer(buyer.getUniqueID(), EnumChatFormatting.GREEN +
"Buyout successful! Claim your " + listing.item.getDisplayName() + " from an Auctioneer.");
notifyPlayer(listing.sellerUUID, EnumChatFormatting.GREEN +
"Your " + listing.item.getDisplayName() + " was bought out for " +
formatCurrency(listing.buyoutPrice) + "! Claim your proceeds.");
logEvent("BUYOUT", String.format("ID=%d, Buyer=%s, Price=%d, Seller=%s",
listingId, buyer.getCommandSenderName(), listing.buyoutPrice, listing.sellerName));
return true;
}
/**
* Cancel an auction listing
*/
public boolean cancelListing(int listingId, EntityPlayer requester, boolean forceCancel) {
AuctionListing listing = listings.get(listingId);
if (listing == null) {
return false;
}
boolean byAdmin = !listing.sellerUUID.equals(requester.getUniqueID());
if (byAdmin && !forceCancel) {
return false;
}
if (!forceCancel && listing.hasBids()) {
return false;
}
if (listing.status != EnumAuctionStatus.ACTIVE) {
return false;
}
if (forceCancel && listing.hasBids() && listing.highBidderUUID != null) {
CurrencyController.Instance.addClaim(listing.highBidderUUID, listing.currentBid,
"Auction Cancelled", String.valueOf(listingId));
notifyPlayer(listing.highBidderUUID, EnumChatFormatting.RED +
"Your bid on " + EnumChatFormatting.WHITE + listing.item.getDisplayName() +
EnumChatFormatting.RED + " was cancelled. Your " +
formatCurrency(listing.currentBid) + " has been refunded.");
}
listing.status = EnumAuctionStatus.CANCELLED;
save();
if (byAdmin) {
notifyPlayer(listing.sellerUUID, EnumChatFormatting.RED +
"Your auction for " + listing.item.getDisplayName() +
" was cancelled by an administrator.");
}
logEvent("CANCELLED", String.format("ID=%d, CancelledBy=%s, ByAdmin=%b",
listingId, requester.getCommandSenderName(), byAdmin));
return true;
}
// ==================== Claiming ====================
/**
* Claim seller proceeds from a sold auction
*/
public boolean claimSellerProceeds(int listingId, EntityPlayer seller) {
AuctionListing listing = listings.get(listingId);
if (listing == null || !listing.sellerUUID.equals(seller.getUniqueID()) ||
listing.status != EnumAuctionStatus.SOLD || listing.sellerClaimed) {
return false;
}
long proceeds = listing.getSellerProceeds();
CurrencyController.Instance.deposit(seller, proceeds);
listing.sellerClaimed = true;
checkAndMarkClaimed(listing);
save();
logEvent("PROCEEDS_CLAIMED", String.format("ID=%d, Seller=%s, Amount=%d",
listingId, seller.getCommandSenderName(), proceeds));
return true;
}
/**
* Claim item from won auction
*/
public ItemStack claimBuyerItem(int listingId, EntityPlayer buyer) {
AuctionListing listing = listings.get(listingId);
if (listing == null || listing.highBidderUUID == null ||
!listing.highBidderUUID.equals(buyer.getUniqueID()) ||
listing.status != EnumAuctionStatus.SOLD || listing.buyerClaimed) {
return null;
}
listing.buyerClaimed = true;
checkAndMarkClaimed(listing);
save();
logEvent("ITEM_CLAIMED", String.format("ID=%d, Buyer=%s, Item=%s",
listingId, buyer.getCommandSenderName(), listing.item.getDisplayName()));
return listing.item.copy();
}
/**
* Claim item from cancelled or expired auction
*/
public ItemStack claimExpiredItem(int listingId, EntityPlayer seller) {
AuctionListing listing = listings.get(listingId);
if (listing == null || !listing.sellerUUID.equals(seller.getUniqueID()) ||
(listing.status != EnumAuctionStatus.CANCELLED && listing.status != EnumAuctionStatus.EXPIRED) ||
listing.sellerClaimed) {
return null;
}
listing.sellerClaimed = true;
listing.status = EnumAuctionStatus.CLAIMED;
save();
logEvent("ITEM_RECLAIMED", String.format("ID=%d, Seller=%s, Item=%s",
listingId, seller.getCommandSenderName(), listing.item.getDisplayName()));
return listing.item.copy();
}
private void checkAndMarkClaimed(AuctionListing listing) {
if (listing.status == EnumAuctionStatus.SOLD &&
listing.sellerClaimed && listing.buyerClaimed) {
listing.status = EnumAuctionStatus.CLAIMED;
}
}
// ==================== Expiration Processing ====================
/**
* Process all expired auctions
*/
public void processExpiredAuctions() {
boolean changed = false;
for (AuctionListing listing : listings.values()) {
if (listing.status == EnumAuctionStatus.ACTIVE && listing.isExpired()) {
listing.finalize();
changed = true;
if (listing.status == EnumAuctionStatus.SOLD) {
// Notify winner and seller
notifyPlayer(listing.highBidderUUID, EnumChatFormatting.GREEN +
"You won the auction for " + listing.item.getDisplayName() +
" for " + formatCurrency(listing.currentBid) + "! Claim your item.");
notifyPlayer(listing.sellerUUID, EnumChatFormatting.GREEN +
"Your " + listing.item.getDisplayName() + " sold for " +
formatCurrency(listing.currentBid) + "! Claim your proceeds.");
logEvent("AUCTION_SOLD", String.format("ID=%d, Winner=%s, Price=%d, Seller=%s",
listing.id, listing.highBidderName, listing.currentBid, listing.sellerName));
} else {
notifyPlayer(listing.sellerUUID, EnumChatFormatting.GRAY +
"Your auction for " + listing.item.getDisplayName() +
" has expired with no bids. Claim your item.");
logEvent("AUCTION_EXPIRED", String.format("ID=%d, Item=%s, Seller=%s",
listing.id, listing.item.getDisplayName(), listing.sellerName));
}
}
}
if (changed) {
save();
}
}
/**
* Clean up old claimed listings
*/
public void cleanupOldListings() {
long claimExpirationMs = ConfigMarket.ClaimExpirationDays * 24L * 60L * 60L * 1000L;
if (claimExpirationMs <= 0) return;
long cutoffTime = System.currentTimeMillis() - claimExpirationMs;
List<Integer> toRemove = new ArrayList<>();
for (AuctionListing listing : listings.values()) {
if (listing.status == EnumAuctionStatus.CLAIMED &&
listing.expirationTime < cutoffTime) {
toRemove.add(listing.id);
}
}
for (int id : toRemove) {
AuctionListing removed = listings.remove(id);
if (removed != null) {
removeFromSellerIndex(removed.sellerUUID, id);
if (removed.highBidderUUID != null) {
removeFromBidderIndex(removed.highBidderUUID, id);
}
}
}
if (!toRemove.isEmpty()) {
save();
logEvent("CLEANUP", "Removed " + toRemove.size() + " old listings");
}
}
// ==================== Notifications ====================
/**
* Send notification to player (or queue if offline)
*/
private void notifyPlayer(UUID playerUUID, String message) {
if (playerUUID == null) return;
EntityPlayerMP player = getOnlinePlayer(playerUUID);
String fullMessage = EnumChatFormatting.YELLOW + "[Auction] " + message;
if (player != null) {
player.addChatMessage(new ChatComponentText(fullMessage));
} else {
pendingNotifications.computeIfAbsent(playerUUID, k -> new ArrayList<>()).add(fullMessage);
// Limit queue size
List<String> queue = pendingNotifications.get(playerUUID);
while (queue.size() > 50) {
queue.remove(0);
}
}
}
/**
* Send pending notifications on player login
*/
public void onPlayerLogin(EntityPlayerMP player) {
UUID uuid = player.getUniqueID();
List<String> notifications = pendingNotifications.remove(uuid);
if (notifications != null && !notifications.isEmpty()) {
player.addChatMessage(new ChatComponentText(
EnumChatFormatting.YELLOW + "[Auction] " + EnumChatFormatting.WHITE +
"You have " + notifications.size() + " auction notification(s):"));
for (String msg : notifications) {
player.addChatMessage(new ChatComponentText(msg));
}
}
// Check claimable items
int claimableCount = getClaimableListings(uuid).size();
if (claimableCount > 0) {
player.addChatMessage(new ChatComponentText(
EnumChatFormatting.YELLOW + "[Auction] " + EnumChatFormatting.GREEN +
"You have " + claimableCount + " item(s) waiting to be claimed!"));
}
}
private EntityPlayerMP getOnlinePlayer(UUID uuid) {
if (CustomNpcs.getServer() == null) return null;
for (Object obj : CustomNpcs.getServer().getConfigurationManager().playerEntityList) {
EntityPlayerMP player = (EntityPlayerMP) obj;
if (player.getUniqueID().equals(uuid)) {
return player;
}
}
return null;
}
// ==================== Index Management ====================
private void addToSellerIndex(UUID seller, int listingId) {
listingsBySeller.computeIfAbsent(seller, k -> new ArrayList<>()).add(listingId);
}
private void removeFromSellerIndex(UUID seller, int listingId) {
List<Integer> ids = listingsBySeller.get(seller);
if (ids != null) {
ids.remove(Integer.valueOf(listingId));
}
}
private void addToBidderIndex(UUID bidder, int listingId) {
listingsByBidder.computeIfAbsent(bidder, k -> new ArrayList<>()).add(listingId);
}
private void removeFromBidderIndex(UUID bidder, int listingId) {
List<Integer> ids = listingsByBidder.get(bidder);
if (ids != null) {
ids.remove(Integer.valueOf(listingId));
}
}
private void rebuildIndices() {
listingsBySeller.clear();
listingsByBidder.clear();
for (AuctionListing listing : listings.values()) {
addToSellerIndex(listing.sellerUUID, listing.id);
if (listing.highBidderUUID != null) {
addToBidderIndex(listing.highBidderUUID, listing.id);
}
}
}
// ==================== Helpers ====================
public int getMaxListings(EntityPlayer player) {
return ConfigMarket.DefaultMaxListings;
}
private String formatCurrency(long amount) {
return String.format("%,d %s", amount, ConfigMarket.CurrencyName);
}
private void logEvent(String event, String details) {
LogWriter.info(LOG_PREFIX + event + ": " + details);
}
private String getListingName(AuctionListing listing) {
if (listing == null || listing.item == null) {
return "";
}
return listing.item.getDisplayName();
}
// ==================== Persistence ====================
public void save() {
File saveDir = CustomNpcs.getWorldSaveDirectory();
if (saveDir == null) return;
try {
NBTTagCompound compound = new NBTTagCompound();
compound.setInteger("NextId", nextId);
NBTTagList listingList = new NBTTagList();
for (AuctionListing listing : listings.values()) {
listingList.appendTag(listing.writeToNBT(new NBTTagCompound()));
}
compound.setTag("Listings", listingList);
File file = new File(saveDir, "auctions.dat");
File backup = new File(saveDir, "auctions.dat_old");
if (file.exists()) {
if (backup.exists()) backup.delete();
file.renameTo(backup);
}
file = new File(saveDir, "auctions.dat");
FileOutputStream fos = new FileOutputStream(file);
CompressedStreamTools.writeCompressed(compound, fos);
fos.close();
} catch (Exception e) {
LogWriter.error(LOG_PREFIX + "Error saving auctions", e);
}
}
public void load() {
File saveDir = CustomNpcs.getWorldSaveDirectory();
if (saveDir == null) return;
listings.clear();
try {
File file = new File(saveDir, "auctions.dat");
if (!file.exists()) {
file = new File(saveDir, "auctions.dat_old");
if (!file.exists()) return;
}
FileInputStream fis = new FileInputStream(file);
NBTTagCompound compound = CompressedStreamTools.readCompressed(fis);
fis.close();
nextId = compound.getInteger("NextId");
if (nextId < 1) nextId = 1;
NBTTagList listingList = compound.getTagList("Listings", 10);
for (int i = 0; i < listingList.tagCount(); i++) {
AuctionListing listing = new AuctionListing();
listing.readFromNBT(listingList.getCompoundTagAt(i));
listings.put(listing.id, listing);
}
rebuildIndices();
logEvent("SYSTEM_STARTUP", String.format("Loaded %d listings, %d active",
listings.size(), getActiveListingCount()));
} catch (Exception e) {
LogWriter.error(LOG_PREFIX + "Error loading auctions", e);
}
}
// ==================== Statistics ====================
public int getActiveListingCount() {
return (int) listings.values().stream()
.filter(l -> l.status == EnumAuctionStatus.ACTIVE)
.count();
}
public int getTotalListingCount() {
return listings.size();
}
}
@@ -0,0 +1,400 @@
package noppes.npcs.controllers;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.CompressedStreamTools;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import noppes.npcs.CustomNpcs;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.controllers.data.PlayerData;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.*;
/**
* Controller for managing currency operations including:
* - Claims system (for auction refunds, NPC payments, etc.)
* - Transaction history
* - Currency administration
*
* Delegates actual balance operations to VaultHelper.
*/
public class CurrencyController {
private static final Logger logger = LogManager.getLogger(CustomNpcs.class);
public static CurrencyController Instance;
// Pending claims per player UUID - claims that can be collected
private Map<UUID, List<CurrencyClaim>> pendingClaims = new HashMap<>();
// File path for persistence
private String filePath = "";
public CurrencyController() {
Instance = this;
load();
}
/**
* Get player's current balance
*/
public long getBalance(EntityPlayer player) {
return VaultHelper.Instance.getBalance(player);
}
/**
* Deposit currency directly to player's balance
*/
public boolean deposit(EntityPlayer player, long amount) {
return VaultHelper.Instance.deposit(player, amount);
}
/**
* Withdraw currency from player's balance
*/
public boolean withdraw(EntityPlayer player, long amount) {
return VaultHelper.Instance.withdraw(player, amount);
}
/**
* Check if player can afford an amount
*/
public boolean canAfford(EntityPlayer player, long amount) {
return VaultHelper.Instance.canAfford(player, amount);
}
/**
* Transfer currency between players
*/
public boolean transfer(EntityPlayer from, EntityPlayer to, long amount) {
return VaultHelper.Instance.transfer(from, to, amount);
}
/**
* Format amount for display
*/
public String formatAmount(long amount) {
return VaultHelper.Instance.formatAmount(amount);
}
// ==================== CLAIMS SYSTEM ====================
/**
* Add a claim for a player (e.g., auction refund, NPC payment)
* Claims can be collected later by the player.
*
* @param playerUUID The player's UUID
* @param amount The amount to claim
* @param source Description of where this claim came from
* @param sourceId Optional ID of the source (e.g., auction ID)
*/
public void addClaim(UUID playerUUID, long amount, String source, String sourceId) {
if (amount <= 0) {
return;
}
CurrencyClaim claim = new CurrencyClaim();
claim.amount = amount;
claim.source = source;
claim.sourceId = sourceId;
claim.timestamp = System.currentTimeMillis();
claim.expiresAt = claim.timestamp + (ConfigMarket.ClaimExpirationDays * 24L * 60L * 60L * 1000L);
List<CurrencyClaim> claims = pendingClaims.computeIfAbsent(playerUUID, k -> new ArrayList<>());
claims.add(claim);
save();
logger.info("Added claim of {} for player {} from {}", amount, playerUUID, source);
}
/**
* Get all pending claims for a player
*/
public List<CurrencyClaim> getPendingClaims(EntityPlayer player) {
return getPendingClaims(player.getUniqueID());
}
/**
* Get all pending claims for a player by UUID
*/
public List<CurrencyClaim> getPendingClaims(UUID playerUUID) {
List<CurrencyClaim> claims = pendingClaims.get(playerUUID);
if (claims == null) {
return new ArrayList<>();
}
// Filter out expired claims
long now = System.currentTimeMillis();
claims.removeIf(claim -> claim.expiresAt > 0 && claim.expiresAt < now);
return new ArrayList<>(claims);
}
/**
* Get total pending claim amount for a player
*/
public long getTotalPendingClaims(EntityPlayer player) {
return getTotalPendingClaims(player.getUniqueID());
}
/**
* Get total pending claim amount for a player by UUID
*/
public long getTotalPendingClaims(UUID playerUUID) {
List<CurrencyClaim> claims = getPendingClaims(playerUUID);
long total = 0;
for (CurrencyClaim claim : claims) {
total += claim.amount;
}
return total;
}
/**
* Claim all pending claims for a player
* @return Amount successfully claimed
*/
public long claimAll(EntityPlayer player) {
List<CurrencyClaim> claims = getPendingClaims(player);
if (claims.isEmpty()) {
return 0;
}
long totalClaimed = 0;
for (CurrencyClaim claim : claims) {
if (deposit(player, claim.amount)) {
totalClaimed += claim.amount;
}
}
// Clear claims after successful deposit
pendingClaims.remove(player.getUniqueID());
save();
return totalClaimed;
}
/**
* Claim a specific claim by index
* @return true if successful
*/
public boolean claimSingle(EntityPlayer player, int claimIndex) {
List<CurrencyClaim> claims = pendingClaims.get(player.getUniqueID());
if (claims == null || claimIndex < 0 || claimIndex >= claims.size()) {
return false;
}
CurrencyClaim claim = claims.get(claimIndex);
if (deposit(player, claim.amount)) {
claims.remove(claimIndex);
if (claims.isEmpty()) {
pendingClaims.remove(player.getUniqueID());
}
save();
return true;
}
return false;
}
/**
* Check if player has any pending claims
*/
public boolean hasPendingClaims(EntityPlayer player) {
return !getPendingClaims(player).isEmpty();
}
// ==================== PERSISTENCE ====================
public void load() {
File saveDir = CustomNpcs.getWorldSaveDirectory();
if (saveDir == null) {
return;
}
filePath = saveDir.getAbsolutePath();
pendingClaims.clear();
try {
File file = new File(saveDir, "currency_claims.dat");
if (file.exists()) {
loadFromFile(file);
}
} catch (Exception e) {
logger.error("Error loading currency claims", e);
try {
File file = new File(saveDir, "currency_claims.dat_old");
if (file.exists()) {
loadFromFile(file);
}
} catch (Exception ee) {
logger.error("Error loading backup currency claims", ee);
}
}
// Clean expired claims
cleanExpiredClaims();
}
private void loadFromFile(File file) throws Exception {
FileInputStream fis = new FileInputStream(file);
NBTTagCompound compound = CompressedStreamTools.readCompressed(fis);
fis.close();
NBTTagList claimsList = compound.getTagList("Claims", 10);
for (int i = 0; i < claimsList.tagCount(); i++) {
NBTTagCompound playerCompound = claimsList.getCompoundTagAt(i);
UUID playerUUID = UUID.fromString(playerCompound.getString("UUID"));
List<CurrencyClaim> playerClaims = new ArrayList<>();
NBTTagList playerClaimsList = playerCompound.getTagList("PlayerClaims", 10);
for (int j = 0; j < playerClaimsList.tagCount(); j++) {
NBTTagCompound claimCompound = playerClaimsList.getCompoundTagAt(j);
CurrencyClaim claim = new CurrencyClaim();
claim.readFromNBT(claimCompound);
playerClaims.add(claim);
}
if (!playerClaims.isEmpty()) {
pendingClaims.put(playerUUID, playerClaims);
}
}
logger.info("Loaded {} player claim records", pendingClaims.size());
}
public void save() {
File saveDir = CustomNpcs.getWorldSaveDirectory();
if (saveDir == null) {
return;
}
try {
File file = new File(saveDir, "currency_claims.dat");
File backup = new File(saveDir, "currency_claims.dat_old");
if (file.exists()) {
if (backup.exists()) {
backup.delete();
}
file.renameTo(backup);
}
NBTTagCompound compound = new NBTTagCompound();
NBTTagList claimsList = new NBTTagList();
for (Map.Entry<UUID, List<CurrencyClaim>> entry : pendingClaims.entrySet()) {
if (entry.getValue().isEmpty()) {
continue;
}
NBTTagCompound playerCompound = new NBTTagCompound();
playerCompound.setString("UUID", entry.getKey().toString());
NBTTagList playerClaimsList = new NBTTagList();
for (CurrencyClaim claim : entry.getValue()) {
NBTTagCompound claimCompound = new NBTTagCompound();
claim.writeToNBT(claimCompound);
playerClaimsList.appendTag(claimCompound);
}
playerCompound.setTag("PlayerClaims", playerClaimsList);
claimsList.appendTag(playerCompound);
}
compound.setTag("Claims", claimsList);
file = new File(saveDir, "currency_claims.dat");
FileOutputStream fos = new FileOutputStream(file);
CompressedStreamTools.writeCompressed(compound, fos);
fos.close();
} catch (Exception e) {
logger.error("Error saving currency claims", e);
}
}
/**
* Clean up expired claims
*/
public void cleanExpiredClaims() {
long now = System.currentTimeMillis();
boolean changed = false;
Iterator<Map.Entry<UUID, List<CurrencyClaim>>> it = pendingClaims.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<UUID, List<CurrencyClaim>> entry = it.next();
List<CurrencyClaim> claims = entry.getValue();
int before = claims.size();
claims.removeIf(claim -> claim.expiresAt > 0 && claim.expiresAt < now);
if (claims.size() != before) {
changed = true;
}
if (claims.isEmpty()) {
it.remove();
}
}
if (changed) {
save();
}
}
// ==================== CLAIM DATA CLASS ====================
public static class CurrencyClaim {
public long amount;
public String source; // e.g., "Auction Refund", "NPC Payment", "Quest Reward"
public String sourceId; // e.g., auction ID
public long timestamp; // When the claim was created
public long expiresAt; // When the claim expires (0 = never)
public void writeToNBT(NBTTagCompound compound) {
compound.setLong("Amount", amount);
compound.setString("Source", source != null ? source : "");
compound.setString("SourceId", sourceId != null ? sourceId : "");
compound.setLong("Timestamp", timestamp);
compound.setLong("ExpiresAt", expiresAt);
}
public void readFromNBT(NBTTagCompound compound) {
amount = compound.getLong("Amount");
source = compound.getString("Source");
sourceId = compound.getString("SourceId");
timestamp = compound.getLong("Timestamp");
expiresAt = compound.getLong("ExpiresAt");
}
/**
* Get formatted time remaining until expiration
*/
public String getTimeRemaining() {
if (expiresAt <= 0) {
return "Never";
}
long remaining = expiresAt - System.currentTimeMillis();
if (remaining <= 0) {
return "Expired";
}
long days = remaining / (24L * 60L * 60L * 1000L);
long hours = (remaining % (24L * 60L * 60L * 1000L)) / (60L * 60L * 1000L);
if (days > 0) {
return days + " days, " + hours + " hours";
} else if (hours > 0) {
return hours + " hours";
} else {
long minutes = remaining / (60L * 1000L);
return minutes + " minutes";
}
}
}
}
@@ -0,0 +1,272 @@
package noppes.npcs.controllers;
import net.minecraft.entity.player.EntityPlayer;
import noppes.npcs.CustomNpcs;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.controllers.data.PlayerData;
import noppes.npcs.controllers.PlayerDataController;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.lang.reflect.Method;
/**
* Helper class for VaultAPI integration on Bukkit hybrid servers.
* Uses reflection to integrate with Vault when available.
* Falls back to internal currency system when Vault is not present.
*/
public class VaultHelper {
private static final Logger logger = LogManager.getLogger(CustomNpcs.class);
public static VaultHelper Instance;
// Vault reflection references
private boolean vaultAvailable = false;
private Object economy = null;
private Method getBalance;
private Method depositPlayer;
private Method withdrawPlayer;
private Method hasAccount;
private Method createPlayerAccount;
private Method responseSuccess;
// Bukkit references for getting offline player
private Class<?> bukkitClass;
private Method getOfflinePlayer;
public VaultHelper() {
Instance = this;
if (!ConfigMarket.UseVaultIfAvailable) {
logger.info("Vault integration disabled by config");
return;
}
try {
// Check for Bukkit first
bukkitClass = Class.forName("org.bukkit.Bukkit");
getOfflinePlayer = bukkitClass.getMethod("getOfflinePlayer", String.class);
// Check for Vault
Class<?> vaultClass = Class.forName("net.milkbowl.vault.economy.Economy");
// Get the Economy service from Bukkit's ServicesManager
Method getServicesManager = bukkitClass.getMethod("getServicesManager");
Object servicesManager = getServicesManager.invoke(null);
Method getRegistration = servicesManager.getClass().getMethod("getRegistration", Class.class);
Object registration = getRegistration.invoke(servicesManager, vaultClass);
if (registration != null) {
Method getProvider = registration.getClass().getMethod("getProvider");
economy = getProvider.invoke(registration);
if (economy != null) {
// Get Economy methods - using OfflinePlayer versions for broader compatibility
Class<?> offlinePlayerClass = Class.forName("org.bukkit.OfflinePlayer");
getBalance = economy.getClass().getMethod("getBalance", offlinePlayerClass);
depositPlayer = economy.getClass().getMethod("depositPlayer", offlinePlayerClass, double.class);
withdrawPlayer = economy.getClass().getMethod("withdrawPlayer", offlinePlayerClass, double.class);
hasAccount = economy.getClass().getMethod("hasAccount", offlinePlayerClass);
createPlayerAccount = economy.getClass().getMethod("createPlayerAccount", offlinePlayerClass);
// EconomyResponse.transactionSuccess() method
Class<?> economyResponseClass = Class.forName("net.milkbowl.vault.economy.EconomyResponse");
responseSuccess = economyResponseClass.getField("transactionSuccess").getClass().getMethod("booleanValue");
vaultAvailable = true;
logger.info("Vault Economy integration enabled - using external economy");
}
}
if (!vaultAvailable) {
logger.info("Vault found but no Economy provider registered - using internal currency");
}
} catch (ClassNotFoundException e) {
// Vault not present - use internal currency
logger.info("Vault not found - using internal currency system");
} catch (Exception e) {
logger.warn("Error initializing Vault integration - using internal currency: " + e.getMessage());
}
}
/**
* Check if Vault economy is available and enabled
*/
public boolean isVaultEnabled() {
return vaultAvailable && ConfigMarket.UseVaultIfAvailable;
}
/**
* Get player's balance
* Uses Vault if available, otherwise internal currency
*/
public long getBalance(EntityPlayer player) {
if (isVaultEnabled()) {
try {
Object offlinePlayer = getOfflinePlayer.invoke(null, player.getCommandSenderName());
Double balance = (Double) getBalance.invoke(economy, offlinePlayer);
return balance.longValue();
} catch (Exception e) {
logger.warn("Vault getBalance failed, falling back to internal: " + e.getMessage());
}
}
// Fall back to internal currency
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
return data.currencyData.getBalance();
}
/**
* Deposit currency to player's balance
* Uses Vault if available, otherwise internal currency
* @return true if successful
*/
public boolean deposit(EntityPlayer player, long amount) {
if (amount <= 0) {
return false;
}
if (isVaultEnabled()) {
try {
Object offlinePlayer = getOfflinePlayer.invoke(null, player.getCommandSenderName());
// Ensure account exists
Boolean hasAcc = (Boolean) hasAccount.invoke(economy, offlinePlayer);
if (!hasAcc) {
createPlayerAccount.invoke(economy, offlinePlayer);
}
Object response = depositPlayer.invoke(economy, offlinePlayer, (double) amount);
// Check if transaction succeeded by checking the transactionSuccess field
Boolean success = (Boolean) response.getClass().getField("transactionSuccess").get(response);
if (success) {
// Also update internal tracking for statistics
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
data.currencyData.setBalance(getBalance(player));
return true;
}
return false;
} catch (Exception e) {
logger.warn("Vault deposit failed, falling back to internal: " + e.getMessage());
}
}
// Fall back to internal currency
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
boolean success = data.currencyData.deposit(amount);
if (success) {
data.save();
}
return success;
}
/**
* Withdraw currency from player's balance
* Uses Vault if available, otherwise internal currency
* @return true if successful
*/
public boolean withdraw(EntityPlayer player, long amount) {
if (amount <= 0) {
return false;
}
if (isVaultEnabled()) {
try {
Object offlinePlayer = getOfflinePlayer.invoke(null, player.getCommandSenderName());
// Check if player has enough
Double currentBalance = (Double) getBalance.invoke(economy, offlinePlayer);
if (currentBalance < amount) {
return false;
}
Object response = withdrawPlayer.invoke(economy, offlinePlayer, (double) amount);
Boolean success = (Boolean) response.getClass().getField("transactionSuccess").get(response);
if (success) {
// Also update internal tracking for statistics
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
data.currencyData.setBalance(getBalance(player));
return true;
}
return false;
} catch (Exception e) {
logger.warn("Vault withdraw failed, falling back to internal: " + e.getMessage());
}
}
// Fall back to internal currency
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
boolean success = data.currencyData.withdraw(amount);
if (success) {
data.save();
}
return success;
}
/**
* Check if player can afford an amount
*/
public boolean canAfford(EntityPlayer player, long amount) {
return getBalance(player) >= amount;
}
/**
* Transfer currency from one player to another
* @return true if successful
*/
public boolean transfer(EntityPlayer from, EntityPlayer to, long amount) {
if (amount <= 0) {
return false;
}
if (!canAfford(from, amount)) {
return false;
}
// Withdraw from sender first
if (!withdraw(from, amount)) {
return false;
}
// Deposit to receiver
if (!deposit(to, amount)) {
// Rollback - deposit back to sender
deposit(from, amount);
return false;
}
return true;
}
/**
* Set player's balance directly (admin operation)
* Only works with internal currency - Vault manages its own balances
*/
public void setBalance(EntityPlayer player, long amount) {
if (isVaultEnabled()) {
logger.warn("Cannot set balance directly when using Vault - use Vault's economy commands");
return;
}
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
data.currencyData.setBalance(amount);
data.save();
}
/**
* Format an amount for display with currency name
*/
public String formatAmount(long amount) {
return String.format("%,d %s", amount, ConfigMarket.CurrencyName);
}
/**
* Get the currency name
*/
public String getCurrencyName() {
return ConfigMarket.CurrencyName;
}
}
@@ -0,0 +1,226 @@
package noppes.npcs.controllers.data;
import net.minecraft.nbt.NBTTagCompound;
import noppes.npcs.constants.EnumAuctionSort;
/**
* Filter/search criteria for auction listings.
* Used to query the auction controller with specific criteria.
*/
public class AuctionFilter {
/** Search text to match against item names */
public String searchText = "";
/** How to sort results */
public EnumAuctionSort sortOrder = EnumAuctionSort.ENDING_SOON;
/** Minimum current bid/price filter */
public long minPrice = 0;
/** Maximum current bid/price filter (0 = no max) */
public long maxPrice = 0;
/** Only show listings with buyout option */
public boolean buyoutOnly = false;
/** Only show listings without any bids yet */
public boolean noBidsOnly = false;
/** Page number for pagination (0-indexed) */
public int page = 0;
/** Items per page */
public int pageSize = 20;
/** Filter by specific seller UUID string (empty = all sellers) */
public String sellerUUID = "";
/** Filter by specific seller name (partial match, empty = all) */
public String sellerName = "";
public AuctionFilter() {
}
/**
* Create a filter with search text
*/
public static AuctionFilter search(String text) {
AuctionFilter filter = new AuctionFilter();
filter.searchText = text != null ? text : "";
return filter;
}
/**
* Create a filter for a specific seller
*/
public static AuctionFilter seller(String sellerUUID) {
AuctionFilter filter = new AuctionFilter();
filter.sellerUUID = sellerUUID != null ? sellerUUID : "";
return filter;
}
// Builder-style methods for chaining
public AuctionFilter withSearch(String text) {
this.searchText = text != null ? text : "";
return this;
}
public AuctionFilter withSort(EnumAuctionSort sort) {
this.sortOrder = sort;
return this;
}
public AuctionFilter withPriceRange(long min, long max) {
this.minPrice = min;
this.maxPrice = max;
return this;
}
public AuctionFilter withBuyoutOnly(boolean buyoutOnly) {
this.buyoutOnly = buyoutOnly;
return this;
}
public AuctionFilter withNoBidsOnly(boolean noBidsOnly) {
this.noBidsOnly = noBidsOnly;
return this;
}
public AuctionFilter withPage(int page, int pageSize) {
this.page = Math.max(0, page);
this.pageSize = Math.max(1, Math.min(100, pageSize));
return this;
}
public AuctionFilter withSeller(String sellerUUID, String sellerName) {
this.sellerUUID = sellerUUID != null ? sellerUUID : "";
this.sellerName = sellerName != null ? sellerName : "";
return this;
}
/**
* Check if a listing matches this filter's criteria
*/
public boolean matches(AuctionListing listing) {
if (listing == null) {
return false;
}
if (listing.item == null) {
return false;
}
// Search text filter (case-insensitive)
if (!searchText.isEmpty()) {
String lowerSearch = searchText.toLowerCase();
String itemName = listing.item.getDisplayName().toLowerCase();
if (!itemName.contains(lowerSearch)) {
return false;
}
}
// Price range filter (uses current bid or starting price)
long price = listing.currentBid > 0 ? listing.currentBid : listing.startingPrice;
if (minPrice > 0 && price < minPrice) {
return false;
}
if (maxPrice > 0 && price > maxPrice) {
return false;
}
// Buyout only filter
if (buyoutOnly && listing.buyoutPrice <= 0) {
return false;
}
// No bids only filter
if (noBidsOnly && listing.hasBids()) {
return false;
}
// Seller UUID filter
if (!sellerUUID.isEmpty() && !listing.sellerUUID.toString().equals(sellerUUID)) {
return false;
}
// Seller name filter (partial match)
if (!sellerName.isEmpty()) {
String lowerName = sellerName.toLowerCase();
if (!listing.sellerName.toLowerCase().contains(lowerName)) {
return false;
}
}
return true;
}
/**
* Reset all filters to defaults
*/
public void reset() {
searchText = "";
sortOrder = EnumAuctionSort.ENDING_SOON;
minPrice = 0;
maxPrice = 0;
buyoutOnly = false;
noBidsOnly = false;
page = 0;
sellerUUID = "";
sellerName = "";
}
/**
* Write filter to NBT for network transmission
*/
public NBTTagCompound writeToNBT(NBTTagCompound compound) {
compound.setString("SearchText", searchText);
compound.setInteger("SortOrder", sortOrder.ordinal());
compound.setLong("MinPrice", minPrice);
compound.setLong("MaxPrice", maxPrice);
compound.setBoolean("BuyoutOnly", buyoutOnly);
compound.setBoolean("NoBidsOnly", noBidsOnly);
compound.setInteger("Page", page);
compound.setInteger("PageSize", pageSize);
compound.setString("SellerUUID", sellerUUID);
compound.setString("SellerName", sellerName);
return compound;
}
/**
* Read filter from NBT
*/
public void readFromNBT(NBTTagCompound compound) {
searchText = compound.getString("SearchText");
int sortOrdinal = compound.getInteger("SortOrder");
if (sortOrdinal >= 0 && sortOrdinal < EnumAuctionSort.values().length) {
sortOrder = EnumAuctionSort.values()[sortOrdinal];
}
minPrice = compound.getLong("MinPrice");
maxPrice = compound.getLong("MaxPrice");
buyoutOnly = compound.getBoolean("BuyoutOnly");
noBidsOnly = compound.getBoolean("NoBidsOnly");
page = Math.max(0, compound.getInteger("Page"));
pageSize = compound.getInteger("PageSize");
if (pageSize <= 0) {
pageSize = 20;
} else {
pageSize = Math.min(100, pageSize);
}
sellerUUID = compound.getString("SellerUUID");
sellerName = compound.getString("SellerName");
}
@Override
public String toString() {
return "AuctionFilter{" +
"search='" + searchText + '\'' +
", sort=" + sortOrder +
", price=" + minPrice + "-" + maxPrice +
", buyoutOnly=" + buyoutOnly +
", page=" + page +
'}';
}
}
@@ -0,0 +1,397 @@
package noppes.npcs.controllers.data;
import kamkeel.npcs.controllers.data.attribute.ItemTradeAttribute;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.constants.EnumAuctionDuration;
import noppes.npcs.constants.EnumAuctionStatus;
import noppes.npcs.controllers.AuctionBlacklist;
import java.util.UUID;
/**
* Represents a single auction listing.
* Contains all data about the item, seller, bidding, and timing.
*/
public class AuctionListing {
// Unique identifier
public int id;
// Seller info
public UUID sellerUUID;
public String sellerName;
// Item being sold
public ItemStack item;
// Pricing
public long startingPrice;
public long buyoutPrice; // 0 = no buyout option
public long currentBid;
// Current high bidder
public UUID highBidderUUID;
public String highBidderName;
// Previous bidder (for refund notifications)
public UUID previousBidderUUID;
public String previousBidderName;
public long previousBidAmount;
// Timing
public long listingTime; // When the auction was created
public long expirationTime; // When the auction ends
public EnumAuctionDuration duration;
// Status
public EnumAuctionStatus status = EnumAuctionStatus.ACTIVE;
// Claim tracking
public boolean sellerClaimed = false; // Has seller claimed their proceeds?
public boolean buyerClaimed = false; // Has buyer claimed their item?
// Bid tracking
public int bidCount = 0; // Number of bids placed
public AuctionListing() {
}
/**
* Alias for listingTime (when the auction was created)
*/
public long getCreationTime() {
return listingTime;
}
// For sorting compatibility
public long creationTime() {
return listingTime;
}
/**
* Create a new auction listing
*/
public AuctionListing(UUID seller, String sellerName, ItemStack item,
long startPrice, long buyout, EnumAuctionDuration duration) {
this.sellerUUID = seller;
this.sellerName = sellerName;
this.item = item.copy();
this.startingPrice = startPrice;
this.buyoutPrice = buyout;
this.currentBid = 0; // No bids yet
this.duration = duration;
this.listingTime = System.currentTimeMillis();
this.expirationTime = listingTime + duration.getMillis();
this.status = EnumAuctionStatus.ACTIVE;
}
// ==================== Status Checks ====================
/**
* Check if auction has expired
*/
public boolean isExpired() {
return System.currentTimeMillis() >= expirationTime;
}
/**
* Check if auction is still active
*/
public boolean isActive() {
return status == EnumAuctionStatus.ACTIVE && !isExpired();
}
/**
* Get time remaining in milliseconds
*/
public long getTimeRemaining() {
return Math.max(0, expirationTime - System.currentTimeMillis());
}
/**
* Get formatted time remaining
*/
public String getTimeRemainingFormatted() {
long remaining = getTimeRemaining();
if (remaining <= 0) {
return "Ended";
}
long hours = remaining / (60L * 60L * 1000L);
long minutes = (remaining % (60L * 60L * 1000L)) / (60L * 1000L);
if (hours > 24) {
long days = hours / 24;
hours = hours % 24;
return days + "d " + hours + "h";
} else if (hours > 0) {
return hours + "h " + minutes + "m";
} else {
long seconds = (remaining % (60L * 1000L)) / 1000L;
return minutes + "m " + seconds + "s";
}
}
/**
* Check if auction has any bids
*/
public boolean hasBids() {
return highBidderUUID != null;
}
// ==================== Bidding Methods ====================
/**
* Calculate minimum valid bid amount
*/
public long getMinimumBid() {
if (!hasBids()) {
return startingPrice;
}
// Minimum increment is configured percent or 1, whichever is greater
long minIncrement = Math.max(1, (long) (currentBid * ConfigMarket.MinBidIncrementPercent));
return currentBid + minIncrement;
}
/**
* Place a bid
* @return true if bid was successful
*/
public boolean placeBid(UUID bidder, String bidderName, long amount) {
if (status != EnumAuctionStatus.ACTIVE) {
return false;
}
if (isExpired()) {
return false;
}
if (amount < getMinimumBid()) {
return false;
}
if (bidder.equals(sellerUUID)) {
return false; // Can't bid on own item
}
// Store previous bidder for refund notification
if (highBidderUUID != null) {
previousBidderUUID = highBidderUUID;
previousBidderName = highBidderName;
previousBidAmount = currentBid;
}
// Update high bidder
highBidderUUID = bidder;
highBidderName = bidderName;
currentBid = amount;
bidCount++;
// Snipe protection - extend if bid placed in final minutes
if (ConfigMarket.SnipeProtectionMinutes > 0) {
long timeRemaining = getTimeRemaining();
long thresholdMs = ConfigMarket.SnipeProtectionThreshold * 60L * 1000L;
if (timeRemaining < thresholdMs) {
// Extend TO snipe protection time, not by it
long newExpiration = System.currentTimeMillis() +
(ConfigMarket.SnipeProtectionMinutes * 60L * 1000L);
// Only extend if it would actually extend the auction
if (newExpiration > expirationTime) {
expirationTime = newExpiration;
}
}
}
return true;
}
/**
* Execute buyout (instant purchase at buyout price)
* @return true if buyout was successful
*/
public boolean buyout(UUID buyer, String buyerName) {
if (status != EnumAuctionStatus.ACTIVE) {
return false;
}
if (isExpired()) {
return false;
}
if (buyoutPrice <= 0) {
return false; // No buyout available
}
if (buyer.equals(sellerUUID)) {
return false; // Can't buy own item
}
// Store previous bidder for refund
if (highBidderUUID != null) {
previousBidderUUID = highBidderUUID;
previousBidderName = highBidderName;
previousBidAmount = currentBid;
}
highBidderUUID = buyer;
highBidderName = buyerName;
currentBid = buyoutPrice;
status = EnumAuctionStatus.SOLD;
return true;
}
/**
* Cancel listing (seller only, before any bids)
* @return true if cancellation was successful
*/
public boolean cancel(UUID requester) {
if (!requester.equals(sellerUUID)) {
return false; // Only seller can cancel
}
if (hasBids()) {
return false; // Can't cancel with active bids
}
if (status != EnumAuctionStatus.ACTIVE) {
return false;
}
status = EnumAuctionStatus.CANCELLED;
return true;
}
/**
* Finalize auction when it expires
* Call this when auction timer runs out
*/
public void finalize() {
if (status != EnumAuctionStatus.ACTIVE) {
return;
}
if (hasBids()) {
status = EnumAuctionStatus.SOLD;
} else {
status = EnumAuctionStatus.EXPIRED;
}
}
// ==================== Validation ====================
/**
* Validate that the item can be listed
* @return null if valid, error message if invalid
*/
public static String validateItem(ItemStack item) {
if (item == null || item.getItem() == null) {
return "Invalid item";
}
// Check trade restrictions (Untradeable, ProfileSlot Bound, Soulbound)
if (!ItemTradeAttribute.canTrade(item)) {
String reason = ItemTradeAttribute.getTradeBlockReason(item);
return reason != null ? reason : "Item cannot be traded";
}
// Check blacklist
if (AuctionBlacklist.Instance != null && AuctionBlacklist.Instance.isBlacklisted(item)) {
return "Item is blacklisted from auction";
}
return null; // Valid
}
// ==================== Financial Calculations ====================
/**
* Get listing fee for this auction
*/
public long getListingFee() {
long flatFee = duration.getListingFee();
long percentFee = (long) (startingPrice * ConfigMarket.ListingFeePercent);
return flatFee + percentFee;
}
/**
* Get seller's proceeds after sales tax
*/
public long getSellerProceeds() {
if (status != EnumAuctionStatus.SOLD) {
return 0;
}
long tax = (long) (currentBid * ConfigMarket.SalesTaxPercent);
return currentBid - tax;
}
// ==================== NBT Serialization ====================
public NBTTagCompound writeToNBT(NBTTagCompound compound) {
compound.setInteger("Id", id);
compound.setString("SellerUUID", sellerUUID.toString());
compound.setString("SellerName", sellerName);
compound.setTag("Item", item.writeToNBT(new NBTTagCompound()));
compound.setLong("StartPrice", startingPrice);
compound.setLong("BuyoutPrice", buyoutPrice);
compound.setLong("CurrentBid", currentBid);
if (highBidderUUID != null) {
compound.setString("BidderUUID", highBidderUUID.toString());
compound.setString("BidderName", highBidderName);
}
if (previousBidderUUID != null) {
compound.setString("PrevBidderUUID", previousBidderUUID.toString());
compound.setString("PrevBidderName", previousBidderName);
compound.setLong("PrevBidAmount", previousBidAmount);
}
compound.setLong("ListingTime", listingTime);
compound.setLong("ExpirationTime", expirationTime);
compound.setInteger("Duration", duration.ordinal());
compound.setInteger("Status", status.ordinal());
compound.setBoolean("SellerClaimed", sellerClaimed);
compound.setBoolean("BuyerClaimed", buyerClaimed);
compound.setInteger("BidCount", bidCount);
return compound;
}
public void readFromNBT(NBTTagCompound compound) {
id = compound.getInteger("Id");
sellerUUID = UUID.fromString(compound.getString("SellerUUID"));
sellerName = compound.getString("SellerName");
item = ItemStack.loadItemStackFromNBT(compound.getCompoundTag("Item"));
startingPrice = compound.getLong("StartPrice");
buyoutPrice = compound.getLong("BuyoutPrice");
currentBid = compound.getLong("CurrentBid");
if (compound.hasKey("BidderUUID")) {
highBidderUUID = UUID.fromString(compound.getString("BidderUUID"));
highBidderName = compound.getString("BidderName");
}
if (compound.hasKey("PrevBidderUUID")) {
previousBidderUUID = UUID.fromString(compound.getString("PrevBidderUUID"));
previousBidderName = compound.getString("PrevBidderName");
previousBidAmount = compound.getLong("PrevBidAmount");
}
listingTime = compound.getLong("ListingTime");
expirationTime = compound.getLong("ExpirationTime");
int durationOrdinal = compound.getInteger("Duration");
if (durationOrdinal >= 0 && durationOrdinal < EnumAuctionDuration.values().length) {
duration = EnumAuctionDuration.values()[durationOrdinal];
} else {
duration = EnumAuctionDuration.LONG;
}
int statusOrdinal = compound.getInteger("Status");
if (statusOrdinal >= 0 && statusOrdinal < EnumAuctionStatus.values().length) {
status = EnumAuctionStatus.values()[statusOrdinal];
} else {
status = EnumAuctionStatus.ACTIVE;
}
sellerClaimed = compound.getBoolean("SellerClaimed");
buyerClaimed = compound.getBoolean("BuyerClaimed");
bidCount = compound.getInteger("BidCount");
}
}
@@ -0,0 +1,131 @@
package noppes.npcs.controllers.data;
import net.minecraft.nbt.NBTTagCompound;
import noppes.npcs.config.ConfigMarket;
/**
* Stores player currency balance.
* This data is NOT profile slot bound - all profile slots share the same currency pool.
* When Vault API is available, this serves as a cache/fallback.
*/
public class PlayerCurrencyData {
private long balance;
private long lifetimeEarned;
private long lifetimeSpent;
public PlayerCurrencyData() {
this.balance = ConfigMarket.StartingBalance;
this.lifetimeEarned = 0;
this.lifetimeSpent = 0;
}
public void readFromNBT(NBTTagCompound compound) {
if (compound.hasKey("CurrencyBalance")) {
this.balance = compound.getLong("CurrencyBalance");
} else {
this.balance = ConfigMarket.StartingBalance;
}
this.lifetimeEarned = compound.getLong("CurrencyLifetimeEarned");
this.lifetimeSpent = compound.getLong("CurrencyLifetimeSpent");
}
public void writeToNBT(NBTTagCompound compound) {
compound.setLong("CurrencyBalance", this.balance);
compound.setLong("CurrencyLifetimeEarned", this.lifetimeEarned);
compound.setLong("CurrencyLifetimeSpent", this.lifetimeSpent);
}
/**
* Get the current balance
*/
public long getBalance() {
return balance;
}
/**
* Set the balance directly (use with caution)
*/
public void setBalance(long balance) {
if (balance < 0) {
balance = 0;
}
if (balance > ConfigMarket.MaxBalance) {
balance = ConfigMarket.MaxBalance;
}
this.balance = balance;
}
/**
* Add currency to balance (deposit)
* @param amount Amount to add
* @return true if successful, false if would exceed max balance
*/
public boolean deposit(long amount) {
if (amount <= 0) {
return false;
}
long newBalance = this.balance + amount;
if (newBalance > ConfigMarket.MaxBalance) {
return false;
}
if (newBalance < this.balance) {
// Overflow protection
return false;
}
this.balance = newBalance;
this.lifetimeEarned += amount;
return true;
}
/**
* Remove currency from balance (withdraw)
* @param amount Amount to remove
* @return true if successful, false if insufficient funds
*/
public boolean withdraw(long amount) {
if (amount <= 0) {
return false;
}
if (this.balance < amount) {
return false;
}
this.balance -= amount;
this.lifetimeSpent += amount;
return true;
}
/**
* Check if player can afford an amount
*/
public boolean canAfford(long amount) {
return this.balance >= amount;
}
/**
* Get lifetime earned currency
*/
public long getLifetimeEarned() {
return lifetimeEarned;
}
/**
* Get lifetime spent currency
*/
public long getLifetimeSpent() {
return lifetimeSpent;
}
/**
* Format the balance for display
*/
public String formatBalance() {
return formatAmount(this.balance);
}
/**
* Format an amount for display
*/
public static String formatAmount(long amount) {
return String.format("%,d %s", amount, ConfigMarket.CurrencyName);
}
}
@@ -59,6 +59,9 @@ public class PlayerData implements IExtendedEntityProperties, IPlayerData {
public DataSkinOverlays skinOverlays = new DataSkinOverlays(this);
public MagicData magicData = new MagicData();
// Currency data - NOT slot-bound, shared across all profile slots
public PlayerCurrencyData currencyData = new PlayerCurrencyData();
public ActionManager actionManager = new ActionManager();
public PlayerDataScript scriptData;
@@ -406,6 +409,9 @@ public class PlayerData implements IExtendedEntityProperties, IPlayerData {
}
final NBTTagCompound compound = getNBT();
// Add currency data to main save (NOT slot-bound, preserved across profile changes)
currencyData.writeToNBT(compound);
final String filename;
if (ConfigMain.DatFormat) {
filename = uuid + ".dat";
@@ -442,6 +448,13 @@ public class PlayerData implements IExtendedEntityProperties, IPlayerData {
if (data.hasNoTags()) {
data = getNBT();
}
// Load currency BEFORE setNBT so we can preserve it
// Currency is stored in main file but NOT in slot data
if (data.hasKey("CurrencyBalance")) {
currencyData.readFromNBT(data);
}
setNBT(data);
}
@@ -0,0 +1,319 @@
package noppes.npcs.controllers.data;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import noppes.npcs.constants.EnumStockReset;
import java.util.HashMap;
import java.util.Map;
/**
* Manages trader stock system including:
* - Per-slot stock limits
* - Per-player vs per-server stock tracking
* - Automatic stock reset timers
*/
public class TraderStock {
// Stock configuration
public boolean enableStock = false;
public boolean perPlayer = false; // false = per-server, true = per-player
// Reset configuration (mirrors Quest cooldown system)
public EnumStockReset resetType = EnumStockReset.NONE;
public long customResetTime = 0; // For MCCUSTOM/RLCUSTOM types (in ticks or ms)
// Stock quantities per slot (max stock, -1 = unlimited)
public int[] maxStock = new int[18];
// Current stock (per-server mode)
public int[] currentStock = new int[18];
public long lastResetTime = 0;
// Per-player stock tracking
public HashMap<String, PlayerTraderStock> playerStock = new HashMap<>();
public TraderStock() {
for (int i = 0; i < 18; i++) {
maxStock[i] = -1; // -1 = unlimited
currentStock[i] = -1;
}
}
/**
* Get available stock for a slot
* @param slot The slot index
* @param playerName The player name (for per-player mode)
* @return Available stock count, or Integer.MAX_VALUE if unlimited
*/
public int getAvailableStock(int slot, String playerName) {
if (!enableStock || slot < 0 || slot >= 18 || maxStock[slot] < 0) {
return Integer.MAX_VALUE; // Unlimited
}
if (perPlayer) {
PlayerTraderStock pStock = playerStock.get(playerName);
if (pStock == null) {
return maxStock[slot]; // Not purchased yet
}
return pStock.getStock(slot, maxStock[slot]);
}
if (currentStock[slot] < 0) {
return maxStock[slot];
}
return Math.max(0, currentStock[slot]);
}
/**
* Check if stock is available for purchase
*/
public boolean hasStock(int slot, String playerName, int amount) {
return getAvailableStock(slot, playerName) >= amount;
}
/**
* Consume stock when purchase is made
* @return true if successful, false if insufficient stock
*/
public boolean consumeStock(int slot, String playerName, int amount) {
if (!enableStock || slot < 0 || slot >= 18 || maxStock[slot] < 0) {
return true; // Unlimited, always succeeds
}
if (perPlayer) {
PlayerTraderStock pStock = playerStock.computeIfAbsent(
playerName, k -> new PlayerTraderStock());
return pStock.consumeStock(slot, maxStock[slot], amount);
}
if (currentStock[slot] < 0) {
currentStock[slot] = maxStock[slot];
}
if (currentStock[slot] >= amount) {
currentStock[slot] -= amount;
return true;
}
return false;
}
/**
* Check if stock should reset based on current time
* @param currentTime Current MC world time (ticks) or real time (ms) depending on reset type
*/
public boolean shouldReset(long currentTime) {
if (resetType == EnumStockReset.NONE) {
return false;
}
long elapsed = currentTime - lastResetTime;
long resetInterval = getResetInterval();
return elapsed >= resetInterval;
}
/**
* Reset all stock to max values
* @param currentTime Current time to record as reset time
*/
public void resetStock(long currentTime) {
lastResetTime = currentTime;
// Reset per-server stock
for (int i = 0; i < 18; i++) {
currentStock[i] = maxStock[i];
}
// Clear per-player stock
playerStock.clear();
}
/**
* Get reset interval based on reset type
* @return Interval in ticks (MC time) or milliseconds (real time)
*/
public long getResetInterval() {
switch (resetType) {
case MCDAILY:
return 24000; // 1 MC day in ticks
case MCWEEKLY:
return 168000; // 7 MC days in ticks
case MCCUSTOM:
return customResetTime; // Custom ticks
case RLDAILY:
return 86400000L; // 24 hours in ms
case RLWEEKLY:
return 604800000L; // 7 days in ms
case RLCUSTOM:
return customResetTime; // Custom ms
default:
return Long.MAX_VALUE;
}
}
/**
* Get time until next reset
* @param currentTime Current time
* @return Time remaining until reset, or -1 if no reset scheduled
*/
public long getTimeUntilReset(long currentTime) {
if (resetType == EnumStockReset.NONE) {
return -1;
}
long elapsed = currentTime - lastResetTime;
long interval = getResetInterval();
return Math.max(0, interval - elapsed);
}
/**
* Format time until reset for display
* @param currentTime Current time
* @return Formatted string like "2 hours" or "1 day, 5 hours"
*/
public String getTimeUntilResetFormatted(long currentTime) {
long remaining = getTimeUntilReset(currentTime);
if (remaining < 0) {
return "";
}
if (resetType.isRealTime()) {
// Convert ms to readable format
long hours = remaining / 3600000L;
long days = hours / 24;
hours = hours % 24;
if (days > 0) {
return days + " day" + (days != 1 ? "s" : "") +
(hours > 0 ? ", " + hours + " hour" + (hours != 1 ? "s" : "") : "");
} else if (hours > 0) {
return hours + " hour" + (hours != 1 ? "s" : "");
} else {
long minutes = remaining / 60000L;
return minutes + " minute" + (minutes != 1 ? "s" : "");
}
} else {
// Convert ticks to MC time format
long mcHours = remaining / 1000; // 1000 ticks = 1 MC hour
long mcDays = mcHours / 24;
mcHours = mcHours % 24;
if (mcDays > 0) {
return mcDays + " MC day" + (mcDays != 1 ? "s" : "") +
(mcHours > 0 ? ", " + mcHours + " MC hour" + (mcHours != 1 ? "s" : "") : "");
} else {
return mcHours + " MC hour" + (mcHours != 1 ? "s" : "");
}
}
}
/**
* Set stock for a specific slot
*/
public void setMaxStock(int slot, int amount) {
if (slot >= 0 && slot < 18) {
maxStock[slot] = amount;
if (currentStock[slot] < 0 || currentStock[slot] > amount) {
currentStock[slot] = amount;
}
}
}
// ==================== NBT Serialization ====================
public NBTTagCompound writeToNBT(NBTTagCompound compound) {
compound.setBoolean("EnableStock", enableStock);
compound.setBoolean("PerPlayer", perPlayer);
compound.setInteger("ResetType", resetType.ordinal());
compound.setLong("CustomResetTime", customResetTime);
compound.setIntArray("MaxStock", maxStock);
compound.setIntArray("CurrentStock", currentStock);
compound.setLong("LastResetTime", lastResetTime);
// Save per-player stock
NBTTagList playerList = new NBTTagList();
for (Map.Entry<String, PlayerTraderStock> entry : playerStock.entrySet()) {
NBTTagCompound playerTag = new NBTTagCompound();
playerTag.setString("Player", entry.getKey());
entry.getValue().writeToNBT(playerTag);
playerList.appendTag(playerTag);
}
compound.setTag("PlayerStock", playerList);
return compound;
}
public void readFromNBT(NBTTagCompound compound) {
enableStock = compound.getBoolean("EnableStock");
perPlayer = compound.getBoolean("PerPlayer");
int resetOrdinal = compound.getInteger("ResetType");
if (resetOrdinal >= 0 && resetOrdinal < EnumStockReset.values().length) {
resetType = EnumStockReset.values()[resetOrdinal];
}
customResetTime = compound.getLong("CustomResetTime");
int[] loadedMax = compound.getIntArray("MaxStock");
int[] loadedCurrent = compound.getIntArray("CurrentStock");
if (loadedMax != null && loadedMax.length == 18) {
maxStock = loadedMax;
}
if (loadedCurrent != null && loadedCurrent.length == 18) {
currentStock = loadedCurrent;
}
lastResetTime = compound.getLong("LastResetTime");
// Load per-player stock
playerStock.clear();
NBTTagList playerList = compound.getTagList("PlayerStock", 10);
for (int i = 0; i < playerList.tagCount(); i++) {
NBTTagCompound playerTag = playerList.getCompoundTagAt(i);
String playerName = playerTag.getString("Player");
PlayerTraderStock pStock = new PlayerTraderStock();
pStock.readFromNBT(playerTag);
playerStock.put(playerName, pStock);
}
}
// ==================== Inner Class for Per-Player Stock ====================
public static class PlayerTraderStock {
public int[] purchasedAmounts = new int[18];
public long lastPurchaseTime = 0;
public PlayerTraderStock() {
for (int i = 0; i < 18; i++) {
purchasedAmounts[i] = 0;
}
}
public int getStock(int slot, int maxStock) {
if (slot < 0 || slot >= 18) return 0;
return Math.max(0, maxStock - purchasedAmounts[slot]);
}
public boolean consumeStock(int slot, int maxStock, int amount) {
if (slot < 0 || slot >= 18) return false;
if (getStock(slot, maxStock) >= amount) {
purchasedAmounts[slot] += amount;
lastPurchaseTime = System.currentTimeMillis();
return true;
}
return false;
}
public void writeToNBT(NBTTagCompound compound) {
compound.setIntArray("Purchased", purchasedAmounts);
compound.setLong("LastPurchase", lastPurchaseTime);
}
public void readFromNBT(NBTTagCompound compound) {
int[] loaded = compound.getIntArray("Purchased");
if (loaded != null && loaded.length == 18) {
purchasedAmounts = loaded;
}
lastPurchaseTime = compound.getLong("LastPurchase");
}
}
}
@@ -0,0 +1,135 @@
package noppes.npcs.roles;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import noppes.npcs.NoppesUtilServer;
import noppes.npcs.config.ConfigMarket;
import noppes.npcs.constants.EnumGuiType;
import noppes.npcs.controllers.AuctionController;
import noppes.npcs.controllers.data.Line;
import noppes.npcs.entity.EntityNPCInterface;
/**
* NPC role for Auctioneer - provides access to the global auction house.
*/
public class RoleAuctioneer extends RoleInterface {
// Configuration
public boolean showActiveListings = true; // Show active listings tab
public boolean showMyListings = true; // Show player's listings tab
public boolean showMyBids = true; // Show player's bids tab
public boolean showClaims = true; // Show claimable items tab
public boolean allowCreatingListings = true; // Allow creating new listings
public boolean allowBidding = true; // Allow bidding on items
public boolean allowBuyout = true; // Allow buyout purchases
// Custom greeting messages
public String welcomeMessage = "";
public String noAuctionMessage = "";
public RoleAuctioneer(EntityNPCInterface npc) {
super(npc);
}
@Override
public NBTTagCompound writeToNBT(NBTTagCompound compound) {
compound.setBoolean("ShowActiveListings", showActiveListings);
compound.setBoolean("ShowMyListings", showMyListings);
compound.setBoolean("ShowMyBids", showMyBids);
compound.setBoolean("ShowClaims", showClaims);
compound.setBoolean("AllowCreatingListings", allowCreatingListings);
compound.setBoolean("AllowBidding", allowBidding);
compound.setBoolean("AllowBuyout", allowBuyout);
compound.setString("WelcomeMessage", welcomeMessage);
compound.setString("NoAuctionMessage", noAuctionMessage);
return compound;
}
@Override
public void readFromNBT(NBTTagCompound compound) {
showActiveListings = compound.hasKey("ShowActiveListings") ?
compound.getBoolean("ShowActiveListings") : true;
showMyListings = compound.hasKey("ShowMyListings") ?
compound.getBoolean("ShowMyListings") : true;
showMyBids = compound.hasKey("ShowMyBids") ?
compound.getBoolean("ShowMyBids") : true;
showClaims = compound.hasKey("ShowClaims") ?
compound.getBoolean("ShowClaims") : true;
allowCreatingListings = compound.hasKey("AllowCreatingListings") ?
compound.getBoolean("AllowCreatingListings") : true;
allowBidding = compound.hasKey("AllowBidding") ?
compound.getBoolean("AllowBidding") : true;
allowBuyout = compound.hasKey("AllowBuyout") ?
compound.getBoolean("AllowBuyout") : true;
welcomeMessage = compound.getString("WelcomeMessage");
noAuctionMessage = compound.getString("NoAuctionMessage");
}
@Override
public void interact(EntityPlayer player) {
// Check if auction system is enabled
if (!ConfigMarket.AuctionEnabled) {
if (!noAuctionMessage.isEmpty()) {
npc.say(player, new Line(noAuctionMessage));
} else {
npc.say(player, new Line("The auction house is currently closed."));
}
return;
}
// Process expired auctions before opening GUI
if (AuctionController.Instance != null) {
AuctionController.Instance.processExpiredAuctions();
}
// Say welcome message
if (!welcomeMessage.isEmpty()) {
npc.say(player, new Line(welcomeMessage));
} else {
npc.say(player, npc.advanced.getInteractLine());
}
// Open auction GUI
NoppesUtilServer.sendOpenGui(player, EnumGuiType.PlayerAuction, npc);
}
/**
* Check if player has claims waiting
*/
public boolean hasClaimsWaiting(EntityPlayer player) {
if (AuctionController.Instance == null) {
return false;
}
return !AuctionController.Instance.getClaimableListings(player.getUniqueID()).isEmpty();
}
/**
* Get number of active listings in the auction house
*/
public int getActiveListingCount() {
if (AuctionController.Instance == null) {
return 0;
}
return AuctionController.Instance.getActiveListingCount();
}
/**
* Get player's current listing count
*/
public int getPlayerListingCount(EntityPlayer player) {
if (AuctionController.Instance == null) {
return 0;
}
return AuctionController.Instance.getActiveListingsCount(player.getUniqueID());
}
/**
* Get player's maximum allowed listings
*/
public int getPlayerMaxListings(EntityPlayer player) {
if (AuctionController.Instance == null) {
return ConfigMarket.DefaultMaxListings;
}
return AuctionController.Instance.getMaxListings(player);
}
}
@@ -4,11 +4,13 @@ import foxz.utils.Market;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import noppes.npcs.NBTTags;
import noppes.npcs.NoppesUtilPlayer;
import noppes.npcs.NoppesUtilServer;
import noppes.npcs.NpcMiscInventory;
import noppes.npcs.constants.EnumGuiType;
import noppes.npcs.controllers.data.TraderStock;
import noppes.npcs.entity.EntityNPCInterface;
import java.util.HashMap;
@@ -30,6 +32,13 @@ public class RoleTrader extends RoleInterface {
public HashMap<String, int[]> playerPurchases;
public HashMap<String, int[]> playerDisableSlot;
// Stock system
public TraderStock stock = new TraderStock();
// Currency system
public boolean useCurrency = false; // Use virtual currency instead of items
public long[] slotPrices = new long[18]; // Currency prices per slot
public RoleTrader(EntityNPCInterface npc) {
super(npc);
inventoryCurrency = new NpcMiscInventory(36);
@@ -59,6 +68,20 @@ public class RoleTrader extends RoleInterface {
nbttagcompound.setIntArray("Purchases", purchases);
nbttagcompound.setTag("PlayerPurchases", NBTTags.nbtStringIntegerArrayMap(playerPurchases));
}
// Stock system
nbttagcompound.setTag("Stock", stock.writeToNBT(new NBTTagCompound()));
// Currency system
nbttagcompound.setBoolean("UseCurrency", useCurrency);
NBTTagList priceList = new NBTTagList();
for (long price : slotPrices) {
NBTTagCompound priceTag = new NBTTagCompound();
priceTag.setLong("Price", price);
priceList.appendTag(priceTag);
}
nbttagcompound.setTag("SlotPrices", priceList);
return nbttagcompound;
}
@@ -94,10 +117,39 @@ public class RoleTrader extends RoleInterface {
disableSlot = new int[18];
for (int i = 0; i < disableSlot.length; ++i) disableSlot[i] = 0;
}
// Stock system
if (nbttagcompound.hasKey("Stock")) {
stock.readFromNBT(nbttagcompound.getCompoundTag("Stock"));
}
// Currency system
useCurrency = nbttagcompound.getBoolean("UseCurrency");
if (nbttagcompound.hasKey("SlotPrices")) {
NBTTagList priceList = nbttagcompound.getTagList("SlotPrices", 10);
for (int i = 0; i < priceList.tagCount() && i < 18; i++) {
slotPrices[i] = priceList.getCompoundTagAt(i).getLong("Price");
}
}
}
@Override
public void interact(EntityPlayer player) {
// Check for stock reset before opening GUI
if (stock.enableStock) {
long currentTime = stock.resetType.isRealTime()
? System.currentTimeMillis()
: player.worldObj.getTotalWorldTime();
if (stock.shouldReset(currentTime)) {
stock.resetStock(currentTime);
// Save to market if using shared market
if (!marketName.isEmpty()) {
Market.save(this, marketName);
}
}
}
npc.say(player, npc.advanced.getInteractLine());
try {
Market.getMarket(this, marketName);
@@ -138,4 +190,78 @@ public class RoleTrader extends RoleInterface {
return map.get(name);
}
// ==================== Stock System Methods ====================
/**
* Check if there is stock available for a slot
*/
public boolean hasStock(int slot, String playerName, int amount) {
if (!stock.enableStock) {
return true; // Stock system disabled, always available
}
return stock.hasStock(slot, playerName, amount);
}
/**
* Get available stock for a slot
*/
public int getAvailableStock(int slot, String playerName) {
if (!stock.enableStock) {
return Integer.MAX_VALUE; // Unlimited
}
return stock.getAvailableStock(slot, playerName);
}
/**
* Consume stock after purchase
*/
public boolean consumeStock(int slot, String playerName, int amount) {
if (!stock.enableStock) {
return true; // Stock system disabled
}
boolean consumed = stock.consumeStock(slot, playerName, amount);
if (consumed && !marketName.isEmpty()) {
Market.save(this, marketName);
}
return consumed;
}
/**
* Get time until stock reset formatted for display
*/
public String getTimeUntilResetFormatted() {
if (!stock.enableStock || stock.resetType == noppes.npcs.constants.EnumStockReset.NONE) {
return "";
}
long currentTime = stock.resetType.isRealTime()
? System.currentTimeMillis()
: (npc != null && npc.worldObj != null ? npc.worldObj.getTotalWorldTime() : 0);
return stock.getTimeUntilResetFormatted(currentTime);
}
// ==================== Currency System Methods ====================
/**
* Get the currency price for a slot
*/
public long getSlotPrice(int slot) {
if (slot < 0 || slot >= 18) return 0;
return slotPrices[slot];
}
/**
* Set the currency price for a slot
*/
public void setSlotPrice(int slot, long price) {
if (slot >= 0 && slot < 18) {
slotPrices[slot] = Math.max(0, price);
}
}
/**
* Check if a slot has a currency price set
*/
public boolean hasSlotPrice(int slot) {
return useCurrency && slot >= 0 && slot < 18 && slotPrices[slot] > 0;
}
}
@@ -49,11 +49,14 @@ 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;
@@ -895,4 +898,186 @@ public class ScriptPlayer<T extends EntityPlayerMP> extends ScriptLivingBase<T>
}
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();
}
}
@@ -1,6 +1,7 @@
package noppes.npcs.scripted.item;
import com.google.common.collect.Multimap;
import kamkeel.npcs.controllers.data.attribute.ItemTradeAttribute;
import kamkeel.npcs.controllers.data.attribute.requirement.IRequirementChecker;
import kamkeel.npcs.controllers.data.attribute.requirement.RequirementCheckerRegistry;
import kamkeel.npcs.util.AttributeItemUtil;
@@ -592,4 +593,117 @@ public class ScriptItemStack implements IItemStack {
Set<String> keys = reqTag.func_150296_c();
return keys.toArray(new String[keys.size()]);
}
// ==================== Trade Restriction Methods ====================
/**
* Check if this item can be traded or auctioned.
* An item cannot be traded if it is:
* - Marked as untradeable
* - Bound to a profile slot
* - Soulbound to a player
* @return true if the item can be traded
* @since 1.11
*/
public boolean canTrade() {
return ItemTradeAttribute.canTrade(item);
}
/**
* Get the reason why this item cannot be traded.
* @return Localization key for the block reason, or null if tradeable
* @since 1.11
*/
public String getTradeBlockReason() {
return ItemTradeAttribute.getTradeBlockReason(item);
}
/**
* Check if this item is marked as untradeable
* @return true if untradeable
* @since 1.11
*/
public boolean isUntradeable() {
return ItemTradeAttribute.isUntradeable(item);
}
/**
* Set whether this item is untradeable
* @param untradeable true to mark as untradeable
* @since 1.11
*/
public void setUntradeable(boolean untradeable) {
ItemTradeAttribute.setUntradeable(item, untradeable);
}
/**
* Check if this item is bound to a profile slot
* @return true if profile slot bound
* @since 1.11
*/
public boolean isProfileSlotBound() {
return ItemTradeAttribute.isProfileSlotBound(item);
}
/**
* Get the profile slot this item is bound to
* @return Profile slot ID, or -1 if not bound
* @since 1.11
*/
public int getProfileSlot() {
return ItemTradeAttribute.getProfileSlot(item);
}
/**
* Bind this item to a specific profile slot
* @param slot The profile slot ID, or -1 to unbind
* @since 1.11
*/
public void setProfileSlotBound(int slot) {
ItemTradeAttribute.setProfileSlotBound(item, slot);
}
/**
* Check if this item is soulbound to any player
* @return true if soulbound
* @since 1.11
*/
public boolean isSoulbound() {
return ItemTradeAttribute.isSoulbound(item);
}
/**
* Get the UUID of the player this item is soulbound to
* @return UUID string, or null if not soulbound
* @since 1.11
*/
public String getSoulbindOwner() {
return ItemTradeAttribute.getSoulbindOwner(item);
}
/**
* Remove the soulbind from this item
* @since 1.11
*/
public void removeSoulbind() {
ItemTradeAttribute.removeSoulbind(item);
}
/**
* Clear all trade restrictions from this item
* (untradeable, profile slot bound, soulbound)
* @since 1.11
*/
public void clearTradeRestrictions() {
ItemTradeAttribute.clearAllRestrictions(item);
}
/**
* Get a summary of all trade restrictions on this item
* @return Human-readable string of restrictions, or empty if none
* @since 1.11
*/
public String getRestrictionSummary() {
return ItemTradeAttribute.getRestrictionSummary(item);
}
}