Files
CustomNPC-Plus/src/main/java/noppes/npcs/containers/ContainerAnvilRepair.java
T
2025-03-13 17:14:45 -04:00

306 lines
11 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package noppes.npcs.containers;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.*;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
import noppes.npcs.api.handler.data.IAnvilRecipe;
import noppes.npcs.controllers.RecipeController;
import noppes.npcs.controllers.data.RecipeAnvil;
public class ContainerAnvilRepair extends Container {
// A 2-slot crafting matrix: slot 0 = damaged item, slot 1 = repair material.
public InventoryCrafting anvilMatrix = new InventoryCrafting(this, 2, 1);
// Single-slot output inventory.
public InventoryCraftResult anvilResult = new InventoryCraftResult();
private EntityPlayer player;
private World worldObj;
private int posX, posY, posZ;
public int repairCost = 0;
public int repairMaterialConsumed = 0;
public ContainerAnvilRepair(InventoryPlayer playerInv, World world, int x, int y, int z) {
this.worldObj = world;
this.posX = x;
this.posY = y;
this.posZ = z;
this.player = playerInv.player;
// Output slot (index 0) using our custom SlotAnvilOutput.
this.addSlotToContainer(new SlotAnvilOutput(this, anvilResult, 0, 133, 47));
// Input slot 0: damaged item. We restrict its stack size to 1.
this.addSlotToContainer(new Slot(anvilMatrix, 0, 26, 47) {
@Override
public int getSlotStackLimit() {
return 1;
}
});
// Input slot 1: repair material. Override onSlotChanged so that changes to the stack size trigger an update.
this.addSlotToContainer(new Slot(anvilMatrix, 1, 75, 47) {
@Override
public void onSlotChanged() {
super.onSlotChanged();
ContainerAnvilRepair.this.onCraftMatrixChanged(anvilMatrix);
}
});
// Add player inventory slots.
for (int row = 0; row < 3; ++row) {
for (int col = 0; col < 9; ++col) {
this.addSlotToContainer(new Slot(playerInv, col + row * 9 + 9, 8 + col * 18, 98 + row * 18));
}
}
for (int col = 0; col < 9; ++col) {
this.addSlotToContainer(new Slot(playerInv, col, 8 + col * 18, 156));
}
updateRepairResult();
}
@Override
public void onCraftMatrixChanged(IInventory inventory) {
updateRepairResult();
detectAndSendChanges();
}
/**
* Updates the output slot (and repair cost fields) based on the two input slots.
* Instead of forcing the damaged item’s stack to 1 (which deletes extra items),
* we create a copy with stackSize 1 for calculations. Then, when the repair is picked up,
* we subtract one from the original stack.
*/
public void updateRepairResult() {
if (!this.worldObj.isRemote) {
repairMaterialConsumed = 0;
ItemStack input0 = anvilMatrix.getStackInRowAndColumn(0, 0);
ItemStack input1 = anvilMatrix.getStackInRowAndColumn(1, 0);
// If either input is missing, clear output.
if (input0 == null || input1 == null) {
repairCost = 0;
anvilResult.setInventorySlotContents(0, null);
return;
}
// Create a copy of the damaged item for calculation (stack size 1)
ItemStack calcItem = input0.copy();
calcItem.stackSize = 1;
// If the item is damageable and already fully repaired, show a message.
if (calcItem.isItemStackDamageable() && calcItem.getItemDamage() <= 0) {
repairCost = 0;
anvilResult.setInventorySlotContents(0, null);
return;
}
// Look for a matching recipe.
RecipeAnvil matchingRecipe = null;
for (IAnvilRecipe recipe : RecipeController.Instance.getAnvilList()) {
if (recipe.matches(input0, input1)) {
matchingRecipe = (RecipeAnvil) recipe;
break;
}
}
ItemStack output = null;
if (matchingRecipe != null) {
if (!matchingRecipe.availability.isAvailable(player)) {
return;
}
int baseXpCost = matchingRecipe.getXpCost();
// Assume repairPercentage is given as a percent (e.g. 20 for 20% per material)
float repairPercentage = matchingRecipe.getRepairPercentage() / 100.0f;
int maxDamage = calcItem.getMaxDamage();
int currentDamage = calcItem.getItemDamage();
// Fixed repair amount per material (at least 1 point)
int repairPerMaterial = (int) Math.floor(maxDamage * repairPercentage);
if (repairPerMaterial < 1) {
repairPerMaterial = 1;
}
int availableMaterials = input1.stackSize;
int materialsUsed = 0;
while (currentDamage > 0 && materialsUsed < availableMaterials) {
int repairThisIteration = repairPerMaterial;
if (repairThisIteration > currentDamage) {
repairThisIteration = currentDamage;
}
currentDamage -= repairThisIteration;
materialsUsed++;
// Stop if item is fully repaired.
if (currentDamage <= 0) {
break;
}
}
int xpCost = baseXpCost * materialsUsed;
calcItem.setItemDamage(currentDamage);
if (player.experienceTotal >= xpCost) {
output = calcItem;
}
repairMaterialConsumed = materialsUsed;
repairCost = xpCost;
} else {
repairCost = 0;
}
anvilResult.setInventorySlotContents(0, output);
}
}
// --- Sync Methods ---
@Override
public void addCraftingToCrafters(ICrafting listener) {
super.addCraftingToCrafters(listener);
listener.sendProgressBarUpdate(this, 0, this.repairCost);
}
@Override
public void detectAndSendChanges() {
super.detectAndSendChanges();
for (Object crafterObj : this.crafters) {
((ICrafting) crafterObj).sendProgressBarUpdate(this, 0, this.repairCost);
}
}
@Override
public void updateProgressBar(int id, int data) {
if (id == 0) {
this.repairCost = data;
}
}
// --- End Sync Methods ---
@Override
public void onContainerClosed(EntityPlayer player) {
super.onContainerClosed(player);
if (!this.worldObj.isRemote) {
for (int i = 0; i < this.anvilMatrix.getSizeInventory(); i++) {
ItemStack stack = this.anvilMatrix.getStackInSlotOnClosing(i);
if (stack != null) {
player.dropPlayerItemWithRandomChoice(stack, false);
}
}
}
}
@Override
public boolean canInteractWith(EntityPlayer player) {
return player.getDistanceSq((double) this.posX + 0.5D,
(double) this.posY + 0.5D,
(double) this.posZ + 0.5D) <= 64.0D;
}
@Override
public ItemStack transferStackInSlot(EntityPlayer player, int index) {
ItemStack copy = null;
Slot slot = (Slot) this.inventorySlots.get(index);
if (slot != null && slot.getHasStack()) {
ItemStack stack = slot.getStack();
copy = stack.copy();
if (index == 0) { // output slot
if (player.experienceTotal < this.repairCost) {
return null;
}
if (!this.mergeItemStack(stack, 3, this.inventorySlots.size(), true)) {
return null;
}
slot.onSlotChange(stack, copy);
} else if (index >= 1 && index <= 2) { // input slots
if (!this.mergeItemStack(stack, 3, this.inventorySlots.size(), false)) {
return null;
}
} else { // player inventory
if (!this.mergeItemStack(stack, 1, 3, false)) {
return null;
}
}
if (stack.stackSize == 0) {
slot.putStack(null);
} else {
slot.onSlotChanged();
}
if (stack.stackSize == copy.stackSize) {
return null;
}
slot.onPickupFromSlot(player, stack);
}
if (!this.worldObj.isRemote && player instanceof EntityPlayerMP) {
((EntityPlayerMP) player).sendContainerToPlayer(this);
}
return copy;
}
@Override
public boolean func_94530_a(ItemStack stack, Slot slotIn) {
return slotIn.inventory != this.anvilResult && super.func_94530_a(stack, slotIn);
}
// Custom output slot: only allows pickup if the player has enough XP and,
// when picked up, consumes the required number of repair material items and
// subtracts one from the damaged item stack.
public class SlotAnvilOutput extends Slot {
private ContainerAnvilRepair container;
public SlotAnvilOutput(ContainerAnvilRepair container, IInventory inventory, int index, int x, int y) {
super(inventory, index, x, y);
this.container = container;
}
@Override
public boolean isItemValid(ItemStack stack) {
return false;
}
@Override
public boolean canTakeStack(EntityPlayer player) {
return player.experienceTotal >= container.repairCost;
}
@Override
public void onPickupFromSlot(EntityPlayer player, ItemStack stack) {
if (player.experienceTotal < container.repairCost) {
container.updateRepairResult();
return;
}
if (!player.capabilities.isCreativeMode) {
player.addExperience(-container.repairCost);
}
ItemStack repairMat = container.anvilMatrix.getStackInRowAndColumn(1, 0);
if (repairMat != null) {
if (repairMat.stackSize > container.repairMaterialConsumed) {
repairMat.stackSize -= container.repairMaterialConsumed;
} else {
repairMat = null;
}
container.anvilMatrix.setInventorySlotContents(1, repairMat);
}
ItemStack input0 = container.anvilMatrix.getStackInRowAndColumn(0, 0);
if (input0 != null) {
if (input0.stackSize > 1) {
input0.stackSize -= 1;
} else {
input0 = null;
}
container.anvilMatrix.setInventorySlotContents(0, input0);
}
container.repairCost = 0;
container.updateRepairResult();
super.onPickupFromSlot(player, stack);
}
}
}