Exemplo n.º 1
0
 /**
  * We can assume that if null is passed for the container that the container was consumed by the
  * process and we should just remove the input container.
  *
  * @param inv
  * @param inputSlot
  * @param outputSlot
  * @param container
  */
 private static void storeContainer(
     IInventory inv, int inputSlot, int outputSlot, ItemStack container) {
   if (container == null) {
     inv.decrStackSize(inputSlot, 1);
     return;
   }
   ItemStack output = inv.getStackInSlot(outputSlot);
   if (output == null) inv.setInventorySlotContents(outputSlot, container);
   else output.stackSize++;
   inv.decrStackSize(inputSlot, 1);
 }
  @Override
  public ItemStack pullItem(ForgeDirection side, boolean doPull) {
    int xo = xCoord + side.offsetX;
    int yo = yCoord + side.offsetY;
    int zo = zCoord + side.offsetZ;

    TileEntity t = worldObj.getBlockTileEntity(xo, yo, zo);

    if (t instanceof IInventory) {
      if (t instanceof ISpecialInventory) {
        ISpecialInventory isi = (ISpecialInventory) t;
        ItemStack[] items = isi.extractItem(doPull, side.getOpposite(), 1);
        if (items != null && items.length > 0) return items[0];
      } else if (t instanceof ISidedInventory) {
        ISidedInventory isi = (ISidedInventory) t;
        int[] slots = isi.getAccessibleSlotsFromSide(side.getOpposite().ordinal());

        for (int i = 0; i < slots.length; i++) {
          ItemStack pulled = isi.getStackInSlot(slots[i]);
          if (pulled != null
              && isi.canExtractItem(slots[i], pulled, side.getOpposite().ordinal())) {
            ItemStack result = null; // pulled.copy().splitStack(1);
            // pulled.stackSize--;
            // isi.setInventorySlotContents(slots[i], pulled);
            // if(pulled.stackSize <= 0) isi.setInventorySlotContents(slots[i], null);
            if (doPull) {
              result = isi.decrStackSize(slots[i], 1);
              isi.onInventoryChanged();
            } else {
              result = pulled.copy().splitStack(1);
            }
            return result;
          }
        }
      } else {
        IInventory ii = (IInventory) t;

        for (int i = 0; i < ii.getSizeInventory(); i++) {
          ItemStack pulled = ii.getStackInSlot(i);
          if (pulled != null) {
            ItemStack result = null;
            // pulled.stackSize--;
            // ii.setInventorySlotContents(i, pulled);
            // if(pulled.stackSize <= 0)ii.setInventorySlotContents(i, null);
            if (doPull) {
              result = ii.decrStackSize(i, 1);
              ii.onInventoryChanged();
            } else {
              result = pulled.copy().splitStack(1);
            }
            return result;
          }
        }
      }
    }

    return null;
  }
 @Override
 public void onCraft(IInventory inventory) {
   for (int slotId = 0; slotId < inventory.getSizeInventory(); slotId++) {
     ItemStack stack = inventory.getStackInSlot(slotId);
     Item item = stack.getItem();
     if (item == ModItems.equipmentSkinTemplate & !EquipmentNBTHelper.stackHasSkinData(stack)) {
       inventory.decrStackSize(slotId, 1);
     }
   }
 }
  @Override
  public void onCrafting(EntityPlayer player, ItemStack output, IInventory craftMatrix) {
    ItemStack itemstack1 = craftMatrix.getStackInSlot(0);

    // Assumption: Only 1 input, will always be decreased by only 1
    if (itemstack1 != null) {
      craftMatrix.decrStackSize(0, 1);
    }

    updateResult();
  }
 @Override
 public void performEffect(IMasterRitualStone ritualStone) {
   String owner = ritualStone.getOwner();
   World world = ritualStone.getWorld();
   int x = ritualStone.getXCoord();
   int y = ritualStone.getYCoord();
   int z = ritualStone.getZCoord();
   TileEntity tile = world.getTileEntity(x, y + 1, z);
   IInventory tileEntity;
   if (tile instanceof IInventory) {
     tileEntity = (IInventory) tile;
   } else {
     return;
   }
   if (tileEntity.getSizeInventory() <= 0) {
     return;
   }
   int currentEssence = SoulNetworkHandler.getCurrentEssence(owner);
   if (currentEssence < this.getCostPerRefresh()) {
     EntityPlayer entityOwner = SpellHelper.getPlayerForUsername(owner);
     if (entityOwner == null) {
       return;
     }
     SoulNetworkHandler.causeNauseaToPlayer(owner);
   } else {
     for (int i = x - 2; i <= x + 2; i++) {
       for (int k = z - 2; k <= z + 2; k++) {
         for (int inv = 0; inv < tileEntity.getSizeInventory(); inv++) {
           if (world.getBlock(i, y, k).isReplaceable(world, i, y + 1, k)
               && tileEntity.getStackInSlot(inv) != null
               && tileEntity.getStackInSlot(inv).stackSize != 0) {
             if (tileEntity.getStackInSlot(inv).getItem() instanceof ItemBlock
                 && world.getBlock(i, y - 1, k) != null) {
               world.setBlock(
                   i,
                   y,
                   k,
                   Block.getBlockFromItem(tileEntity.getStackInSlot(inv).getItem()),
                   tileEntity.getStackInSlot(inv).getItemDamage(),
                   3);
               tileEntity.decrStackSize(inv, 1);
               tileEntity.markDirty();
               SoulNetworkHandler.syphonFromNetwork(owner, getCostPerRefresh());
             }
           }
         }
       }
     }
   }
 }
  public ItemStack checkExtractGeneric(
      IInventory inventory, boolean doRemove, ForgeDirection from, int[] slots) {
    for (int i : slots) {
      ItemStack slot = inventory.getStackInSlot(i);

      if (slot != null && slot.stackSize > 0 && canExtract(slot)) {
        if (doRemove) {
          return inventory.decrStackSize(i, (int) powerProvider.useEnergy(1, slot.stackSize, true));
        } else {
          return slot;
        }
      }
    }
    return null;
  }
Exemplo n.º 7
0
  @Override
  public List<RanchedItem> ranch(World world, EntityLivingBase entity, IInventory rancher) {
    List<RanchedItem> drops = new LinkedList<RanchedItem>();
    IInventoryManager manager = InventoryManager.create(rancher, ForgeDirection.UP);
    int bucketIndex = manager.findItem(new ItemStack(Item.bucketEmpty));
    if (bucketIndex >= 0) {
      drops.add(new RanchedItem(Item.bucketMilk));
      rancher.decrStackSize(bucketIndex, 1);
    } else {
      FluidStack milk = FluidRegistry.getFluidStack("milk", FluidContainerRegistry.BUCKET_VOLUME);
      drops.add(new RanchedItem(milk));
    }

    return drops;
  }
  private static boolean insertStackFromInventory(
      Hopper par0Hopper, IInventory par1IInventory, int par2, int par3) {
    ItemStack itemstack = par1IInventory.getStackInSlot(par2);

    if (itemstack != null && canExtractItemFromInventory(par1IInventory, itemstack, par2, par3)) {
      ItemStack itemstack1 = itemstack.copy();
      ItemStack itemstack2 = insertStack(par0Hopper, par1IInventory.decrStackSize(par2, 1), -1);

      if (itemstack2 == null || itemstack2.stackSize == 0) {
        par1IInventory.onInventoryChanged();
        return true;
      }

      par1IInventory.setInventorySlotContents(par2, itemstack1);
    }

    return false;
  }
Exemplo n.º 9
0
  @Override
  public ItemStack[] extractItem(boolean doRemove, ForgeDirection from, int maxItemCount) {

    if (!this.isLinked()) return new ItemStack[0];

    ItemStack product = null;
    IInventory inventory = getOrCreateTradeInventory();
    for (int i = TradeStation.SLOT_OUTPUTBUF_1;
        i < TradeStation.SLOT_OUTPUTBUF_1 + TradeStation.SLOT_BUFFER_COUNT;
        i++) {
      ItemStack stackSlot = inventory.getStackInSlot(i);
      if (stackSlot == null) continue;
      if (stackSlot.stackSize <= 0) continue;

      product = inventory.decrStackSize(i, 1);
      break;
    }

    if (product != null) return new ItemStack[] {product};
    else return new ItemStack[0];
  }
  @Override
  public List<ItemStack> ranch(World world, EntityLiving entity, IInventory rancher) {
    List<ItemStack> drops = new LinkedList<ItemStack>();

    IInventoryManager manager = InventoryManager.create(rancher, ForgeDirection.UP);
    int bowlIndex = manager.findItem(new ItemStack(Item.bowlEmpty));
    if (bowlIndex >= 0) {
      drops.add(new ItemStack(Item.bowlSoup));
      rancher.decrStackSize(bowlIndex, 1);
    }

    int bucketIndex = manager.findItem(new ItemStack(Item.bucketEmpty));
    if (bucketIndex >= 0) {
      drops.add(new ItemStack(Item.bucketMilk));
      rancher.setInventorySlotContents(bucketIndex, null);
    } else {
      LiquidStack soup = LiquidDictionary.getLiquid("mushroomsoup", 1000);
      drops.add(new ItemStack(soup.itemID, 1, soup.itemMeta));
    }

    return drops;
  }
Exemplo n.º 11
0
  @Override
  public void onPickupFromSlot(EntityPlayer player, ItemStack itemstack) {
    itemstack.onCrafting(thePlayer.worldObj, thePlayer, slotNumber);
    TerraFirmaCraft.proxy.takenFromCrafting(thePlayer, itemstack, craftMatrix);

    for (int i = 0; i < craftMatrix.getSizeInventory(); i++) {
      ItemStack itemstack1 = craftMatrix.getStackInSlot(i);
      if (itemstack1 != null) {
        craftMatrix.decrStackSize(i, 1);
        if (player.worldObj.isRemote && player.openContainer instanceof ContainerSpecialCrafting)
          ((GuiKnapping) Minecraft.getMinecraft().currentScreen).resetButton(i);

        if (itemstack1.getItem().getContainerItem() != null) {
          ItemStack itemstack2 = new ItemStack(itemstack1.getItem().getContainerItem());
          if (!itemstack1.getItem().doesContainerItemLeaveCraftingGrid(itemstack1)
              || !thePlayer.inventory.addItemStackToInventory(itemstack2)) {
            if (craftMatrix.getStackInSlot(i) == null)
              craftMatrix.setInventorySlotContents(i, itemstack2);
            else thePlayer.entityDropItem(itemstack2, 0);
          }
        }
      }
    }
  }
Exemplo n.º 12
0
  public static ItemStack takeTopItemFromInventory(IInventory inventory, int side) {
    if (!(inventory instanceof ISidedInventory)) {
      for (int i = inventory.getSizeInventory() - 1; i >= 0; i--) {
        if (inventory.getStackInSlot(i) != null) {
          ItemStack toSend = inventory.getStackInSlot(i).copy();
          toSend.stackSize = 1;

          inventory.decrStackSize(i, 1);

          return toSend;
        }
      }
    } else {
      ISidedInventory sidedInventory = (ISidedInventory) inventory;
      int[] slots = sidedInventory.getAccessibleSlotsFromSide(side);

      if (slots != null) {
        for (int get = slots.length - 1; get >= 0; get--) {
          int slotID = slots[get];

          if (sidedInventory.getStackInSlot(slotID) != null) {
            ItemStack toSend = sidedInventory.getStackInSlot(slotID);
            toSend.stackSize = 1;

            if (sidedInventory.canExtractItem(slotID, toSend, side)) {
              sidedInventory.decrStackSize(slotID, 1);

              return toSend;
            }
          }
        }
      }
    }

    return null;
  }
Exemplo n.º 13
0
 @Override
 public ItemStack decrStackSize(int slot, int amount) {
   return inv.decrStackSize(start + slot, amount);
 }
Exemplo n.º 14
0
  @Override
  public void performEffect(IMasterRitualStone ritualStone) {
    String owner = ritualStone.getOwner();

    int currentEssence = SoulNetworkHandler.getCurrentEssence(owner);
    World world = ritualStone.getWorld();
    int x = ritualStone.getXCoord();
    int y = ritualStone.getYCoord();
    int z = ritualStone.getZCoord();

    if (world.getWorldTime() % 20 != 0) {
      return;
    }

    double horizRange = 16;
    double vertRange = 16;

    List<EntityPlayer> playerList =
        SpellHelper.getPlayersInRange(world, x + 0.5, y + 0.5, z + 0.5, horizRange, vertRange);

    if (playerList == null) {
      return;
    }

    if (currentEssence < this.getCostPerRefresh() * playerList.size()) {
      SoulNetworkHandler.causeNauseaToPlayer(owner);
    } else {
      TileEntity tile = world.getTileEntity(x, y + 1, z);
      IInventory inventory = null;
      if (tile instanceof IInventory) {
        inventory = (IInventory) tile;
      } else {
        tile = world.getTileEntity(x, y - 1, z);
        if (tile instanceof IInventory) {
          inventory = (IInventory) tile;
        }
      }

      int count = 0;

      if (inventory != null) {
        for (EntityPlayer player : playerList) {
          FoodStats foodStats = player.getFoodStats();
          float satLevel = foodStats.getSaturationLevel();

          for (int i = 0; i < inventory.getSizeInventory(); i++) {
            ItemStack stack = inventory.getStackInSlot(i);

            if (stack != null && stack.getItem() instanceof ItemFood) {
              ItemFood foodItem = (ItemFood) stack.getItem();

              int regularHeal = foodItem.func_150905_g(stack);
              float saturatedHeal = foodItem.func_150906_h(stack) * regularHeal * 2.0f;

              if (saturatedHeal + satLevel <= 20) {
                NBTTagCompound nbt = new NBTTagCompound();
                foodStats.writeNBT(nbt);
                nbt.setFloat("foodSaturationLevel", saturatedHeal + satLevel);
                foodStats.readNBT(nbt);

                inventory.decrStackSize(i, 1);
                count++;
                break;
              }
            }
          }
        }
      }

      SoulNetworkHandler.syphonFromNetwork(owner, this.getCostPerRefresh() * count);
    }
  }