From c1dc58ae54397aedf0d4c5e134f126a86139be64 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 4 Jan 2026 08:43:55 +0000 Subject: [PATCH] Implement Phase 4: Auction House core system - Add auction enums: - EnumAuctionDuration.java - configurable auction durations (SHORT/MEDIUM/LONG/VERY_LONG) - EnumAuctionStatus.java - listing statuses (ACTIVE/SOLD/EXPIRED/CANCELLED/CLAIMED) - EnumAuctionCategory.java - auto-categorization of items for browsing - Add AuctionListing.java data class: - Complete auction listing with seller/bidder tracking - Pricing with starting price, buyout price, current bid - Timing with snipe protection (extends TO X minutes, not by) - Item validation (checks trade restrictions and blacklist) - Previous bidder tracking for refund notifications - NBT serialization for persistence - Add AuctionController.java: - Global auction house management - Create/cancel/finalize listings - Bid placement with automatic outbid refunds via claims system - Buyout support with immediate sale - Claim system for sellers (proceeds) and buyers (items) - Search and filter by category/name - Periodic expiration processing - Persistence via auctions.dat - Add RoleAuctioneer.java NPC role: - Configurable tabs (listings, my listings, my bids, claims) - Configurable permissions (create, bid, buyout) - Custom welcome/disabled messages - Opens auction GUI on interaction - Update ConfigMarket.java: - Duration-specific settings (hours and fees) - Removed deprecated AvailableDurations string - Update EnumRoleType.java - add Auctioneer - Update EnumGuiType.java - add PlayerAuction, SetupAuctioneer - Update DataAdvanced.java - handle Auctioneer role creation - Update CustomNpcs.java - initialize AuctionController --- src/main/java/noppes/npcs/CustomNpcs.java | 2 + src/main/java/noppes/npcs/DataAdvanced.java | 3 + .../java/noppes/npcs/config/ConfigMarket.java | 74 +- .../npcs/constants/EnumAuctionCategory.java | 156 +++++ .../npcs/constants/EnumAuctionDuration.java | 68 ++ .../npcs/constants/EnumAuctionStatus.java | 54 ++ .../noppes/npcs/constants/EnumGuiType.java | 4 +- .../noppes/npcs/constants/EnumRoleType.java | 2 +- .../npcs/controllers/AuctionController.java | 662 ++++++++++++++++++ .../npcs/controllers/data/AuctionListing.java | 392 +++++++++++ .../noppes/npcs/roles/RoleAuctioneer.java | 134 ++++ 11 files changed, 1522 insertions(+), 29 deletions(-) create mode 100644 src/main/java/noppes/npcs/constants/EnumAuctionCategory.java create mode 100644 src/main/java/noppes/npcs/constants/EnumAuctionDuration.java create mode 100644 src/main/java/noppes/npcs/constants/EnumAuctionStatus.java create mode 100644 src/main/java/noppes/npcs/controllers/AuctionController.java create mode 100644 src/main/java/noppes/npcs/controllers/data/AuctionListing.java create mode 100644 src/main/java/noppes/npcs/roles/RoleAuctioneer.java diff --git a/src/main/java/noppes/npcs/CustomNpcs.java b/src/main/java/noppes/npcs/CustomNpcs.java index dbdee9e67..c29fa4253 100644 --- a/src/main/java/noppes/npcs/CustomNpcs.java +++ b/src/main/java/noppes/npcs/CustomNpcs.java @@ -61,6 +61,7 @@ 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 +311,7 @@ public class CustomNpcs { new VaultHelper(); new CurrencyController(); new AuctionBlacklist(); + new AuctionController(); RecipeController.Instance.load(); new BankController(); DialogController.Instance.load(); diff --git a/src/main/java/noppes/npcs/DataAdvanced.java b/src/main/java/noppes/npcs/DataAdvanced.java index 45ecfe4a8..f03714506 100644 --- a/src/main/java/noppes/npcs/DataAdvanced.java +++ b/src/main/java/noppes/npcs/DataAdvanced.java @@ -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) { diff --git a/src/main/java/noppes/npcs/config/ConfigMarket.java b/src/main/java/noppes/npcs/config/ConfigMarket.java index 9c5791929..81eda2c3f 100644 --- a/src/main/java/noppes/npcs/config/ConfigMarket.java +++ b/src/main/java/noppes/npcs/config/ConfigMarket.java @@ -40,13 +40,23 @@ public class ConfigMarket { public static double ListingFeePercent = 0.0; public static double SalesTaxPercent = 0.05; public static boolean RequireAuctioneerNPC = true; - public static String AvailableDurations = "2,12,24,48"; - public static int DefaultDurationHours = 24; 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 // ========================================= @@ -108,12 +118,6 @@ public class ConfigMarket { RequireAuctioneerNPC = config.get(AUCTION, "Require Auctioneer NPC", true, "Require an Auctioneer NPC to access auction house").getBoolean(true); - AvailableDurations = config.get(AUCTION, "Available Durations", "2,12,24,48", - "Available auction durations in hours (comma-separated)").getString(); - - DefaultDurationHours = config.get(AUCTION, "Default Duration Hours", 24, - "Default auction duration in hours").getInt(24); - ClaimExpirationDays = config.get(AUCTION, "Claim Expiration Days", 30, "Claim expiration in days (claims auto-expire after this period, 0 = never)").getInt(30); @@ -126,6 +130,32 @@ public class ConfigMarket { 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 // ========================================= @@ -157,12 +187,18 @@ public class ConfigMarket { "Listing Fee Percent", "Sales Tax Percent", "Require Auctioneer NPC", - "Available Durations", - "Default Duration Hours", "Claim Expiration Days", "Min Bid Increment Percent", "Snipe Protection Minutes", - "Snipe Protection Threshold" + "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( @@ -198,20 +234,4 @@ public class ConfigMarket { } } } - - /** - * Parse available durations from config string - */ - public static int[] getAvailableDurationsArray() { - String[] parts = AvailableDurations.split(","); - int[] durations = new int[parts.length]; - for (int i = 0; i < parts.length; i++) { - try { - durations[i] = Integer.parseInt(parts[i].trim()); - } catch (NumberFormatException e) { - durations[i] = 24; // Default to 24 hours if parsing fails - } - } - return durations; - } } diff --git a/src/main/java/noppes/npcs/constants/EnumAuctionCategory.java b/src/main/java/noppes/npcs/constants/EnumAuctionCategory.java new file mode 100644 index 000000000..0906bb6ed --- /dev/null +++ b/src/main/java/noppes/npcs/constants/EnumAuctionCategory.java @@ -0,0 +1,156 @@ +package noppes.npcs.constants; + +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemEnchantedBook; +import net.minecraft.item.ItemFood; +import net.minecraft.item.ItemHoe; +import net.minecraft.item.ItemPickaxe; +import net.minecraft.item.ItemPotion; +import net.minecraft.item.ItemSpade; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemSword; +import net.minecraft.item.ItemTool; + +/** + * Categories for auction house items. + * Used for filtering and browsing. + */ +public enum EnumAuctionCategory { + ALL, // Special: shows all categories + WEAPONS, // Swords, bows, etc. + ARMOR, // Helmets, chestplates, leggings, boots + TOOLS, // Pickaxes, axes, shovels, hoes + FOOD, // Edible items + POTIONS, // Potions and splash potions + BLOCKS, // Placeable blocks + MATERIALS, // Crafting materials (ingots, gems, etc.) + ENCHANTED, // Items with enchantments or enchanted books + MISC; // Everything else + + /** + * Get display name for GUI + */ + public String getDisplayName() { + switch (this) { + case ALL: return "All Items"; + case WEAPONS: return "Weapons"; + case ARMOR: return "Armor"; + case TOOLS: return "Tools"; + case FOOD: return "Food"; + case POTIONS: return "Potions"; + case BLOCKS: return "Blocks"; + case MATERIALS: return "Materials"; + case ENCHANTED: return "Enchanted"; + case MISC: return "Miscellaneous"; + default: return "Unknown"; + } + } + + /** + * Auto-categorize an item based on its type + */ + public static EnumAuctionCategory categorize(ItemStack itemStack) { + if (itemStack == null || itemStack.getItem() == null) { + return MISC; + } + + Item item = itemStack.getItem(); + + // Check for enchantments first (higher priority) + if (itemStack.isItemEnchanted() || item instanceof ItemEnchantedBook) { + return ENCHANTED; + } + + // Weapons + if (item instanceof ItemSword || item instanceof ItemBow) { + return WEAPONS; + } + + // Armor + if (item instanceof ItemArmor) { + return ARMOR; + } + + // Tools + if (item instanceof ItemTool || item instanceof ItemPickaxe || + item instanceof ItemAxe || item instanceof ItemSpade || + item instanceof ItemHoe) { + return TOOLS; + } + + // Food + if (item instanceof ItemFood) { + return FOOD; + } + + // Potions + if (item instanceof ItemPotion) { + return POTIONS; + } + + // Blocks + if (item instanceof ItemBlock) { + return BLOCKS; + } + + // Materials - common crafting items + if (isMaterial(item)) { + return MATERIALS; + } + + return MISC; + } + + /** + * Check if an item is a common crafting material + */ + private static boolean isMaterial(Item item) { + // Check common material items + return item == Items.iron_ingot || + item == Items.gold_ingot || + item == Items.diamond || + item == Items.emerald || + item == Items.coal || + item == Items.redstone || + item == Items.glowstone_dust || + item == Items.quartz || + item == Items.leather || + item == Items.string || + item == Items.feather || + item == Items.bone || + item == Items.gunpowder || + item == Items.slime_ball || + item == Items.ender_pearl || + item == Items.blaze_rod || + item == Items.ghast_tear || + item == Items.gold_nugget || + item == Items.nether_wart || + item == Items.spider_eye || + item == Items.magma_cream || + item == Items.nether_star; + } + + /** + * Get icon item for category display + */ + public ItemStack getIconItem() { + switch (this) { + case ALL: return new ItemStack(Items.compass); + case WEAPONS: return new ItemStack(Items.iron_sword); + case ARMOR: return new ItemStack(Items.iron_chestplate); + case TOOLS: return new ItemStack(Items.iron_pickaxe); + case FOOD: return new ItemStack(Items.bread); + case POTIONS: return new ItemStack(Items.potionitem); + case BLOCKS: return new ItemStack(Item.getItemFromBlock(net.minecraft.init.Blocks.grass)); + case MATERIALS: return new ItemStack(Items.iron_ingot); + case ENCHANTED: return new ItemStack(Items.enchanted_book); + case MISC: return new ItemStack(Items.chest_minecart); + default: return new ItemStack(Items.paper); + } + } +} diff --git a/src/main/java/noppes/npcs/constants/EnumAuctionDuration.java b/src/main/java/noppes/npcs/constants/EnumAuctionDuration.java new file mode 100644 index 000000000..e18416f50 --- /dev/null +++ b/src/main/java/noppes/npcs/constants/EnumAuctionDuration.java @@ -0,0 +1,68 @@ +package noppes.npcs.constants; + +import noppes.npcs.config.ConfigMarket; + +/** + * Duration options for auction listings. + * Values are configurable via ConfigMarket. + */ +public enum EnumAuctionDuration { + SHORT, // Default: 2 hours + MEDIUM, // Default: 12 hours + LONG, // Default: 24 hours + VERY_LONG; // Default: 48 hours + + /** + * 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 display name for GUI + */ + public String getDisplayName() { + switch (this) { + case SHORT: + return ConfigMarket.AuctionDurationShort + " Hours"; + case MEDIUM: + return ConfigMarket.AuctionDurationMedium + " Hours"; + case LONG: + return ConfigMarket.AuctionDurationLong + " Hours"; + case VERY_LONG: + return ConfigMarket.AuctionDurationVeryLong + " Hours"; + default: + return "Unknown"; + } + } + + /** + * 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; + } + } +} diff --git a/src/main/java/noppes/npcs/constants/EnumAuctionStatus.java b/src/main/java/noppes/npcs/constants/EnumAuctionStatus.java new file mode 100644 index 000000000..9e614e496 --- /dev/null +++ b/src/main/java/noppes/npcs/constants/EnumAuctionStatus.java @@ -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; + } +} diff --git a/src/main/java/noppes/npcs/constants/EnumGuiType.java b/src/main/java/noppes/npcs/constants/EnumGuiType.java index d0919b9b1..adec6d51d 100644 --- a/src/main/java/noppes/npcs/constants/EnumGuiType.java +++ b/src/main/java/noppes/npcs/constants/EnumGuiType.java @@ -63,5 +63,7 @@ public enum EnumGuiType { ScriptItem, ScriptBlock, Paintbrush, - MagicBook; + MagicBook, + PlayerAuction, + SetupAuctioneer; } diff --git a/src/main/java/noppes/npcs/constants/EnumRoleType.java b/src/main/java/noppes/npcs/constants/EnumRoleType.java index 624658fb3..33f36941a 100644 --- a/src/main/java/noppes/npcs/constants/EnumRoleType.java +++ b/src/main/java/noppes/npcs/constants/EnumRoleType.java @@ -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 } diff --git a/src/main/java/noppes/npcs/controllers/AuctionController.java b/src/main/java/noppes/npcs/controllers/AuctionController.java new file mode 100644 index 000000000..ec3b6de19 --- /dev/null +++ b/src/main/java/noppes/npcs/controllers/AuctionController.java @@ -0,0 +1,662 @@ +package noppes.npcs.controllers; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +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.constants.EnumAuctionCategory; +import noppes.npcs.constants.EnumAuctionDuration; +import noppes.npcs.constants.EnumAuctionStatus; +import noppes.npcs.controllers.data.AuctionListing; +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.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.stream.Collectors; + +/** + * Controller for the global auction house. + * Manages all auction listings, bidding, and claims. + */ +public class AuctionController { + private static final Logger logger = LogManager.getLogger(CustomNpcs.class); + + public static AuctionController Instance; + + // All auction listings by ID + private Map listings = new ConcurrentHashMap<>(); + + // Next available listing ID + private int nextId = 1; + + // Indices for fast lookup + private Map> listingsBySeller = new ConcurrentHashMap<>(); + private Map> listingsByBidder = 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) { + logger.warn("Auction listing validation failed: " + validation); + return null; + } + + // Check seller's listing limit + int currentListings = getActiveListingsCount(seller.getUniqueID()); + int maxListings = getMaxListings(seller); + if (currentListings >= maxListings) { + logger.info("Player {} has reached max listings ({}/{})", + seller.getCommandSenderName(), 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)) { + logger.info("Player {} cannot afford listing fee of {}", + seller.getCommandSenderName(), 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(); + logger.info("Created auction listing {} by {} for {}", + listing.id, seller.getCommandSenderName(), + item.getDisplayName()); + + return listing; + } + + /** + * Get a listing by ID + */ + public AuctionListing getListing(int id) { + return listings.get(id); + } + + /** + * Get all active listings + */ + public List getActiveListings() { + processExpiredAuctions(); + return listings.values().stream() + .filter(AuctionListing::isActive) + .collect(Collectors.toList()); + } + + /** + * Get active listings by category + */ + public List getActiveListings(EnumAuctionCategory category) { + if (category == EnumAuctionCategory.ALL) { + return getActiveListings(); + } + return getActiveListings().stream() + .filter(l -> l.category == category) + .collect(Collectors.toList()); + } + + /** + * Search listings by item name + */ + public List searchListings(String query) { + String lowerQuery = query.toLowerCase(); + return getActiveListings().stream() + .filter(l -> l.item.getDisplayName().toLowerCase().contains(lowerQuery)) + .collect(Collectors.toList()); + } + + /** + * Get all listings by a seller (all statuses) + */ + public List getListingsBySeller(UUID sellerUUID) { + List 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 getListingsAsBidder(UUID bidderUUID) { + List ids = listingsByBidder.get(bidderUUID); + if (ids == null) { + return new ArrayList<>(); + } + return ids.stream() + .map(listings::get) + .filter(Objects::nonNull) + .filter(l -> bidderUUID.equals(l.highBidderUUID)) + .collect(Collectors.toList()); + } + + /** + * Get listings that need claiming by a player + * (items won, sales proceeds, cancelled/expired items) + */ + public List getClaimableListings(UUID playerUUID) { + List 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 + * @return true if bid was successful + */ + public boolean placeBid(int listingId, EntityPlayer bidder, long amount) { + AuctionListing listing = listings.get(listingId); + if (listing == null) { + return false; + } + + // Check if bidder can afford + if (!CurrencyController.Instance.canAfford(bidder, amount)) { + return false; + } + + // Store previous bidder for refund + UUID previousBidder = listing.highBidderUUID; + long previousBidAmount = listing.currentBid; + + // Try to place bid + if (!listing.placeBid(bidder.getUniqueID(), bidder.getCommandSenderName(), amount)) { + return false; + } + + // Withdraw bid amount from new bidder + CurrencyController.Instance.withdraw(bidder, amount); + + // Refund previous bidder via claims system + if (previousBidder != null) { + CurrencyController.Instance.addClaim( + previousBidder, + previousBidAmount, + "Auction Outbid", + String.valueOf(listingId) + ); + } + + // Update bidder index + addToBidderIndex(bidder.getUniqueID(), listingId); + + save(); + logger.info("Bid placed on listing {} by {} for {}", + listingId, bidder.getCommandSenderName(), amount); + + return true; + } + + /** + * Execute buyout on an auction + * @return true if buyout was successful + */ + public boolean buyout(int listingId, EntityPlayer buyer) { + AuctionListing listing = listings.get(listingId); + if (listing == null || listing.buyoutPrice <= 0) { + return false; + } + + // Check if buyer can afford + if (!CurrencyController.Instance.canAfford(buyer, listing.buyoutPrice)) { + return false; + } + + // Store previous bidder for refund + UUID previousBidder = listing.highBidderUUID; + long previousBidAmount = listing.currentBid; + + // Execute buyout + if (!listing.buyout(buyer.getUniqueID(), buyer.getCommandSenderName())) { + return false; + } + + // Withdraw buyout amount from buyer + CurrencyController.Instance.withdraw(buyer, listing.buyoutPrice); + + // Refund previous bidder via claims system + if (previousBidder != null) { + CurrencyController.Instance.addClaim( + previousBidder, + previousBidAmount, + "Auction Outbid (Buyout)", + String.valueOf(listingId) + ); + } + + // Update bidder index + addToBidderIndex(buyer.getUniqueID(), listingId); + + save(); + logger.info("Buyout executed on listing {} by {} for {}", + listingId, buyer.getCommandSenderName(), listing.buyoutPrice); + + return true; + } + + /** + * Cancel an auction listing + * @return true if cancellation was successful + */ + public boolean cancelListing(int listingId, EntityPlayer requester) { + AuctionListing listing = listings.get(listingId); + if (listing == null) { + return false; + } + + if (!listing.cancel(requester.getUniqueID())) { + return false; + } + + save(); + logger.info("Listing {} cancelled by {}", + listingId, requester.getCommandSenderName()); + + return true; + } + + // ==================== Claiming ==================== + + /** + * Claim seller proceeds from a sold auction + * @return true if claim was successful + */ + public boolean claimSellerProceeds(int listingId, EntityPlayer seller) { + AuctionListing listing = listings.get(listingId); + if (listing == null) { + return false; + } + + if (!listing.sellerUUID.equals(seller.getUniqueID())) { + return false; // Not the seller + } + + if (listing.status != EnumAuctionStatus.SOLD) { + return false; // Not sold + } + + if (listing.sellerClaimed) { + return false; // Already claimed + } + + // Deposit proceeds to seller + long proceeds = listing.getSellerProceeds(); + CurrencyController.Instance.deposit(seller, proceeds); + + listing.sellerClaimed = true; + checkAndMarkClaimed(listing); + save(); + + logger.info("Seller {} claimed {} from listing {}", + seller.getCommandSenderName(), proceeds, listingId); + + return true; + } + + /** + * Claim item from won auction + * @return The item if successful, null otherwise + */ + public ItemStack claimBuyerItem(int listingId, EntityPlayer buyer) { + AuctionListing listing = listings.get(listingId); + if (listing == null) { + return null; + } + + if (listing.highBidderUUID == null || + !listing.highBidderUUID.equals(buyer.getUniqueID())) { + return null; // Not the buyer + } + + if (listing.status != EnumAuctionStatus.SOLD) { + return null; // Not sold + } + + if (listing.buyerClaimed) { + return null; // Already claimed + } + + listing.buyerClaimed = true; + checkAndMarkClaimed(listing); + save(); + + logger.info("Buyer {} claimed item from listing {}", + buyer.getCommandSenderName(), listingId); + + return listing.item.copy(); + } + + /** + * Claim item from cancelled or expired auction (seller reclaiming) + * @return The item if successful, null otherwise + */ + public ItemStack claimExpiredItem(int listingId, EntityPlayer seller) { + AuctionListing listing = listings.get(listingId); + if (listing == null) { + return null; + } + + if (!listing.sellerUUID.equals(seller.getUniqueID())) { + return null; // Not the seller + } + + if (listing.status != EnumAuctionStatus.CANCELLED && + listing.status != EnumAuctionStatus.EXPIRED) { + return null; // Not claimable + } + + if (listing.sellerClaimed) { + return null; // Already claimed + } + + listing.sellerClaimed = true; + listing.status = EnumAuctionStatus.CLAIMED; + save(); + + logger.info("Seller {} reclaimed item from listing {}", + seller.getCommandSenderName(), listingId); + + return listing.item.copy(); + } + + /** + * Mark listing as fully claimed if both parties have claimed + */ + private void checkAndMarkClaimed(AuctionListing listing) { + if (listing.status == EnumAuctionStatus.SOLD) { + if (listing.sellerClaimed && listing.buyerClaimed) { + listing.status = EnumAuctionStatus.CLAIMED; + } + } + } + + // ==================== Expiration Processing ==================== + + /** + * Process all expired auctions + * Call this periodically (e.g., every minute) + */ + public void processExpiredAuctions() { + boolean changed = false; + + for (AuctionListing listing : listings.values()) { + if (listing.status == EnumAuctionStatus.ACTIVE && listing.isExpired()) { + listing.finalize(); + changed = true; + + // If sold, add proceeds to seller's claims + if (listing.status == EnumAuctionStatus.SOLD) { + // Proceeds will be claimed manually, no automatic deposit + logger.info("Auction {} ended with sale to {} for {}", + listing.id, listing.highBidderName, listing.currentBid); + } else { + logger.info("Auction {} expired without bids", listing.id); + } + } + } + + if (changed) { + save(); + } + } + + /** + * Clean up old claimed listings + * Call this periodically (e.g., daily) + */ + public void cleanupOldListings() { + long claimExpirationMs = ConfigMarket.ClaimExpirationDays * 24L * 60L * 60L * 1000L; + if (claimExpirationMs <= 0) { + return; // No expiration + } + + long cutoffTime = System.currentTimeMillis() - claimExpirationMs; + List 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(); + logger.info("Cleaned up {} old auction listings", toRemove.size()); + } + } + + // ==================== 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 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 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); + } + } + } + + // ==================== Permission Helpers ==================== + + /** + * Get maximum listings allowed for a player + */ + public int getMaxListings(EntityPlayer player) { + // TODO: Check for permission-based overrides + // e.g., CustomNpcsPermissions.hasCustomPermission(player, "cnpc.auction.slots.10") + return ConfigMarket.DefaultMaxListings; + } + + // ==================== 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) { + logger.error("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(); + + logger.info("Loaded {} auction listings", listings.size()); + + } catch (Exception e) { + logger.error("Error loading auctions", e); + } + } + + // ==================== Statistics ==================== + + /** + * Get total number of active listings + */ + public int getActiveListingCount() { + return (int) listings.values().stream() + .filter(l -> l.status == EnumAuctionStatus.ACTIVE) + .count(); + } + + /** + * Get total number of all listings + */ + public int getTotalListingCount() { + return listings.size(); + } +} diff --git a/src/main/java/noppes/npcs/controllers/data/AuctionListing.java b/src/main/java/noppes/npcs/controllers/data/AuctionListing.java new file mode 100644 index 000000000..e17a08112 --- /dev/null +++ b/src/main/java/noppes/npcs/controllers/data/AuctionListing.java @@ -0,0 +1,392 @@ +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.EnumAuctionCategory; +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; + + // Category for filtering + public EnumAuctionCategory category = EnumAuctionCategory.MISC; + + // Claim tracking + public boolean sellerClaimed = false; // Has seller claimed their proceeds? + public boolean buyerClaimed = false; // Has buyer claimed their item? + + public AuctionListing() { + } + + /** + * 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.category = EnumAuctionCategory.categorize(item); + 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; + + // 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.setInteger("Category", category.ordinal()); + compound.setBoolean("SellerClaimed", sellerClaimed); + compound.setBoolean("BuyerClaimed", buyerClaimed); + + 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; + } + + int categoryOrdinal = compound.getInteger("Category"); + if (categoryOrdinal >= 0 && categoryOrdinal < EnumAuctionCategory.values().length) { + category = EnumAuctionCategory.values()[categoryOrdinal]; + } else { + category = EnumAuctionCategory.MISC; + } + + sellerClaimed = compound.getBoolean("SellerClaimed"); + buyerClaimed = compound.getBoolean("BuyerClaimed"); + } +} diff --git a/src/main/java/noppes/npcs/roles/RoleAuctioneer.java b/src/main/java/noppes/npcs/roles/RoleAuctioneer.java new file mode 100644 index 000000000..0c0f53d07 --- /dev/null +++ b/src/main/java/noppes/npcs/roles/RoleAuctioneer.java @@ -0,0 +1,134 @@ +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.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, noAuctionMessage); + } else { + npc.say(player, "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, 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); + } +}