Initial commit

This commit is contained in:
Scifi9902
2026-10-12 13:57:05 -03:00
commit 4bde3b176a
2576 changed files with 212659 additions and 0 deletions
+34
View File
@@ -0,0 +1,34 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>ProjectCranked</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>Trade</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<artifactId>Utils</artifactId>
<groupId>net.crankedpvp</groupId>
</dependency>
<dependency>
<groupId>com.earth2me.essentials</groupId>
<artifactId>EssentialsX</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../.lib/EssentialsX-2.19.7.jar</systemPath>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,93 @@
package net.crankedpvp.trade;
import com.earth2me.essentials.Essentials;
import com.earth2me.essentials.IUser;
import com.earth2me.essentials.Teleport;
import com.earth2me.essentials.User;
import com.google.common.collect.MapMaker;
import lombok.Getter;
import net.crankedpvp.crankedutils.utils.EssentialsUtils;
import net.crankedpvp.crankedutils.utils.PluginUtils;
import net.crankedpvp.trade.commands.TradeCommand;
import net.crankedpvp.trade.listeners.TradeListener;
import net.crankedpvp.trade.struct.PlayerTrade;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitTask;
import java.util.Map;
import java.util.UUID;
public class TradePlugin extends JavaPlugin {
@Getter
private static TradePlugin instance;
private final Map<UUID, PlayerTrade> playerTradeMap = (new MapMaker()).concurrencyLevel(32).makeMap();
private BukkitTask tradeTask;
private Essentials ess;
@Override
public void onEnable() {
saveDefaultConfig();
instance = this;
this.ess = EssentialsUtils.getEssentials();
this.tradeTask = (new BukkitRunnable() {
public void run() {
playerTradeMap.values().forEach(PlayerTrade::onTradeTick);
}
}).runTaskTimer(this, 13L, 13L);
getCommand("trade").setExecutor(new TradeCommand(instance));
}
@Override
public void onDisable() {
if (this.playerTradeMap.size() > 0) {
Bukkit.getLogger().info("Cancelling " + this.playerTradeMap.values() + " player trades.");
this.playerTradeMap.values().forEach((trade) -> {
trade.cancelTrade(null);
});
}
if (this.tradeTask != null) {
this.tradeTask.cancel();
}
}
public PlayerTrade getCurrentTrade(Player player) {
return this.playerTradeMap.get(player.getUniqueId());
}
public void unregisterTrade(PlayerTrade trade) {
this.playerTradeMap.remove(trade.getPlayer1().getUniqueId());
this.playerTradeMap.remove(trade.getPlayer2().getUniqueId());
}
public void startPlayerTrade(Player player, Player player2) {
EssentialsUtils.clearTeleportRequests(player);
EssentialsUtils.clearTeleportRequests(player2);
player.closeInventory();
player2.closeInventory();
PlayerTrade trade = new PlayerTrade(player, player2);
this.playerTradeMap.put(player.getUniqueId(), trade);
this.playerTradeMap.put(player2.getUniqueId(), trade);
trade.openTradeMenu();
trade.playSound(Sound.WOOD_CLICK, 1.0F, 0.8F);
player.sendMessage(ChatColor.YELLOW + "Trading with " + ChatColor.BOLD + player2.getName() + ChatColor.YELLOW + "...");
player2.sendMessage(ChatColor.YELLOW + "Trading with " + ChatColor.BOLD + player.getName() + ChatColor.YELLOW + "...");
}
public Map<UUID, PlayerTrade> getPlayerTradeMap() {
return this.playerTradeMap;
}
}
@@ -0,0 +1,129 @@
package net.crankedpvp.trade.commands;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.Clickable;
import net.crankedpvp.trade.TradePlugin;
import net.crankedpvp.trade.struct.PlayerTrade;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.metadata.FixedMetadataValue;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TradeCommand implements CommandExecutor {
public TradePlugin betterTradeInstance;
public TradeCommand(TradePlugin instance) {
this.betterTradeInstance = instance;
}
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
if (!(sender instanceof Player)) {
return true;
} else {
Player pl = (Player)sender;
if (args.length != 1) {
pl.sendMessage(ChatColor.GOLD.toString() + ChatColor.BOLD + ChatColor.UNDERLINE + "Trade Commands");
pl.sendMessage(ChatColor.GOLD + "/trade <player>");
pl.sendMessage(ChatColor.GRAY + "Sends a trade request to the specified <player>.");
return true;
} else {
PlayerTrade trade = this.betterTradeInstance.getCurrentTrade(pl);
if (trade != null) {
pl.sendMessage(CC.RedB + "(!) " + CC.Red + "You already had an active trade!");
trade.cancelTrade(pl);
return true;
} else {
String tradie = args[0];
if (tradie.equalsIgnoreCase(pl.getName())) {
pl.sendMessage(ChatColor.RED + "'If a man loves the labour of his trade, apart from any question of success or fame, the gods have called him.'");
return true;
} else {
Player p_tradie = Bukkit.getPlayer(tradie);
if (p_tradie == null) {
pl.sendMessage(ChatColor.RED.toString() + ChatColor.BOLD + "(!)" + ChatColor.RED + " " + ChatColor.RED + "You aren't close enough to " + tradie + " to send a /trade.");
return true;
} else if (p_tradie.getName().equalsIgnoreCase(pl.getName())) {
pl.sendMessage(ChatColor.RED + "'If a man loves the labour of his trade, apart from any question of success or fame, the gods have called him.'");
return true;
} else if (!p_tradie.getWorld().getName().equalsIgnoreCase(pl.getWorld().getName())) {
pl.sendMessage(ChatColor.RED.toString() + ChatColor.BOLD + "(!)" + ChatColor.RED + " " + ChatColor.RED + "You aren't close enough to " + tradie + " to send a /trade.");
return true;
} else if (p_tradie.getLocation().distanceSquared(pl.getLocation()) > Math.pow(10.0D, 2.0D)) {
pl.sendMessage(ChatColor.RED.toString() + ChatColor.BOLD + "(!)" + ChatColor.RED + " " + ChatColor.RED + "You aren't close enough to " + tradie + " to send a /trade.");
pl.sendMessage(ChatColor.GRAY + "Move within 10 blocks of them and try again.");
return true;
} else {
if (pl.hasMetadata("trade_request") || p_tradie.hasMetadata("trade_request")) {
if (pl.hasMetadata("trade_request")) {
String stored_tradie = pl.getMetadata("trade_request").get(0).asString();
if (stored_tradie.equalsIgnoreCase(tradie)) {
if (p_tradie.hasMetadata("trade_request") && p_tradie.getMetadata("trade_request").get(0).asString().equalsIgnoreCase(pl.getName())) {
pl.removeMetadata("trade_request", betterTradeInstance);
p_tradie.removeMetadata("trade_request", betterTradeInstance);
this.betterTradeInstance.startPlayerTrade(pl, p_tradie);
return true;
}
pl.sendMessage(ChatColor.RED + p_tradie.getName() + "'s trade request has timed out.");
pl.removeMetadata("trade_request", betterTradeInstance);
return true;
}
}
if (p_tradie.hasMetadata("trade_request")) {
if (p_tradie.getMetadata("trade_request").get(0).asString().equalsIgnoreCase(pl.getName())) {
pl.removeMetadata("trade_request", betterTradeInstance);
p_tradie.removeMetadata("trade_request", betterTradeInstance);
this.betterTradeInstance.startPlayerTrade(pl, p_tradie);
}
return true;
}
}
pl.setMetadata("trade_request", new FixedMetadataValue(betterTradeInstance, p_tradie.getName()));
pl.sendMessage(ChatColor.GOLD.toString() + ChatColor.BOLD + "(!)" + ChatColor.GOLD + " You have sent a trade request to " + p_tradie.getName() + "!");
Clickable clickable = new Clickable((ChatColor.GOLD.toString() + ChatColor.BOLD + "TRADE " + ChatColor.YELLOW + pl.getName() + ChatColor.GOLD + " wants to trade with you. " + ChatColor.YELLOW + "/trade " + pl.getName()), "&7Click to accept trade.", "/trade " + pl.getName());
clickable.sendToPlayer(p_tradie);
return true;
}
}
}
}
}
}
public List<String> onTabComplete(CommandSender sender, Command cmd, String label, String[] args) {
List<String> results = new ArrayList();
if (args.length != 1) {
return null;
} else {
String s = args[0];
Iterator var7 = Bukkit.getOnlinePlayers().iterator();
while(true) {
Player pl;
do {
if (!var7.hasNext()) {
return results.size() > 0 ? results : null;
}
pl = (Player)var7.next();
} while(sender instanceof Player && !((Player)sender).canSee(pl));
if (pl.getName().toLowerCase().startsWith(s.toLowerCase())) {
results.add(pl.getName());
}
}
}
}
}
@@ -0,0 +1,144 @@
package net.crankedpvp.trade.guis;
import com.google.common.collect.Lists;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.cosmicgui.CosmicGUI;
import net.crankedpvp.crankedutils.utils.cosmicgui.InventoryItem;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.trade.struct.PlayerTrade;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
import java.util.Iterator;
import java.util.List;
public class TradeMenu extends CosmicGUI {
public static List<Integer> leftTradingSlots = Lists.newArrayList(1, 2, 3, 9, 10, 11, 12, 18, 19, 20, 21, 27, 28, 29, 30, 36, 37, 38, 39, 45, 46, 47, 48);
private static final List<Integer> rightTradingSlots = Lists.newArrayList(5, 6, 7, 14, 15, 16, 17, 23, 24, 25, 26, 32, 33, 34, 35, 41, 42, 43, 44, 50, 51, 52, 53);
private final PlayerTrade trade;
private final InventoryItem dividerItem;
private long lastClick;
private long lastItemModified;
public PlayerTrade getTrade() {
return this.trade;
}
public TradeMenu(Player player, String title, PlayerTrade trade) {
super(player, title, 54);
this.dividerItem = new InventoryItem((new ItemBuilder(new ItemStack(Material.STAINED_GLASS_PANE, 1, (short)7)).setName(" ").build()));
this.lastClick = 0L;
this.trade = trade;
this.setOnClose(() -> {
this.trade.cancelTrade(this.player);
});
}
public void redraw() {
this.inventory.clear();
this.getInventoryItems().clear();
this.updateToggleButtons();
this.drawItemsPlayerIsTrading(this.player, leftTradingSlots);
this.drawItemsPlayerIsTrading(this.trade.getOppositePlayer(this.player), rightTradingSlots);
this.setDividers();
this.player.updateInventory();
}
public void updateToggleButtons() {
this.setItem(0, this.getAcceptedPane(this.player).click(() -> {
if (this.checkCanClick(false)) {
this.trade.toggleAccepted(this.player);
this.redraw();
}
}));
Player opposite = this.trade.getOppositePlayer(this.player);
this.setItem(8, this.getAcceptedPane(opposite));
}
private boolean checkCanClick(boolean modified) {
if ((modified ? this.lastItemModified : this.lastClick) != 0L && (modified ? this.lastItemModified : this.lastClick) > System.currentTimeMillis()) {
this.player.sendMessage(CC.Red + "You are clicking too fast! Please slow it down.");
return false;
} else {
if (modified) {
this.lastItemModified = System.currentTimeMillis() + 100L;
} else {
this.lastClick = System.currentTimeMillis() + 500L;
}
return true;
}
}
public void onUnknownItemClick(InventoryClickEvent event) {
ItemStack item = event.getCurrentItem();
if (item != null && item.getType() != Material.AIR) {
if (event.getInventory() != null && event.getInventory().getTitle().equals(this.title) && event.getWhoClicked().equals(this.player) && event.getClickedInventory() != null && event.getClickedInventory().getTitle().equals("container.inventory") && event.getClickedInventory().equals(this.player.getOpenInventory().getBottomInventory())) {
if (!this.trade.canTradeItem(this.player, item)) {
return;
}
if (!this.checkCanClick(true)) {
return;
}
this.player.getInventory().setItem(event.getSlot(), null);
this.trade.addItemToTradeList(this.player, item);
this.redraw();
}
}
}
private void drawItemsPlayerIsTrading(Player player, List<Integer> slotsToUse) {
List<ItemStack> itemsInTrade = this.trade.getCurrentlyTradedItems().get(player.getUniqueId());
if (itemsInTrade != null && !itemsInTrade.isEmpty()) {
int itemIndex = 0;
Integer slot;
InventoryItem invItem;
for(Iterator<Integer> var5 = slotsToUse.iterator(); var5.hasNext(); this.setItem(slot, invItem)) {
slot = var5.next();
if (itemIndex >= itemsInTrade.size()) {
break;
}
ItemStack tradeItem = itemsInTrade.get(itemIndex++);
invItem = new InventoryItem(tradeItem);
if (player.equals(this.player)) {
invItem.click(() -> {
if (this.checkCanClick(true)) {
this.trade.returnItemFromTradeList(this.player, tradeItem);
this.redraw();
}
});
}
}
}
}
public void setDividers() {
int slot = 4;
for(int i = 0; i < 6; ++i) {
int newSlot = i * 9 + slot;
if (newSlot >= this.inventory.getSize()) {
break;
}
this.setItem(newSlot, this.dividerItem);
}
}
public InventoryItem getAcceptedPane(Player playerFor) {
boolean hasAccepted = this.trade.hasAccepted(playerFor);
return new InventoryItem((new ItemBuilder(Material.STAINED_GLASS_PANE, this.trade.getTradeCountdown()).setName(hasAccepted ? CC.GreenB + "Trade Accepting..." : CC.YellowB + "Click to Accept").addLoreLine(hasAccepted ? CC.Gray + "Modify the trade to cancel." : CC.Gray + "Click to accept the trade.")).setColor(hasAccepted ? DyeColor.LIME : DyeColor.RED).build());
}
}
@@ -0,0 +1,55 @@
package net.crankedpvp.trade.listeners;
import net.crankedpvp.trade.TradePlugin;
import net.crankedpvp.trade.struct.PlayerTrade;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
public class TradeListener implements Listener {
private TradePlugin instance;
public TradeListener(TradePlugin plugin) {
this.instance = plugin;
}
@EventHandler(
priority = EventPriority.HIGHEST,
ignoreCancelled = true
)
public void onPlayerPickupItem(PlayerPickupItemEvent event) {
if (this.instance.getCurrentTrade(event.getPlayer()) != null) {
event.setCancelled(true);
}
}
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
public void onPlayerDamage(EntityDamageEvent event) {
if (event.getEntity() instanceof Player) {
Player pl = (Player)event.getEntity();
if (this.instance.getCurrentTrade(pl) != null) {
pl.closeInventory();
}
}
}
@EventHandler
public void onInventoryOpen(InventoryOpenEvent event) {
PlayerTrade trade = this.instance.getCurrentTrade((Player)event.getPlayer());
if (trade != null && !event.getInventory().getTitle().contains(" ")) {
event.setCancelled(true);
Bukkit.getLogger().info("Player " + event.getPlayer().getName() + " tried to open " + event.getInventory().getTitle() + " while in a trade!?");
}
}
}
@@ -0,0 +1,330 @@
// =============================================== //
// Recompile disabled. Please run Recaf with a JDK //
// =============================================== //
// Decompiled with: FernFlower
// Class Version: 8
package net.crankedpvp.trade.struct;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.PlayerUtils;
import net.crankedpvp.trade.TradePlugin;
import net.crankedpvp.trade.guis.TradeMenu;
import org.bukkit.Bukkit;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.*;
public class PlayerTrade {
private final Player player1;
private final Player player2;
private TradeMenu player1Menu;
private TradeMenu player2Menu;
private final Map<UUID, LinkedList<ItemStack>> currentlyTradedItems = new HashMap<>();
private int tradeCountdown = 10;
private boolean tradeSuccess = false;
private boolean cancelled = false;
private boolean player1Accepted = false;
private boolean player2Accepted = false;
private long lastWindowUpdate;
public PlayerTrade(Player player, Player player2) {
this.player1 = player;
this.player2 = player2;
}
public void onTradeTick() {
if (this.lastWindowUpdate == 0L || this.lastWindowUpdate <= System.currentTimeMillis()) {
this.lastWindowUpdate = System.currentTimeMillis() + 100L;
if (this.player1.isValid() && this.player2.isValid()) {
if (this.player2Accepted && this.player1Accepted) {
if (this.tradeCountdown <= 1) {
this.completeTrade();
} else {
--this.tradeCountdown;
this.updateTradeMenus();
}
} else if (this.tradeCountdown < 10) {
this.tradeCountdown = 10;
this.updateTradeMenus();
}
} else {
this.cancelTrade(null);
Bukkit.getLogger().info("Unable to finish trade due to player being invalid: " + this);
}
}
}
public void cancelTrade(Player cancelled) {
if (!this.cancelled && !this.tradeSuccess) {
this.cancelled = true;
this.returnItems(this.player1);
this.returnItems(this.player2);
this.player1.closeInventory();
this.player2.closeInventory();
this.sendMessage(CC.YellowB + "Trade cancelled" + (cancelled != null ? " " + CC.Yellow + "by " + cancelled.getName() + "!" : "."));
this.unregister();
}
}
public void completeTrade() {
if (!this.cancelled && !this.tradeSuccess) {
this.tradeSuccess = true;
int p1Sent = this.giveTradeItems(this.player1, this.player2);
int p2Sent = this.giveTradeItems(this.player2, this.player1);
this.player1.sendMessage(CC.GreenB + "Trade Accepted (" + CC.Green + "Received " + CC.GreenB + p2Sent + CC.Green + " item" + (p2Sent > 1 ? "s" : "") + ", gave " + CC.GreenB + p1Sent + CC.Green + " item" + (p1Sent > 1 ? "s" : "") + CC.GreenB + ")");
this.player2.sendMessage(CC.GreenB + "Trade Accepted (" + CC.Green + "Received " + CC.GreenB + p1Sent + CC.Green + " item" + (p1Sent > 1 ? "s" : "") + ", gave " + CC.GreenB + p2Sent + CC.Green + " item" + (p2Sent > 1 ? "s" : "") + CC.GreenB + ")");
this.unregister();
this.player1.closeInventory();
this.player2.closeInventory();
this.playSound(Sound.BLAZE_HIT, 1.0F, 1.5F);
Bukkit.getLogger().info("[CrankedTrade] " + this.player1.getName() + " has traded " + this.player2.getName() + " successfully!");
}
}
private int giveTradeItems(Player playersTradeItems, Player playerToReceiveItems) {
List<ItemStack> items = this.currentlyTradedItems.get(playersTradeItems.getUniqueId());
if (items != null && !items.isEmpty()) {
for (ItemStack toReceive : items) {
PlayerUtils.giveOrDropProtectedItem(playerToReceiveItems, toReceive, 60);
}
Bukkit.getLogger().info("[CrankedTrade] Giving " + playerToReceiveItems.getName() + " trade items of " + playersTradeItems.getName() + " : " + Arrays.toString(items.toArray(new ItemStack[items.size()])));
int size = items.size();
playerToReceiveItems.updateInventory();
items.clear();
return size;
} else {
return 0;
}
}
private void returnItems(Player player) {
List<ItemStack> itemsToReturn = this.currentlyTradedItems.get(player.getUniqueId());
if (itemsToReturn != null) {
for (ItemStack toRetr : itemsToReturn) {
PlayerUtils.giveOrDropProtectedItem(player, toRetr, 60);
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 1.0F, 1.0F);
}
if (itemsToReturn.size() > 0) {
Bukkit.getLogger().info("Returning " + Arrays.toString(itemsToReturn.toArray(new ItemStack[0])));
}
itemsToReturn.clear();
}
}
public void addItemToTradeList(Player player, ItemStack item) {
LinkedList<ItemStack> list = this.currentlyTradedItems.computeIfAbsent(player.getUniqueId(), (l) -> new LinkedList<>());
list.add(item);
this.onTradeUpdate(player);
}
public void returnItemFromTradeList(Player player, ItemStack item) {
List<ItemStack> itemsStillTrading = this.currentlyTradedItems.get(player.getUniqueId());
if (itemsStillTrading != null && itemsStillTrading.contains(item)) {
itemsStillTrading.remove(item);
PlayerUtils.giveOrDropProtectedItem(player, item, -1);
this.onTradeUpdate(player);
} else {
Bukkit.getLogger().info("[CrankedTrade] Not removing " + item + " for " + player.getName() + " due to list not having any trade items!");
}
}
public boolean canTradeItem(Player player, ItemStack item) {
List<ItemStack> alreadyTrading = this.getCurrentlyTradedItems().get(player.getUniqueId());
int limit = TradeMenu.leftTradingSlots.size();
if (alreadyTrading != null && alreadyTrading.size() >= limit) {
player.sendMessage(CC.RedB + "(!) " + CC.Red + "You can only trade " + limit + " items at once!");
player.sendMessage(CC.Gray + "Remove some items from the trade window and try again.");
return false;
} else {
return true;
}
}
public Player getOppositePlayer(Player player) {
if (this.player1.equals(player)) {
return this.player2;
} else {
return this.player2.equals(player) ? this.player1 : null;
}
}
public boolean hasAccepted(Player player) {
if (this.player1.equals(player)) {
return this.player1Accepted;
} else {
return this.player2.equals(player) && this.player2Accepted;
}
}
public boolean toggleAccepted(Player player) {
boolean retr = false;
if (this.tradeCountdown < 10) {
this.player1Accepted = false;
this.player2Accepted = false;
this.playSound(Sound.NOTE_PIANO, 1.1F, 1.0F);
} else {
boolean player2Accepted;
if (this.player1.equals(player)) {
player2Accepted = !this.player1Accepted;
this.player1Accepted = player2Accepted;
retr = player2Accepted;
} else if (this.player2.equals(player)) {
player2Accepted = !this.player2Accepted;
this.player2Accepted = player2Accepted;
retr = player2Accepted;
}
}
this.updateOppositeButtons(player);
return retr;
}
private void updateOppositeButtons(Player player) {
Player opp = this.getOppositePlayer(player);
if (opp.equals(this.player2)) {
this.player2Menu.updateToggleButtons();
} else if (opp.equals(this.player1)) {
this.player1Menu.updateToggleButtons();
}
opp.updateInventory();
}
private void updateOppositeMenu(Player player) {
Player opp = this.getOppositePlayer(player);
if (opp.equals(this.player2)) {
this.player2Menu.redraw();
} else if (opp.equals(this.player1)) {
this.player1Menu.redraw();
}
}
private void onTradeUpdate(Player whoUpdated) {
if (this.player1Accepted) {
this.player1.sendMessage(CC.Yellow + "Trade modified, re-accept the trade.");
this.player1.playSound(this.player1.getLocation(), Sound.NOTE_PIANO, 3.0F, 1.05F);
}
if (this.player2Accepted) {
this.player2.sendMessage(CC.Yellow + "Trade modified, re-accept the trade.");
this.player2.playSound(this.player2.getLocation(), Sound.NOTE_PIANO, 3.0F, 1.05F);
}
this.player1Accepted = false;
this.player2Accepted = false;
this.updateOppositeMenu(whoUpdated);
}
public void openTradeMenu() {
if (this.player1Menu == null) {
(this.player1Menu = new TradeMenu(this.player1, this.getTradeInventoryTitle(this.player2), this)).openGUI(TradePlugin.getInstance());
}
if (this.player2Menu == null) {
(this.player2Menu = new TradeMenu(this.player2, this.getTradeInventoryTitle(this.player1), this)).openGUI(TradePlugin.getInstance());
}
}
private void updateTradeMenus() {
if (!this.cancelled && !this.tradeSuccess) {
this.player1Menu.redraw();
this.player2Menu.redraw();
}
}
public void playSound(Sound sound, float pitch, float vol) {
this.player1.playSound(this.player1.getLocation(), sound, pitch, vol);
this.player2.playSound(this.player2.getLocation(), sound, pitch, vol);
}
private void sendMessage(String msg) {
this.player1.sendMessage(msg);
this.player2.sendMessage(msg);
}
private String getTradeInventoryTitle(Player toShowNameOnRight) {
String lPName = "You";
String title;
for (title = " You"; title.length() + toShowNameOnRight.getName().length() <= 30; title = title + " ") {
}
title = title + toShowNameOnRight.getName();
return title.length() <= 32 ? title : title.substring(0, 31);
}
private void unregister() {
TradePlugin.getInstance().unregisterTrade(this);
}
public String toString() {
return "player1=" + (this.player1 != null ? this.player1.getName() + " valid=" + this.player1.isValid() : "none") + ", player2=" + (this.player2 != null ? this.player2.getName() + " valid=" + this.player2.isValid() : "Null?") + ", Traded items=" + this.currentlyTradedItems.toString() + ", p1Accept=" + this.player1Accepted + " p2Accept=" + this.player2Accepted;
}
public Player getPlayer1() {
return this.player1;
}
public Player getPlayer2() {
return this.player2;
}
public TradeMenu getPlayer1Menu() {
return this.player1Menu;
}
public TradeMenu getPlayer2Menu() {
return this.player2Menu;
}
public Map<UUID, LinkedList<ItemStack>> getCurrentlyTradedItems() {
return this.currentlyTradedItems;
}
public int getTradeCountdown() {
return this.tradeCountdown;
}
public boolean isTradeSuccess() {
return this.tradeSuccess;
}
public boolean isCancelled() {
return this.cancelled;
}
public boolean isPlayer1Accepted() {
return this.player1Accepted;
}
public boolean isPlayer2Accepted() {
return this.player2Accepted;
}
public long getLastWindowUpdate() {
return this.lastWindowUpdate;
}
public void setTradeCountdown(int tradeCountdown) {
this.tradeCountdown = tradeCountdown;
}
}
View File
+8
View File
@@ -0,0 +1,8 @@
name: CrankedTrade
version: 1.0
main: net.crankedpvp.trade.TradePlugin
commands:
trade:
depend:
- CrankedUtils
- Essentials