diff --git a/src/main/java/WayofTime/bloodmagic/api/Constants.java b/src/main/java/WayofTime/bloodmagic/api/Constants.java index c317d050..717cf43f 100644 --- a/src/main/java/WayofTime/bloodmagic/api/Constants.java +++ b/src/main/java/WayofTime/bloodmagic/api/Constants.java @@ -38,6 +38,8 @@ public class Constants public static final String INPUT_AMOUNT = "inputAmount"; public static final String STORED_LP = "storedLP"; public static final String RITUAL_READER = "ritualReaderState"; + public static final String ITEMS = "Items"; + public static final String SLOT = "Slot"; public static final String ALTAR = "bloodAltar"; public static final String ALTAR_TIER = "upgradeLevel"; @@ -111,6 +113,10 @@ public class Constants public static final String ITEM_INVENTORY = "itemInventory"; public static final String BLOCKPOS_CONNECTION = "connections"; + + public static final String CURRENT_SIGIL = "currentSigil"; + public static final String MOST_SIG = "mostSig"; + public static final String LEAST_SIG = "leastSig"; } public static class Mod @@ -129,6 +135,7 @@ public class Constants public static final int ROUTING_NODE_GUI = 2; public static final int MASTER_ROUTING_NODE_GUI = 3; public static final int ALCHEMY_TABLE_GUI = 4; + public static final int SIGIL_HOLDING_GUI = 5; } public static class Compat @@ -217,6 +224,7 @@ public class Constants SIGIL_TRANSPOSITION("ItemSigilTransposition"), RITUAL_READER("ItemRitualReader"), SANGUINE_BOOK("ItemSanguineBook"), + SIGIL_HOLDING("ItemSigilHolding"), ; @Getter diff --git a/src/main/java/WayofTime/bloodmagic/client/gui/GuiHandler.java b/src/main/java/WayofTime/bloodmagic/client/gui/GuiHandler.java index 17da8f67..e2ed6ef1 100644 --- a/src/main/java/WayofTime/bloodmagic/client/gui/GuiHandler.java +++ b/src/main/java/WayofTime/bloodmagic/client/gui/GuiHandler.java @@ -1,5 +1,7 @@ package WayofTime.bloodmagic.client.gui; +import WayofTime.bloodmagic.item.inventory.ContainerHolding; +import WayofTime.bloodmagic.item.inventory.InventoryHolding; import net.minecraft.client.multiplayer.WorldClient; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.util.math.BlockPos; @@ -36,6 +38,8 @@ public class GuiHandler implements IGuiHandler return new ContainerMasterRoutingNode(player.inventory, (TileMasterRoutingNode) world.getTileEntity(pos)); case Constants.Gui.ALCHEMY_TABLE_GUI: return new ContainerAlchemyTable(player.inventory, (TileAlchemyTable) world.getTileEntity(pos)); + case Constants.Gui.SIGIL_HOLDING_GUI: + return new ContainerHolding(player, new InventoryHolding(player.getHeldItemMainhand())); } return null; @@ -60,6 +64,8 @@ public class GuiHandler implements IGuiHandler return new GuiMasterRoutingNode(player.inventory, (TileMasterRoutingNode) world.getTileEntity(pos)); case Constants.Gui.ALCHEMY_TABLE_GUI: return new GuiAlchemyTable(player.inventory, (TileAlchemyTable) world.getTileEntity(pos)); + case Constants.Gui.SIGIL_HOLDING_GUI: + return new GuiHolding(player, new InventoryHolding(player.getHeldItemMainhand())); } } diff --git a/src/main/java/WayofTime/bloodmagic/client/gui/GuiHolding.java b/src/main/java/WayofTime/bloodmagic/client/gui/GuiHolding.java new file mode 100644 index 00000000..ceac8eaf --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/client/gui/GuiHolding.java @@ -0,0 +1,56 @@ +package WayofTime.bloodmagic.client.gui; + +import WayofTime.bloodmagic.api.Constants; +import WayofTime.bloodmagic.item.inventory.ContainerHolding; +import WayofTime.bloodmagic.item.inventory.InventoryHolding; +import WayofTime.bloodmagic.item.sigil.ItemSigilHolding; +import WayofTime.bloodmagic.util.helper.TextHelper; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +@SideOnly(Side.CLIENT) +public class GuiHolding extends GuiContainer +{ + private ResourceLocation texture = new ResourceLocation(Constants.Mod.MODID, "gui/SigilHolding.png"); + private EntityPlayer player; + + public GuiHolding(EntityPlayer player, InventoryHolding inventoryHolding) + { + super(new ContainerHolding(player, inventoryHolding)); + xSize = 176; + ySize = 121; + this.player = player; + } + + @Override + protected void drawGuiContainerForegroundLayer(int param1, int param2) + { + //the parameters for drawString are: string, x, y, color + fontRendererObj.drawString(TextHelper.localize("item.BloodMagic.sigil.holding.name"), 53, 4, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) + { + //draw your Gui here, only thing you need to change is the path + GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.getTextureManager().bindTexture(texture); + int x = (width - xSize) / 2; + int y = (height - ySize) / 2; + this.drawTexturedModalRect(x, y, 0, 0, xSize, ySize); + + if (player != null && player.getHeldItemMainhand() != null && player.getHeldItemMainhand().getItem() instanceof ItemSigilHolding) + { + if (ItemSigilHolding.getCurrentSigil(player.getHeldItemMainhand()) != null) + { + GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.getTextureManager().bindTexture(texture); + this.drawTexturedModalRect(4 + x + 36 * ItemSigilHolding.getCurrentItemOrdinal(player.getHeldItemMainhand()), y + 13, 0, 123, 24, 24); + } + } + } +} diff --git a/src/main/java/WayofTime/bloodmagic/item/inventory/ContainerHolding.java b/src/main/java/WayofTime/bloodmagic/item/inventory/ContainerHolding.java new file mode 100644 index 00000000..e728bfac --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/item/inventory/ContainerHolding.java @@ -0,0 +1,194 @@ +package WayofTime.bloodmagic.item.inventory; + +import WayofTime.bloodmagic.api.iface.ISigil; +import WayofTime.bloodmagic.item.sigil.ItemSigilHolding; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fml.common.FMLCommonHandler; + +public class ContainerHolding extends Container +{ + private final int PLAYER_INVENTORY_ROWS = 3; + private final int PLAYER_INVENTORY_COLUMNS = 9; + + private final EntityPlayer player; + public final InventoryHolding inventoryHolding; + + public ContainerHolding(EntityPlayer player, InventoryHolding inventoryHolding) + { + this.player = player; + this.inventoryHolding = inventoryHolding; + int currentSlotHeldIn = player.inventory.currentItem; + + for (int columnIndex = 0; columnIndex < ItemSigilHolding.inventorySize; ++columnIndex) + { + this.addSlotToContainer(new SlotHolding(this, inventoryHolding, player, columnIndex, 8 + columnIndex * 36, 17)); + } + + for (int rowIndex = 0; rowIndex < PLAYER_INVENTORY_ROWS; ++rowIndex) + { + for (int columnIndex = 0; columnIndex < PLAYER_INVENTORY_COLUMNS; ++columnIndex) + { + this.addSlotToContainer(new Slot(player.inventory, columnIndex + rowIndex * 9 + 9, 8 + columnIndex * 18, 41 + rowIndex * 18)); + } + } + + for (int actionBarIndex = 0; actionBarIndex < PLAYER_INVENTORY_COLUMNS; ++actionBarIndex) + { + if (actionBarIndex == currentSlotHeldIn) + { + this.addSlotToContainer(new SlotDisabled(player.inventory, actionBarIndex, 8 + actionBarIndex * 18, 99)); + } + else + { + this.addSlotToContainer(new Slot(player.inventory, actionBarIndex, 8 + actionBarIndex * 18, 99)); + } + } + } + + @Override + public boolean canInteractWith(EntityPlayer entityPlayer) + { + return true; + } + + @Override + public void onContainerClosed(EntityPlayer entityPlayer) + { + super.onContainerClosed(entityPlayer); + + if (!entityPlayer.worldObj.isRemote) + { + saveInventory(entityPlayer); + } + } + + @Override + public void detectAndSendChanges() + { + super.detectAndSendChanges(); + + if (!player.worldObj.isRemote) + { + saveInventory(player); + } + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer entityPlayer, int slotIndex) + { + ItemStack stack = null; + Slot slotObject = (Slot) inventorySlots.get(slotIndex); + int slots = inventorySlots.size(); + + if (slotObject != null && slotObject.getHasStack()) + { + ItemStack stackInSlot = slotObject.getStack(); + stack = stackInSlot.copy(); + + if (stack.getItem() instanceof ISigil) + { + if (slotIndex < ItemSigilHolding.inventorySize) + { + if (!this.mergeItemStack(stackInSlot, ItemSigilHolding.inventorySize, slots, false)) + { + return null; + } + } + else if (!this.mergeItemStack(stackInSlot, 0, ItemSigilHolding.inventorySize, false)) + { + return null; + } + } + else if (stack.getItem() instanceof ItemSigilHolding) + { + if (slotIndex < ItemSigilHolding.inventorySize + (PLAYER_INVENTORY_ROWS * PLAYER_INVENTORY_COLUMNS)) + { + if (!this.mergeItemStack(stackInSlot, ItemSigilHolding.inventorySize + (PLAYER_INVENTORY_ROWS * PLAYER_INVENTORY_COLUMNS), inventorySlots.size(), false)) + { + return null; + } + } + else if (!this.mergeItemStack(stackInSlot, ItemSigilHolding.inventorySize, ItemSigilHolding.inventorySize + (PLAYER_INVENTORY_ROWS * PLAYER_INVENTORY_COLUMNS), false)) + { + return null; + } + } + + if (stackInSlot.stackSize == 0) + { + slotObject.putStack(null); + } else + { + slotObject.onSlotChanged(); + } + + if (stackInSlot.stackSize == stack.stackSize) + { + return null; + } + + slotObject.onPickupFromSlot(player, stackInSlot); + } + + return stack; + } + + public void saveInventory(EntityPlayer entityPlayer) + { + inventoryHolding.onGuiSaved(entityPlayer); + } + + private class SlotHolding extends Slot + { + private final EntityPlayer player; + private ContainerHolding containerHolding; + + public SlotHolding(ContainerHolding containerHolding, IInventory inventory, EntityPlayer player, int slotIndex, int x, int y) + { + super(inventory, slotIndex, x, y); + this.player = player; + this.containerHolding = containerHolding; + } + + @Override + public void onSlotChanged() + { + super.onSlotChanged(); + + if (FMLCommonHandler.instance().getEffectiveSide().isServer()) + { + containerHolding.saveInventory(player); + } + } + + @Override + public boolean isItemValid(ItemStack itemStack) + { + return itemStack.getItem() instanceof ISigil && !(itemStack.getItem() instanceof ItemSigilHolding); + } + } + + private class SlotDisabled extends Slot + { + public SlotDisabled(IInventory inventory, int slotIndex, int x, int y) + { + super(inventory, slotIndex, x, y); + } + + @Override + public boolean isItemValid(ItemStack itemStack) + { + return false; + } + + @Override + public boolean canTakeStack(EntityPlayer player) + { + return false; + } + } +} diff --git a/src/main/java/WayofTime/bloodmagic/item/inventory/InventoryHolding.java b/src/main/java/WayofTime/bloodmagic/item/inventory/InventoryHolding.java new file mode 100644 index 00000000..9357e5f2 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/item/inventory/InventoryHolding.java @@ -0,0 +1,101 @@ +package WayofTime.bloodmagic.item.inventory; + +import WayofTime.bloodmagic.api.Constants; +import WayofTime.bloodmagic.api.iface.ISigil; +import WayofTime.bloodmagic.api.util.helper.NBTHelper; +import WayofTime.bloodmagic.item.sigil.ItemSigilHolding; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +import java.util.UUID; + +public class InventoryHolding extends ItemInventory +{ + protected ItemStack[] inventory; + + public InventoryHolding(ItemStack itemStack) + { + super(itemStack, ItemSigilHolding.inventorySize, "SigilOfHolding"); + +// readFromNBT(itemStack.getTagCompound()); + } + + public void onGuiSaved(EntityPlayer entityPlayer) + { + masterStack = findParentStack(entityPlayer); + + if (masterStack != null) + { + save(); + } + } + + public ItemStack findParentStack(EntityPlayer entityPlayer) + { + if (hasUUID(masterStack)) + { + UUID parentStackUUID = new UUID(masterStack.getTagCompound().getLong(Constants.NBT.MOST_SIG), masterStack.getTagCompound().getLong(Constants.NBT.LEAST_SIG)); + for (int i = 0; i < entityPlayer.inventory.getSizeInventory(); i++) + { + ItemStack itemStack = entityPlayer.inventory.getStackInSlot(i); + + if (hasUUID(itemStack)) + { + if (itemStack.getTagCompound().getLong(Constants.NBT.MOST_SIG) == parentStackUUID.getMostSignificantBits() && itemStack.getTagCompound().getLong(Constants.NBT.LEAST_SIG) == parentStackUUID.getLeastSignificantBits()) + { + return itemStack; + } + } + } + } + + return null; + } + + public void save() + { + NBTTagCompound nbtTagCompound = masterStack.getTagCompound(); + + if (nbtTagCompound == null) + { + nbtTagCompound = new NBTTagCompound(); + + UUID uuid = UUID.randomUUID(); + nbtTagCompound.setLong(Constants.NBT.MOST_SIG, uuid.getMostSignificantBits()); + nbtTagCompound.setLong(Constants.NBT.LEAST_SIG, uuid.getLeastSignificantBits()); + } + + writeToNBT(nbtTagCompound); + masterStack.setTagCompound(nbtTagCompound); + } + + @Override + public boolean isItemValidForSlot(int slotIndex, ItemStack itemStack) + { + return itemStack.getItem() instanceof ISigil && !(itemStack.getItem() instanceof ItemSigilHolding); + } + + @Override + public int getInventoryStackLimit() + { + return 1; + } + + public static boolean hasUUID(ItemStack itemStack) + { + return itemStack.getTagCompound().hasKey(Constants.NBT.MOST_SIG) && itemStack.getTagCompound().hasKey(Constants.NBT.LEAST_SIG); + } + + public static void setUUID(ItemStack itemStack) + { + itemStack = NBTHelper.checkNBT(itemStack); + + if (!itemStack.getTagCompound().hasKey(Constants.NBT.MOST_SIG) && !itemStack.getTagCompound().hasKey(Constants.NBT.LEAST_SIG)) + { + UUID itemUUID = UUID.randomUUID(); + itemStack.getTagCompound().setLong(Constants.NBT.MOST_SIG, itemUUID.getMostSignificantBits()); + itemStack.getTagCompound().setLong(Constants.NBT.LEAST_SIG, itemUUID.getLeastSignificantBits()); + } + } +} diff --git a/src/main/java/WayofTime/bloodmagic/item/inventory/ItemInventory.java b/src/main/java/WayofTime/bloodmagic/item/inventory/ItemInventory.java index 88fbdeff..dcea591a 100644 --- a/src/main/java/WayofTime/bloodmagic/item/inventory/ItemInventory.java +++ b/src/main/java/WayofTime/bloodmagic/item/inventory/ItemInventory.java @@ -50,7 +50,7 @@ public class ItemInventory implements IInventory public void readFromNBT(NBTTagCompound tagCompound) { - NBTTagList tags = tagCompound.getTagList("Items", 10); + NBTTagList tags = tagCompound.getTagList(Constants.NBT.ITEMS, 10); inventory = new ItemStack[getSizeInventory()]; for (int i = 0; i < tags.tagCount(); i++) @@ -58,7 +58,7 @@ public class ItemInventory implements IInventory if (!isSyncedSlot(i)) { NBTTagCompound data = tags.getCompoundTagAt(i); - byte j = data.getByte("Slot"); + byte j = data.getByte(Constants.NBT.SLOT); if (j >= 0 && j < inventory.length) { @@ -77,13 +77,13 @@ public class ItemInventory implements IInventory if ((inventory[i] != null) && !isSyncedSlot(i)) { NBTTagCompound data = new NBTTagCompound(); - data.setByte("Slot", (byte) i); + data.setByte(Constants.NBT.SLOT, (byte) i); inventory[i].writeToNBT(data); tags.appendTag(data); } } - tagCompound.setTag("Items", tags); + tagCompound.setTag(Constants.NBT.ITEMS, tags); } public void readFromStack(ItemStack masterStack) diff --git a/src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilHolding.java b/src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilHolding.java new file mode 100644 index 00000000..16cd8ab6 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/item/sigil/ItemSigilHolding.java @@ -0,0 +1,305 @@ +package WayofTime.bloodmagic.item.sigil; + +import WayofTime.bloodmagic.BloodMagic; +import WayofTime.bloodmagic.api.Constants; +import WayofTime.bloodmagic.api.util.helper.NBTHelper; +import WayofTime.bloodmagic.item.inventory.InventoryHolding; +import WayofTime.bloodmagic.util.handler.BMKeyBinding; +import WayofTime.bloodmagic.util.handler.IKeybindable; +import WayofTime.bloodmagic.util.helper.TextHelper; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.util.ActionResult; +import net.minecraft.util.EnumActionResult; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.MathHelper; +import net.minecraft.world.World; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import java.util.List; + +public class ItemSigilHolding extends ItemSigilBase implements IKeybindable +{ + public static int inventorySize; + + public ItemSigilHolding() + { + super("holding"); + + inventorySize = 5; + } + + @Override + public void onKeyPressed(ItemStack stack, EntityPlayer player, BMKeyBinding.Key key, boolean showInChat) + { + if (stack == player.getHeldItemMainhand() && stack.getItem() instanceof ItemSigilHolding && key.equals(BMKeyBinding.Key.OPEN_SIGIL_HOLDING)) + { + InventoryHolding.setUUID(stack); + player.openGui(BloodMagic.instance, Constants.Gui.SIGIL_HOLDING_GUI, player.worldObj, (int) player.posX, (int) player.posY, (int) player.posZ); + } + } + + @Override + public String getHighlightTip(ItemStack stack, String displayName) + { + ItemStack[] inv = getInternalInventory(stack); + + if (inv == null) + return displayName; + + int currentSlot = getCurrentItemOrdinal(stack); + ItemStack item = inv[currentSlot]; + + if (item == null) + return displayName; + else + return TextHelper.localizeEffect("item.BloodMagic.sigil.holding.display", displayName, item.getDisplayName()); + } + + @Override + @SideOnly(Side.CLIENT) + public void addInformation(ItemStack stack, EntityPlayer player, List tooltip, boolean advanced) + { + super.addInformation(stack, player, tooltip, advanced); + + ItemStack[] inv = getInternalInventory(stack); + + if (inv == null) + return; + + int currentSlot = getCurrentItemOrdinal(stack); + ItemStack item = inv[currentSlot]; + + for (int i = 0; i < inventorySize; i++) + { + if (inv[i] != null) + if (item != null && inv[i] == item) + tooltip.add(TextHelper.localizeEffect("tooltip.BloodMagic.sigil.holding.sigilInSlot", i + 1, "&l&n" + inv[i].getDisplayName() + "&r")); + else + tooltip.add(TextHelper.localizeEffect("tooltip.BloodMagic.sigil.holding.sigilInSlot", i + 1, inv[i].getDisplayName())); + } + } + + @Override + public EnumActionResult onItemUseFirst(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, EnumHand hand) + { + int currentSlot = getCurrentItemOrdinal(stack); + ItemStack[] inv = getInternalInventory(stack); + + if (inv == null) + return EnumActionResult.PASS; + + ItemStack itemUsing = inv[currentSlot]; + + if (itemUsing == null) + return EnumActionResult.PASS; + + EnumActionResult result = itemUsing.getItem().onItemUseFirst(itemUsing, player, world, pos, side, hitX, hitY, hitZ, hand); + saveInventory(stack, inv); + + return result; + } + + @Override + public EnumActionResult onItemUse(ItemStack stack, EntityPlayer playerIn, World worldIn, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) + { + int currentSlot = getCurrentItemOrdinal(stack); + ItemStack[] inv = getInternalInventory(stack); + + if (inv == null) + return EnumActionResult.PASS; + + ItemStack itemUsing = inv[currentSlot]; + + if (itemUsing == null) + return EnumActionResult.PASS; + + EnumActionResult result = itemUsing.getItem().onItemUse(itemUsing, playerIn, worldIn, pos, hand, facing, hitX, hitY, hitZ); + saveInventory(stack, inv); + + return result; + } + + @Override + public ActionResult onItemRightClick(ItemStack stack, World world, EntityPlayer player, EnumHand hand) + { + int currentSlot = getCurrentItemOrdinal(stack); + ItemStack[] inv = getInternalInventory(stack); + + if (inv == null) + return ActionResult.newResult(EnumActionResult.PASS, stack); + + ItemStack itemUsing = inv[currentSlot]; + + if (itemUsing == null) + return ActionResult.newResult(EnumActionResult.PASS, stack); + + itemUsing.getItem().onItemRightClick(itemUsing, world, player, hand); + + saveInventory(stack, inv); + + return ActionResult.newResult(EnumActionResult.PASS, stack); + } + + public void saveInventory(ItemStack itemStack, ItemStack[] inventory) + { + NBTTagCompound itemTag = itemStack.getTagCompound(); + + if (itemTag == null) + { + itemStack.setTagCompound(new NBTTagCompound()); + } + + NBTTagList itemList = new NBTTagList(); + + for (int i = 0; i < inventorySize; i++) + { + if (inventory[i] != null) + { + NBTTagCompound tag = new NBTTagCompound(); + tag.setByte(Constants.NBT.SLOT, (byte) i); + inventory[i].writeToNBT(tag); + itemList.appendTag(tag); + } + } + + itemTag.setTag(Constants.NBT.ITEMS, itemList); + } + + @Override + public void onUpdate(ItemStack itemStack, World world, Entity entity, int itemSlot, boolean isSelected) + { + if (itemStack.getTagCompound() != null) + { + this.tickInternalInventory(itemStack, world, entity, itemSlot, isSelected); + } + } + + public void tickInternalInventory(ItemStack itemStack, World world, Entity entity, int itemSlot, boolean isSelected) + { + ItemStack[] inv = getInternalInventory(itemStack); + + if (inv == null) + { + return; + } + + for (int i = 0; i < inventorySize; i++) + { + if (inv[i] == null) + { + continue; + } + + inv[i].getItem().onUpdate(inv[i], world, entity, itemSlot, isSelected); + } + } + + public static int next(int mode) + { + int index = mode + 1; + + if (index >= inventorySize) + { + index = 0; + } + + return index; + } + + public static int prev(int mode) + { + int index = mode - 1; + + if (index < 0) + { + index = inventorySize; + } + + return index; + } + + private static void initModeTag(ItemStack itemStack) + { + if (itemStack.getTagCompound() == null) + { + itemStack = NBTHelper.checkNBT(itemStack); + itemStack.getTagCompound().setInteger(Constants.NBT.CURRENT_SIGIL, inventorySize); + } + } + + public static ItemStack getCurrentSigil(ItemStack itemStack) + { + if (itemStack.getItem() instanceof ItemSigilHolding) + { + ItemStack[] itemStacks = getInternalInventory(itemStack); + if (itemStacks != null) + { + return itemStacks[getCurrentItemOrdinal(itemStack)]; + } + } + + return null; + } + + public static int getCurrentItemOrdinal(ItemStack itemStack) + { + if (itemStack.getItem() instanceof ItemSigilHolding) + { + initModeTag(itemStack); + int currentSigil = itemStack.getTagCompound().getInteger(Constants.NBT.CURRENT_SIGIL); + currentSigil = MathHelper.clamp_int(currentSigil, 0, inventorySize - 1); + return currentSigil; + } + + return 0; + } + + public static ItemStack[] getInternalInventory(ItemStack itemStack) + { + initModeTag(itemStack); + NBTTagCompound tagCompound = itemStack.getTagCompound(); + + if (tagCompound == null) + { + return null; + } + + NBTTagList tagList = tagCompound.getTagList(Constants.NBT.ITEMS, 10); + + if (tagList == null) + { + return null; + } + + ItemStack[] inv = new ItemStack[inventorySize]; + + for (int i = 0; i < tagList.tagCount(); i++) + { + NBTTagCompound data = tagList.getCompoundTagAt(i); + byte j = data.getByte(Constants.NBT.SLOT); + + if (j >= 0 && j < inv.length) + { + inv[j] = ItemStack.loadItemStackFromNBT(data); + } + } + + return inv; + } + + public static void cycleSigil(ItemStack itemStack, int mode) + { + if (itemStack.getItem() instanceof ItemSigilHolding) + { + initModeTag(itemStack); + itemStack.getTagCompound().setInteger(Constants.NBT.CURRENT_SIGIL, mode); + } + } +} diff --git a/src/main/java/WayofTime/bloodmagic/network/BloodMagicPacketHandler.java b/src/main/java/WayofTime/bloodmagic/network/BloodMagicPacketHandler.java index ac39e7f1..286b34a9 100644 --- a/src/main/java/WayofTime/bloodmagic/network/BloodMagicPacketHandler.java +++ b/src/main/java/WayofTime/bloodmagic/network/BloodMagicPacketHandler.java @@ -19,6 +19,8 @@ public class BloodMagicPacketHandler INSTANCE.registerMessage(ItemRouterButtonPacketProcessor.class, ItemRouterButtonPacketProcessor.class, 1, Side.SERVER); INSTANCE.registerMessage(PlayerVelocityPacketProcessor.class, PlayerVelocityPacketProcessor.class, 2, Side.CLIENT); INSTANCE.registerMessage(PlayerFallDistancePacketProcessor.class, PlayerFallDistancePacketProcessor.class, 3, Side.SERVER); + INSTANCE.registerMessage(SigilHoldingPacketProcessor.class, SigilHoldingPacketProcessor.class, 4, Side.SERVER); + INSTANCE.registerMessage(KeyProcessor.class, KeyProcessor.class, 5, Side.SERVER); } public static void sendToAllAround(IMessage message, TileEntity te, int range) diff --git a/src/main/java/WayofTime/bloodmagic/network/KeyProcessor.java b/src/main/java/WayofTime/bloodmagic/network/KeyProcessor.java new file mode 100644 index 00000000..234f83b8 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/network/KeyProcessor.java @@ -0,0 +1,61 @@ +package WayofTime.bloodmagic.network; + +import WayofTime.bloodmagic.util.handler.BMKeyBinding; +import WayofTime.bloodmagic.util.handler.IKeybindable; +import io.netty.buffer.ByteBuf; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fml.common.network.simpleimpl.IMessage; +import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler; +import net.minecraftforge.fml.common.network.simpleimpl.MessageContext; + +public class KeyProcessor implements IMessage, IMessageHandler +{ + public int keyId; + public boolean showInChat; + + public KeyProcessor() + { + } + + public KeyProcessor(BMKeyBinding.Key key, boolean showInChat) + { + this.keyId = key.ordinal(); + this.showInChat = showInChat; + } + + @Override + public void fromBytes(ByteBuf buf) + { + this.keyId = buf.readInt(); + this.showInChat = buf.readBoolean(); + } + + @Override + public void toBytes(ByteBuf buf) + { + buf.writeInt(this.keyId); + buf.writeBoolean(this.showInChat); + } + + @Override + public IMessage onMessage(KeyProcessor msg, MessageContext ctx) + { + EntityPlayer entityPlayer = ctx.getServerHandler().playerEntity; + + if (entityPlayer != null) + { + ItemStack heldStack = entityPlayer.getHeldItemMainhand(); + if (heldStack.getItem() instanceof IKeybindable) + { + if (msg.keyId < 0 || msg.keyId >= BMKeyBinding.Key.values().length) + { + return null; + } + BMKeyBinding.Key key = BMKeyBinding.Key.values()[msg.keyId]; + ((IKeybindable) heldStack.getItem()).onKeyPressed(heldStack, entityPlayer, key, msg.showInChat); + } + } + return null; + } +} diff --git a/src/main/java/WayofTime/bloodmagic/network/SigilHoldingPacketProcessor.java b/src/main/java/WayofTime/bloodmagic/network/SigilHoldingPacketProcessor.java new file mode 100644 index 00000000..74e93047 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/network/SigilHoldingPacketProcessor.java @@ -0,0 +1,56 @@ +package WayofTime.bloodmagic.network; + +import WayofTime.bloodmagic.item.sigil.ItemSigilHolding; +import io.netty.buffer.ByteBuf; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fml.common.network.simpleimpl.IMessage; +import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler; +import net.minecraftforge.fml.common.network.simpleimpl.MessageContext; + +public class SigilHoldingPacketProcessor implements IMessage, IMessageHandler +{ + private int slot; + private int mode; + + public SigilHoldingPacketProcessor() + { + } + + public SigilHoldingPacketProcessor(int slot, int mode) + { + this.slot = slot; + this.mode = mode; + } + + @Override + public void toBytes(ByteBuf buffer) + { + buffer.writeInt(slot); + buffer.writeInt(mode); + } + + @Override + public void fromBytes(ByteBuf buffer) + { + slot = buffer.readInt(); + mode = buffer.readInt(); + } + + @Override + public IMessage onMessage(SigilHoldingPacketProcessor message, MessageContext ctx) + { + ItemStack itemStack = null; + + if (message.slot > -1 && message.slot < 9) + { + itemStack = ctx.getServerHandler().playerEntity.inventory.getStackInSlot(message.slot); + } + + if (itemStack != null) + { + ItemSigilHolding.cycleSigil(itemStack, message.mode); + } + + return null; + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/proxy/ClientProxy.java b/src/main/java/WayofTime/bloodmagic/proxy/ClientProxy.java index beed18c8..4a09ed34 100644 --- a/src/main/java/WayofTime/bloodmagic/proxy/ClientProxy.java +++ b/src/main/java/WayofTime/bloodmagic/proxy/ClientProxy.java @@ -40,7 +40,6 @@ import net.minecraftforge.fml.common.ObfuscationReflectionHelper; import org.apache.commons.lang3.tuple.Pair; import java.awt.*; -import java.lang.reflect.Field; public class ClientProxy extends CommonProxy { diff --git a/src/main/java/WayofTime/bloodmagic/registry/ModItems.java b/src/main/java/WayofTime/bloodmagic/registry/ModItems.java index 9c89d70b..99d8af40 100644 --- a/src/main/java/WayofTime/bloodmagic/registry/ModItems.java +++ b/src/main/java/WayofTime/bloodmagic/registry/ModItems.java @@ -50,6 +50,7 @@ import WayofTime.bloodmagic.item.sigil.ItemSigilEnderSeverance; import WayofTime.bloodmagic.item.sigil.ItemSigilFastMiner; import WayofTime.bloodmagic.item.sigil.ItemSigilGreenGrove; import WayofTime.bloodmagic.item.sigil.ItemSigilHaste; +import WayofTime.bloodmagic.item.sigil.ItemSigilHolding; import WayofTime.bloodmagic.item.sigil.ItemSigilLava; import WayofTime.bloodmagic.item.sigil.ItemSigilMagnetism; import WayofTime.bloodmagic.item.sigil.ItemSigilPhantomBridge; @@ -113,6 +114,7 @@ public class ModItems public static Item sigilWhirlwind; public static Item sigilPhantomBridge; public static Item sigilCompression; + public static Item sigilHolding; public static Item sigilTeleposition; public static Item sigilTransposition; @@ -210,6 +212,7 @@ public class ModItems sigilWhirlwind = registerItem(new ItemSigilWhirlwind(), Constants.BloodMagicItem.SIGIL_WHIRLWIND.getRegName()); sigilCompression = registerItem(new ItemSigilCompression(), Constants.BloodMagicItem.SIGIL_COMPRESSION.getRegName()); sigilEnderSeverance = registerItem(new ItemSigilEnderSeverance(), Constants.BloodMagicItem.SIGIL_ENDER_SEVERANCE.getRegName()); + sigilHolding = registerItem(new ItemSigilHolding(), Constants.BloodMagicItem.SIGIL_HOLDING.getRegName()); sigilTeleposition = registerItem(new ItemSigilTeleposition(), Constants.BloodMagicItem.SIGIL_TELEPOSITION.getRegName()); sigilTransposition = registerItem(new ItemSigilTransposition(), Constants.BloodMagicItem.SIGIL_TRANSPOSITION.getRegName()); diff --git a/src/main/java/WayofTime/bloodmagic/util/handler/BMKeyBinding.java b/src/main/java/WayofTime/bloodmagic/util/handler/BMKeyBinding.java new file mode 100644 index 00000000..1d479749 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/util/handler/BMKeyBinding.java @@ -0,0 +1,36 @@ +package WayofTime.bloodmagic.util.handler; + +import WayofTime.bloodmagic.api.Constants; +import WayofTime.bloodmagic.network.BloodMagicPacketHandler; +import WayofTime.bloodmagic.network.KeyProcessor; +import WayofTime.bloodmagic.util.handler.event.ClientHandler; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fml.client.registry.ClientRegistry; + +public class BMKeyBinding extends KeyBinding +{ + private Key keyType; + + public BMKeyBinding(String name, int keyId, Key keyType) + { + super(Constants.Mod.MODID + ".keybind." + name, keyId, Constants.Mod.NAME); + this.keyType = keyType; + ClientRegistry.registerKeyBinding(this); + ClientHandler.keyBindings.add(this); + } + + public void handleKeyPress() + { + ItemStack itemStack = ClientHandler.minecraft.thePlayer.getHeldItemMainhand(); + if (itemStack.getItem() instanceof IKeybindable) + { + BloodMagicPacketHandler.INSTANCE.sendToServer(new KeyProcessor(this.keyType, false)); + } + } + + public enum Key + { + OPEN_SIGIL_HOLDING + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/util/handler/IKeybindable.java b/src/main/java/WayofTime/bloodmagic/util/handler/IKeybindable.java new file mode 100644 index 00000000..ed3421c7 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/util/handler/IKeybindable.java @@ -0,0 +1,9 @@ +package WayofTime.bloodmagic.util.handler; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; + +public interface IKeybindable +{ + void onKeyPressed(ItemStack stack, EntityPlayer player, BMKeyBinding.Key key, boolean showInChat); +} diff --git a/src/main/java/WayofTime/bloodmagic/util/handler/event/ClientHandler.java b/src/main/java/WayofTime/bloodmagic/util/handler/event/ClientHandler.java index b5567234..1345faa3 100644 --- a/src/main/java/WayofTime/bloodmagic/util/handler/event/ClientHandler.java +++ b/src/main/java/WayofTime/bloodmagic/util/handler/event/ClientHandler.java @@ -10,28 +10,38 @@ import WayofTime.bloodmagic.api.ritual.RitualComponent; import WayofTime.bloodmagic.client.render.RenderFakeBlocks; import WayofTime.bloodmagic.item.ItemRitualDiviner; import WayofTime.bloodmagic.item.ItemRitualReader; +import WayofTime.bloodmagic.item.sigil.ItemSigilHolding; +import WayofTime.bloodmagic.network.BloodMagicPacketHandler; +import WayofTime.bloodmagic.network.SigilHoldingPacketProcessor; import WayofTime.bloodmagic.tile.TileMasterRitualStone; import WayofTime.bloodmagic.util.GhostItemHelper; +import WayofTime.bloodmagic.util.handler.BMKeyBinding; import WayofTime.bloodmagic.util.helper.TextHelper; import net.minecraft.client.Minecraft; import net.minecraft.client.entity.EntityPlayerSP; import net.minecraft.client.renderer.GlStateManager; import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.*; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.RayTraceResult; import net.minecraft.world.World; +import net.minecraftforge.client.event.MouseEvent; import net.minecraftforge.client.event.RenderWorldLastEvent; import net.minecraftforge.client.event.TextureStitchEvent; import net.minecraftforge.event.entity.player.ItemTooltipEvent; import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.InputEvent; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import org.lwjgl.input.Keyboard; import org.lwjgl.opengl.GL11; +import java.util.ArrayList; import java.util.List; @Handler @@ -46,7 +56,11 @@ public class ClientHandler public TextureAtlasSprite ritualStoneDawn; public TextureAtlasSprite ritualStoneDusk; - private static Minecraft minecraft = Minecraft.getMinecraft(); + public static Minecraft minecraft = Minecraft.getMinecraft(); + + public static final List keyBindings = new ArrayList(); + + public static final BMKeyBinding keyOpenSigilHolding = new BMKeyBinding("openSigilHolding", Keyboard.KEY_H, BMKeyBinding.Key.OPEN_SIGIL_HOLDING); @SubscribeEvent public void onTooltipEvent(ItemTooltipEvent event) @@ -102,6 +116,36 @@ public class ClientHandler renderRitualInformation(player, event.getPartialTicks()); } + @SubscribeEvent + public void onMouseEvent(MouseEvent event) + { + EntityPlayerSP player = Minecraft.getMinecraft().thePlayer; + + if (event.getDwheel() != 0 && player != null && player.isSneaking()) + { + ItemStack stack = player.getHeldItemMainhand(); + + if (stack != null) + { + Item item = stack.getItem(); + + if (item instanceof ItemSigilHolding) + { + cycleSigil(stack, player, event.getDwheel()); + event.setCanceled(true); + } + } + } + } + + private void cycleSigil(ItemStack stack, EntityPlayer player, int dWheel) + { + int mode = ItemSigilHolding.getCurrentItemOrdinal(stack); + mode = dWheel < 0 ? ItemSigilHolding.next(mode) : ItemSigilHolding.prev(mode); + ItemSigilHolding.cycleSigil(stack, mode); + BloodMagicPacketHandler.INSTANCE.sendToServer(new SigilHoldingPacketProcessor(player.inventory.currentItem, mode)); + } + private static TextureAtlasSprite forName(TextureMap textureMap, String name, String dir) { return textureMap.registerSprite(new ResourceLocation(Constants.Mod.DOMAIN + dir + "/" + name)); @@ -187,4 +231,17 @@ public class ClientHandler GlStateManager.popMatrix(); } + + @SubscribeEvent + public void onKey(InputEvent event) + { + if (!minecraft.inGameHasFocus) + return; + + for (BMKeyBinding key : keyBindings) + { + if (key.isPressed()) + key.handleKeyPress(); + } + } } diff --git a/src/main/resources/assets/bloodmagic/blockstates/item/ItemSigilHolding.json b/src/main/resources/assets/bloodmagic/blockstates/item/ItemSigilHolding.json new file mode 100644 index 00000000..77427007 --- /dev/null +++ b/src/main/resources/assets/bloodmagic/blockstates/item/ItemSigilHolding.json @@ -0,0 +1,16 @@ +{ + "forge_marker": 1, + "defaults": { + "model": "builtin/generated", + "transform": "forge:default-item" + }, + "variants": { + "type": { + "normal": { + "textures": { + "layer0": "bloodmagic:items/SigilOfHolding" + } + } + } + } +} \ No newline at end of file diff --git a/src/main/resources/assets/bloodmagic/gui/SigilHolding.png b/src/main/resources/assets/bloodmagic/gui/SigilHolding.png new file mode 100644 index 00000000..d3468096 Binary files /dev/null and b/src/main/resources/assets/bloodmagic/gui/SigilHolding.png differ diff --git a/src/main/resources/assets/bloodmagic/gui/SigilOfHolding.png b/src/main/resources/assets/bloodmagic/gui/SigilOfHolding.png deleted file mode 100644 index 47887332..00000000 Binary files a/src/main/resources/assets/bloodmagic/gui/SigilOfHolding.png and /dev/null differ diff --git a/src/main/resources/assets/bloodmagic/lang/en_US.lang b/src/main/resources/assets/bloodmagic/lang/en_US.lang index 56238699..4b0cd100 100644 --- a/src/main/resources/assets/bloodmagic/lang/en_US.lang +++ b/src/main/resources/assets/bloodmagic/lang/en_US.lang @@ -122,6 +122,8 @@ item.BloodMagic.sigil.seer.name=Seer's Sigil item.BloodMagic.sigil.phantomBridge.name=Sigil of the Phantom Bridge item.BloodMagic.sigil.whirlwind.name=Sigil of the Whirlwind item.BloodMagic.sigil.enderSeverance.name=Sigil of Ender Severance +item.BloodMagic.sigil.holding.name=Sigil of Holding +item.BloodMagic.sigil.holding.display=%s: &l&n%s item.BloodMagic.sigil.teleposition.name=Teleposition Sigil item.BloodMagic.sigil.transposition.name=Transposition Sigil @@ -283,6 +285,8 @@ tooltip.BloodMagic.sigil.whirlwind.desc=&oBest not to wear a skirt tooltip.BloodMagic.sigil.enderSeverance.desc=&oPutting Endermen in Dire situations! tooltip.BloodMagic.sigil.teleposition.desc=I am very close to being moved by this. tooltip.BloodMagic.sigil.transposition.desc=Feel the power of the Force, my young apprentice. +tooltip.BloodMagic.sigil.holding.desc=Sigil-ception +tooltip.BloodMagic.sigil.holding.sigilInSlot=Slot %d: %s tooltip.BloodMagic.bound.sword.desc=&oCulling the weak tooltip.BloodMagic.bound.pickaxe.desc=&oDestroying stone without mercy @@ -588,6 +592,9 @@ commands.soulnetwork.notACommand=That is not a valid command commands.soulnetwork.fillMax.success=Successfully filled %s's Soul Network to their orb max! commands.soulnetwork.create.success=Successfully created %s's Soul Network (Orb tier: %d) +# Keybinds +BloodMagic.keybind.openSigilHolding=Open Sigil of Holding + # JustEnoughItems jei.BloodMagic.recipe.altar=Blood Altar jei.BloodMagic.recipe.binding=Alchemy Array (Binding)