Initial release v1.0.0

This commit is contained in:
BigPappa committed 2026-08-06 22:07:12 -05:00
commit 3fef65b903
314 files changed
+27448

No files matched your search

@@ -0,0 +1,179 @@
package com.rsscripting.rswarehouse.variantsdamaged;
import com.rsscripting.rswarehouse.variants.dao.DamagedVariantsDAO;
import com.rsscripting.rswarehouse.model.DamagedVariant;
import com.rsscripting.rswarehouse.menuholder.RSMenuHolder;
import com.rsscripting.rswarehouse.utils.ItemStackUtils;
import com.rsscripting.rswarehouse.constants.RSKeys;
import com.rsscripting.rswarehouse.utils.RSMenuUtils;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.Damageable;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataType;
import java.util.ArrayList;
import java.util.List;
public class DamagedVariantsMenu {
public static void open(
Player player,
int itemId,
int parentInventoryId
) {
Inventory menu =
Bukkit.createInventory(
new RSMenuHolder(
"DAMAGED_VARIANTS:" + itemId
),
54,
Component.text(
"Damaged Variants"
).color(
NamedTextColor.BLUE
)
);
ItemStack filler =
RSMenuUtils.createFillerPane();
for (int slot = 0; slot <= 8; slot++) {
menu.setItem(
slot,
filler
);
}
for (int slot = 45; slot <= 53; slot++) {
menu.setItem(
slot,
filler
);
}
menu.setItem(
4,
RSMenuUtils.createMenuItem(
Material.OAK_DOOR,
"§a Back"
)
);
List<DamagedVariant> variants =
DamagedVariantsDAO.getDamagedVariants(
parentInventoryId
);
int slot = 9;
for (
DamagedVariant variant
: variants
) {
ItemStack item =
ItemStackUtils.deserialize(
variant.serializedItem()
);
if (item == null) {
continue;
}
if (
item.getItemMeta()
instanceof Damageable damageable
) {
ItemMeta meta =
item.getItemMeta();
int maxDurability =
item.getType()
.getMaxDurability();
int remainingDurability =
maxDurability
- damageable.getDamage();
List<Component> lore =
new ArrayList<>();
lore.add(
Component.text(
"Durability: "
+ remainingDurability
+ " / "
+ maxDurability
)
);
lore.add(
Component.text(
"Quantity: "
+ String.format(
"%,d",
variant.quantity()
)
)
);
meta.lore(
lore
);
item.setItemMeta(
meta
);
}
ItemMeta meta =
item.getItemMeta();
meta.getPersistentDataContainer()
.set(
RSKeys.DAMAGED_VARIANT_ID,
PersistentDataType.INTEGER,
variant.id()
);
item.setItemMeta(
meta
);
menu.setItem(
slot,
item
);
slot++;
if (slot >= 45) {
break;
}
}
player.openInventory(
menu
);
}
}
@@ -0,0 +1,149 @@
package com.rsscripting.rswarehouse.variantsdamaged;
import com.rsscripting.rswarehouse.item.TransactionAmountMenu;
import com.rsscripting.rswarehouse.menuholder.RSMenuHolder;
import com.rsscripting.rswarehouse.constants.RSKeys;
import com.rsscripting.rswarehouse.session.VariantType;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import com.rsscripting.rswarehouse.session.GuiSession;
import com.rsscripting.rswarehouse.session.GuiSessionManager;
import com.rsscripting.rswarehouse.session.TransactionSession;
public class DamagedVariantsMenuListener
implements Listener {
@EventHandler
public void onInventoryClick(
InventoryClickEvent event
) {
if (
!(event.getWhoClicked()
instanceof Player player)
) {
return;
}
if (
!(event.getInventory()
.getHolder()
instanceof RSMenuHolder holder)
) {
return;
}
if (
!holder.getMenuId()
.startsWith(
"DAMAGED_VARIANTS:"
)
) {
return;
}
event.setCancelled(
true
);
int itemId =
Integer.parseInt(
holder.getMenuId()
.split(":")[1]
);
/*
|--------------------------------------------------------------------------
| BACK
|--------------------------------------------------------------------------
*/
if (event.getSlot() == 4) {
TransactionAmountMenu.open(
player,
itemId,
0
);
return;
}
/*
|--------------------------------------------------------------------------
| DAMAGED VARIANT
|--------------------------------------------------------------------------
*/
ItemStack clickedItem =
event.getCurrentItem();
if (clickedItem == null) {
return;
}
ItemMeta meta =
clickedItem.getItemMeta();
if (meta == null) {
return;
}
Integer damagedVariantId =
meta.getPersistentDataContainer()
.get(
RSKeys.DAMAGED_VARIANT_ID,
PersistentDataType.INTEGER
);
if (damagedVariantId == null) {
return;
}
GuiSession session =
GuiSessionManager.getSession(
player
);
TransactionSession transactionSession =
new TransactionSession(itemId);
transactionSession.setVariantType(
VariantType.DAMAGED
);
transactionSession.setVariantRecordId(
damagedVariantId
);
session.setItemActionSession(
transactionSession
);
DamagedVariantsTransactionMenu.open(
player,
damagedVariantId,
0
);
}
}
@@ -0,0 +1,321 @@
package com.rsscripting.rswarehouse.variantsdamaged;
import com.rsscripting.rswarehouse.variants.dao.DamagedVariantsDAO;
import com.rsscripting.rswarehouse.menuholder.RSMenuHolder;
import com.rsscripting.rswarehouse.utils.ItemStackUtils;
import com.rsscripting.rswarehouse.utils.RSMenuUtils;
import com.rsscripting.rswarehouse.model.DamagedVariant;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.List;
public class DamagedVariantsTransactionMenu {
public static void open(
Player player,
int damagedVariantId,
int amount
) {
String title;
if (amount > 0) {
title =
"Deposit: "
+ String.format(
"%,d",
amount
);
}
else if (amount < 0) {
title =
"Withdraw: "
+ String.format(
"%,d",
Math.abs(
amount
)
);
}
else {
title =
"Amount: 0";
}
Inventory menu =
Bukkit.createInventory(
new RSMenuHolder(
"DAMAGED_ITEM_ACTION"
),
27,
Component.text(
title
).color(
NamedTextColor.BLUE
)
);
/*
|--------------------------------------------------------------------------
| FILLER
|--------------------------------------------------------------------------
*/
for (int i = 0; i < menu.getSize(); i++) {
menu.setItem(
i,
RSMenuUtils.createFillerPane()
);
}
/*
|--------------------------------------------------------------------------
| CENTER ITEM
|--------------------------------------------------------------------------
*/
DamagedVariant damagedVariant =
DamagedVariantsDAO.getDamagedVariantById(
damagedVariantId
);
if (damagedVariant != null) {
ItemStack item =
ItemStackUtils.deserialize(
damagedVariant.serializedItem()
);
if (item != null) {
ItemMeta meta =
item.getItemMeta();
if (meta != null) {
long playerHas =
getPlayerItemCount(
player,
item
);
meta.lore(
List.of(
Component.text(
"In Stock: "
+ String.format(
"%,d",
damagedVariant.quantity()
)
).color(
NamedTextColor.LIGHT_PURPLE
),
Component.text(
"Player Has: "
+ String.format(
"%,d",
playerHas
)
).color(
NamedTextColor.GREEN
),
Component.text(
" "
),
Component.text(
"Click to complete transaction."
).color(
NamedTextColor.YELLOW
)
)
);
item.setItemMeta(
meta
);
}
menu.setItem(
13,
item
);
}
}
/*
|--------------------------------------------------------------------------
| WITHDRAW
|--------------------------------------------------------------------------
*/
ItemStack subtract64 =
RSMenuUtils.createMenuItem(
Material.RED_WOOL,
"§cSubtract 64"
);
subtract64.setAmount(
64
);
menu.setItem(
9,
subtract64
);
ItemStack subtract16 =
RSMenuUtils.createMenuItem(
Material.RED_WOOL,
"§cSubtract 16"
);
subtract16.setAmount(
16
);
menu.setItem(
10,
subtract16
);
ItemStack subtract1 =
RSMenuUtils.createMenuItem(
Material.RED_WOOL,
"§cSubtract 1"
);
subtract1.setAmount(
1
);
menu.setItem(
11,
subtract1
);
/*
|--------------------------------------------------------------------------
| DEPOSIT
|--------------------------------------------------------------------------
*/
ItemStack add1 =
RSMenuUtils.createMenuItem(
Material.GREEN_WOOL,
"§cAdd 1"
);
add1.setAmount(
1
);
menu.setItem(
15,
add1
);
ItemStack add16 =
RSMenuUtils.createMenuItem(
Material.GREEN_WOOL,
"§cAdd 16"
);
add16.setAmount(
16
);
menu.setItem(
16,
add16
);
ItemStack add64 =
RSMenuUtils.createMenuItem(
Material.GREEN_WOOL,
"§cAdd 64"
);
add64.setAmount(
64
);
menu.setItem(
17,
add64
);
/*
|--------------------------------------------------------------------------
| BACK
|--------------------------------------------------------------------------
*/
menu.setItem(
4,
RSMenuUtils.createMenuItem(
Material.OAK_DOOR,
"§eReturn to main menu."
)
);
player.openInventory(
menu
);
}
public static long getPlayerItemCount(
Player player,
ItemStack target
) {
long count = 0;
for (ItemStack item : player.getInventory().getContents()) {
if (item == null) {
continue;
}
if (
item.isSimilar(
target
)
) {
count += item.getAmount();
}
}
return count;
}
}
@@ -0,0 +1,433 @@
package com.rsscripting.rswarehouse.variantsdamaged;
import com.rsscripting.rswarehouse.item.TransactionAmountMenu;
import com.rsscripting.rswarehouse.variants.dao.DamagedVariantsDAO;
import com.rsscripting.rswarehouse.autodeposit.autodepositdao.AutoDepositDAO;
import com.rsscripting.rswarehouse.category.categorymenu.CategoryMenu;
import com.rsscripting.rswarehouse.model.DamagedVariant;
import com.rsscripting.rswarehouse.menuholder.RSMenuHolder;
import com.rsscripting.rswarehouse.item.TransactionUtils;
import com.rsscripting.rswarehouse.session.GuiSession;
import com.rsscripting.rswarehouse.session.GuiSessionManager;
import com.rsscripting.rswarehouse.session.TransactionSession;
import com.rsscripting.rswarehouse.utils.ItemStackUtils;
import com.rsscripting.rswarehouse.utils.RSMessageUtils;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class DamagedVariantsTransactionMenuListener
implements Listener {
@EventHandler
public void onInventoryClick(
InventoryClickEvent event
) {
if (
!(event.getWhoClicked()
instanceof Player player)
) {
return;
}
if (
!(event.getInventory()
.getHolder()
instanceof RSMenuHolder holder)
) {
return;
}
if (
!holder.getMenuId()
.equals(
"DAMAGED_ITEM_ACTION"
)
) {
return;
}
event.setCancelled(
true
);
GuiSession session =
GuiSessionManager.getSession(
player
);
TransactionSession itemSession =
session.getItemActionSession();
if (itemSession == null) {
return;
}
int amount =
itemSession.getAmount();
int warehouseItemId =
itemSession.getWarehouseItemId();
int damagedVariantId =
itemSession.getVariantRecordId();
DamagedVariant damagedVariant =
DamagedVariantsDAO.getDamagedVariantById(
damagedVariantId
);
if (damagedVariant == null) {
return;
}
if (event.getSlot() == 4) {
TransactionAmountMenu.open(
player,
warehouseItemId,
0
);
return;
}
if (event.getSlot() == 5) {
player.closeInventory();
}
ItemStack item =
ItemStackUtils.deserialize(
damagedVariant.serializedItem()
);
if (item == null) {
return;
}
long playerHas =
TransactionUtils.getPlayerItemCount(
player,
item
);
if (event.getSlot() == 13) {
if (amount == 0) {
return;
}
if (amount > 0) {
ItemStack depositItem =
item.clone();
depositItem.setAmount(
1
);
if (
removeItems(
player,
depositItem,
amount
)
) {
DamagedVariantsDAO.addDamagedVariantQuantity(
damagedVariant.id(),
amount
);
player.sendMessage(
"§aYou have deposited "
+ amount
+ " items."
);
itemSession.setAmount(
0
);
DamagedVariantsTransactionMenu.open(
player,
damagedVariantId,
0
);
}
return;
}
else {
int withdrawAmount =
Math.abs(
amount
);
ItemStack withdrawItem =
item.clone();
withdrawItem.setAmount(
withdrawAmount
);
if (
AutoDepositDAO.shouldBlockWithdrawal(
player.getUniqueId(),
withdrawItem
)
) {
RSMessageUtils.error(
player,
"Disable Auto Deposit or remove this item from your filter before withdrawing it."
);
return;
}
player.getInventory()
.addItem(
withdrawItem
);
DamagedVariantsDAO.removeDamagedVariantQuantity(
damagedVariant.id(),
withdrawAmount
);
player.sendMessage(
"§aYou have withdrawn "
+ withdrawAmount
+ " items."
);
itemSession.setAmount(
0
);
DamagedVariantsTransactionMenu.open(
player,
damagedVariantId,
0
);
}
return;
}
long warehouseStock =
damagedVariant.quantity();
int inventoryCapacity =
getAvailableCapacity(
player,
item
);
long maxWithdraw =
Math.min(
warehouseStock,
inventoryCapacity
);
switch (
event.getSlot()
) {
case 9 ->
amount -= 64;
case 10 ->
amount -= 16;
case 11 ->
amount -= 1;
case 15 ->
amount += 1;
case 16 ->
amount += 16;
case 17 ->
amount += 64;
default -> {
return;
}
}
if (amount > playerHas) {
amount =
(int) playerHas;
}
if (
amount < -maxWithdraw
)
{
amount =
(int) -maxWithdraw;
}
itemSession.setAmount(
amount
);
DamagedVariantsTransactionMenu.open(
player,
damagedVariantId,
amount
);
}
private boolean removeItems(
Player player,
ItemStack target,
int amount
) {
int remaining =
amount;
ItemStack[] contents =
player.getInventory()
.getContents();
for (int slot = 0;
slot < contents.length;
slot++) {
ItemStack item =
contents[slot];
if (item == null) {
continue;
}
if (!item.isSimilar(target)) {
continue;
}
if (
item.getAmount()
<= remaining
) {
remaining -=
item.getAmount();
player.getInventory()
.setItem(
slot,
null
);
}
else {
item.setAmount(
item.getAmount()
- remaining
);
remaining =
0;
}
if (remaining <= 0) {
return true;
}
}
return false;
}
private int getAvailableCapacity(
Player player,
ItemStack target
) {
int capacity = 0;
int maxStack =
target.getMaxStackSize();
for (
ItemStack item :
player.getInventory()
.getStorageContents()
) {
if (item == null) {
capacity += maxStack;
continue;
}
if (
item.isSimilar(
target
)
) {
capacity +=
maxStack
- item.getAmount();
}
}
return capacity;
}
}