@Override
  public void writeToNBT(NBTTagCompound nbttagcompound) {
    super.writeToNBT(nbttagcompound);

    Utils.writeStacksToNBT(nbttagcompound, "Items", items);

    if (box.isInitialized()) {
      NBTTagCompound boxStore = new NBTTagCompound();
      box.writeToNBT(boxStore);
      nbttagcompound.setTag("box", boxStore);
    }

    if (path != null) {
      NBTTagList list = new NBTTagList();

      for (BlockIndex i : path) {
        NBTTagCompound c = new NBTTagCompound();
        i.writeTo(c);
        list.appendTag(c);
      }

      nbttagcompound.setTag("path", list);
    }

    nbttagcompound.setBoolean("done", done);
  }
 private void craftItem() {
   ItemStack recipeOutput = getRecipeOutput();
   craftSlot.onPickupFromSlot(internalPlayer, recipeOutput);
   ItemStack[] tempStorage = internalInventoryCrafting.tempStacks;
   for (int i = 0; i < tempStorage.length; i++) {
     if (tempStorage[i] != null && tempStorage[i].stackSize <= 0) {
       tempStorage[i] = null;
     }
     inv.getItemStacks()[i] = tempStorage[i];
   }
   subtractEnergy(getRequiredEnergy());
   List<ItemStack> outputs = Lists.newArrayList(recipeOutput.copy());
   for (int i = 0; i < internalPlayer.inventory.mainInventory.length; i++) {
     if (internalPlayer.inventory.mainInventory[i] != null) {
       outputs.add(internalPlayer.inventory.mainInventory[i]);
       internalPlayer.inventory.mainInventory[i] = null;
     }
   }
   for (ItemStack output : outputs) {
     output.stackSize -=
         Transactor.getTransactorFor(invOutput).add(output, ForgeDirection.UP, true).stackSize;
     if (output.stackSize > 0) {
       output.stackSize -=
           Utils.addToRandomInventoryAround(worldObj, xCoord, yCoord, zCoord, output);
     }
     if (output.stackSize > 0) {
       InvUtils.dropItems(worldObj, output, xCoord, yCoord + 1, zCoord);
     }
   }
 }
  @Override
  public void readFromNBT(NBTTagCompound nbttagcompound) {
    super.readFromNBT(nbttagcompound);

    Utils.readStacksFromNBT(nbttagcompound, "items", items);

    energyStored = nbttagcompound.getFloat("energyStored");

    NBTTagList list = nbttagcompound.getTagList("planned");

    for (int i = 0; i < list.tagCount(); ++i) {
      NBTTagCompound cpt = (NBTTagCompound) list.tagAt(i);

      ItemStack stack = ItemStack.loadItemStackFromNBT(cpt);

      for (AssemblyRecipe r : AssemblyRecipe.assemblyRecipes) {
        if (r.output.itemID == stack.itemID && r.output.getItemDamage() == stack.getItemDamage()) {
          plannedOutput.add(r);
        }
      }
    }

    if (nbttagcompound.hasKey("recipe")) {
      ItemStack stack = ItemStack.loadItemStackFromNBT(nbttagcompound.getCompoundTag("recipe"));

      for (AssemblyRecipe r : plannedOutput) {
        if (r.output.itemID == stack.itemID && r.output.getItemDamage() == stack.getItemDamage()) {
          setCurrentRecipe(r);
          break;
        }
      }
    }
  }
Beispiel #4
0
  @Override
  public void onBlockPlacedBy(
      World world, int i, int j, int k, EntityLiving entityliving, ItemStack stack) {
    ForgeDirection orientation =
        Utils.get2dOrientation(
            new Position(entityliving.posX, entityliving.posY, entityliving.posZ),
            new Position(i, j, k));

    world.setBlockMetadataWithNotify(i, j, k, orientation.getOpposite().ordinal(), 1);
  }
 private void updateTiles() {
   for (int i = 0; i < 6; ++i) {
     TileEntity tile = container.getTile(ForgeDirection.VALID_DIRECTIONS[i]);
     if (Utils.checkPipesConnections(tile, container)) {
       tiles[i] = tile;
     } else {
       tiles[i] = null;
     }
   }
 }
Beispiel #6
0
  public int isPoweringTo(int l) {
    if (!broadcastRedstone) return 0;

    ForgeDirection o = ForgeDirection.values()[l].getOpposite();
    TileEntity tile = container.getTile(o);

    if (tile instanceof TileGenericPipe && Utils.checkPipesConnections(this.container, tile))
      return 0;

    return 15;
  }
 public ItemStack checkExtract(IInventory inventory, boolean doRemove, ForgeDirection from) {
   IInventory inv = Utils.getInventory(inventory);
   int first = 0;
   int last = inv.getSizeInventory() - 1;
   if (inventory instanceof ISidedInventory) {
     ISidedInventory sidedInv = (ISidedInventory) inventory;
     int[] accessibleSlots = sidedInv.getAccessibleSlotsFromSide(from.ordinal());
     ItemStack result = checkExtractGeneric(inv, doRemove, from, accessibleSlots);
     return result;
   }
   ItemStack result = checkExtractGeneric(inv, doRemove, from, first, last);
   return result;
 }
Beispiel #8
0
  public void onBlockRemoval() {
    if (wireSet[IPipe.WireColor.Red.ordinal()]) {
      Utils.dropItems(
          worldObj, new ItemStack(BuildCraftTransport.redPipeWire), xCoord, yCoord, zCoord);
    }

    if (wireSet[IPipe.WireColor.Blue.ordinal()]) {
      Utils.dropItems(
          worldObj, new ItemStack(BuildCraftTransport.bluePipeWire), xCoord, yCoord, zCoord);
    }

    if (wireSet[IPipe.WireColor.Green.ordinal()]) {
      Utils.dropItems(
          worldObj, new ItemStack(BuildCraftTransport.greenPipeWire), xCoord, yCoord, zCoord);
    }

    if (wireSet[IPipe.WireColor.Yellow.ordinal()]) {
      Utils.dropItems(
          worldObj, new ItemStack(BuildCraftTransport.yellowPipeWire), xCoord, yCoord, zCoord);
    }

    if (hasGate()) {
      gate.dropGate(worldObj, xCoord, yCoord, zCoord);
    }

    for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS) {
      if (container.hasFacade(direction)) {
        container.dropFacade(direction);
      }
      if (container.hasPlug(direction)) {
        container.removeAndDropPlug(direction);
      }
    }

    if (broadcastRedstone) {
      updateNeighbors(false); // self will update due to block id changing
    }
  }
Beispiel #9
0
  @Override
  public boolean isWireConnectedTo(TileEntity tile, WireColor color) {
    if (!(tile instanceof TileGenericPipe)) return false;

    TileGenericPipe tilePipe = (TileGenericPipe) tile;

    if (!BlockGenericPipe.isFullyDefined(tilePipe.pipe)) return false;

    if (!tilePipe.pipe.wireSet[color.ordinal()]) return false;

    return (tilePipe.pipe.transport instanceof PipeTransportStructure
        || transport instanceof PipeTransportStructure
        || Utils.checkPipesConnections(container, tile));
  }
Beispiel #10
0
  private void switchSignals() {
    if (signals != null) {
      for (EntityBlock b : signals) {
        if (b != null) {
          CoreProxy.proxy.removeEntity(b);
        }
      }
      signals = null;
    }
    if (showSignals) {
      signals = new EntityBlock[6];
      if (!origin.isSet() || !origin.vect[0].isSet()) {
        signals[0] =
            Utils.createLaser(
                worldObj,
                new Position(xCoord, yCoord, zCoord),
                new Position(xCoord + maxSize - 1, yCoord, zCoord),
                LaserKind.Blue);
        signals[1] =
            Utils.createLaser(
                worldObj,
                new Position(xCoord - maxSize + 1, yCoord, zCoord),
                new Position(xCoord, yCoord, zCoord),
                LaserKind.Blue);
      }

      if (!origin.isSet() || !origin.vect[1].isSet()) {
        signals[2] =
            Utils.createLaser(
                worldObj,
                new Position(xCoord, yCoord, zCoord),
                new Position(xCoord, yCoord + maxSize - 1, zCoord),
                LaserKind.Blue);
        signals[3] =
            Utils.createLaser(
                worldObj,
                new Position(xCoord, yCoord - maxSize + 1, zCoord),
                new Position(xCoord, yCoord, zCoord),
                LaserKind.Blue);
      }

      if (!origin.isSet() || !origin.vect[2].isSet()) {
        signals[4] =
            Utils.createLaser(
                worldObj,
                new Position(xCoord, yCoord, zCoord),
                new Position(xCoord, yCoord, zCoord + maxSize - 1),
                LaserKind.Blue);
        signals[5] =
            Utils.createLaser(
                worldObj,
                new Position(xCoord, yCoord, zCoord - maxSize + 1),
                new Position(xCoord, yCoord, zCoord),
                LaserKind.Blue);
      }
    }
  }
Beispiel #11
0
  private void createLasers() {
    if (lasers != null) {
      for (EntityBlock entity : lasers) {
        if (entity != null) {
          CoreProxy.proxy.removeEntity(entity);
        }
      }
    }

    lasers = new EntityBlock[12];
    Origin o = origin;

    if (!origin.vect[0].isSet()) {
      o.xMin = origin.vectO.x;
      o.xMax = origin.vectO.x;
    } else if (origin.vect[0].x < xCoord) {
      o.xMin = origin.vect[0].x;
      o.xMax = xCoord;
    } else {
      o.xMin = xCoord;
      o.xMax = origin.vect[0].x;
    }

    if (!origin.vect[1].isSet()) {
      o.yMin = origin.vectO.y;
      o.yMax = origin.vectO.y;
    } else if (origin.vect[1].y < yCoord) {
      o.yMin = origin.vect[1].y;
      o.yMax = yCoord;
    } else {
      o.yMin = yCoord;
      o.yMax = origin.vect[1].y;
    }

    if (!origin.vect[2].isSet()) {
      o.zMin = origin.vectO.z;
      o.zMax = origin.vectO.z;
    } else if (origin.vect[2].z < zCoord) {
      o.zMin = origin.vect[2].z;
      o.zMax = zCoord;
    } else {
      o.zMin = zCoord;
      o.zMax = origin.vect[2].z;
    }

    lasers =
        Utils.createLaserBox(
            worldObj, o.xMin, o.yMin, o.zMin, o.xMax, o.yMax, o.zMax, LaserKind.Red);
  }
  @Override
  public boolean outputOpen(ForgeDirection to) {
    if (!super.outputOpen(to)) return false;

    FluidTankInfo[] tanks = transport.getTankInfo(ForgeDirection.UNKNOWN);

    // center tank
    if (tanks == null || tanks[0] == null || tanks[0].fluid == null || tanks[0].fluid.amount == 0)
      return true;

    Fluid fluidInTank = tanks[0].fluid.getFluid();

    boolean[] validDirections = new boolean[ForgeDirection.values().length];
    boolean[] filteredDirections = new boolean[ForgeDirection.values().length];
    boolean filterForLiquid = false;

    // check every direction
    // perhaps we should/can cache this?
    for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
      validDirections[dir.ordinal()] = false;
      filteredDirections[dir.ordinal()] = false;

      if (Utils.checkPipesConnections(container.getTile(dir), container)) {
        for (int slot = 0; slot < 9; ++slot) {
          Fluid fluid = fluids[dir.ordinal() * 9 + slot];

          if (fluid != null) {
            filteredDirections[dir.ordinal()] = true;

            if (fluidInTank.getID() == fluid.getID()) {
              validDirections[dir.ordinal()] = true;
              filterForLiquid = true;
            }
          }
        }
      }
    }

    // the direction is filtered and liquids match
    if (filteredDirections[to.ordinal()] && validDirections[to.ordinal()]) return true;

    // we havent found a filter for this liquid and the direction is free
    if (!filterForLiquid && !filteredDirections[to.ordinal()]) return true;

    // we have a filter for the liquid, but not a valid Direction :/
    return false;
  }
Beispiel #13
0
 public void dropFacade(ForgeDirection direction) {
   if (this.worldObj.isRemote) return;
   if (!hasFacade(direction)) return;
   Utils.dropItems(
       worldObj,
       new ItemStack(
           BuildCraftTransport.facadeItem,
           1,
           ItemFacade.encode(
               this.facadeBlocks[direction.ordinal()], this.facadeMeta[direction.ordinal()])),
       this.xCoord,
       this.yCoord,
       this.zCoord);
   this.facadeBlocks[direction.ordinal()] = 0;
   this.facadeMeta[direction.ordinal()] = 0;
   scheduleRenderUpdate();
 }
  /* LEGACY PIPE RENDERING */
  private void legacyPipeRender(
      RenderBlocks renderblocks,
      IBlockAccess iblockaccess,
      int i,
      int j,
      int k,
      Block block,
      int l) {
    float minSize = Utils.pipeMinPos;
    float maxSize = Utils.pipeMaxPos;

    block.setBlockBounds(minSize, minSize, minSize, maxSize, maxSize, maxSize);
    renderblocks.func_83018_a(block);
    renderblocks.renderStandardBlock(block, i, j, k);

    if (Utils.checkLegacyPipesConnections(iblockaccess, i, j, k, i - 1, j, k)) {
      block.setBlockBounds(0.0F, minSize, minSize, minSize, maxSize, maxSize);
      renderblocks.func_83018_a(block);
      renderblocks.renderStandardBlock(block, i, j, k);
    }

    if (Utils.checkLegacyPipesConnections(iblockaccess, i, j, k, i + 1, j, k)) {
      block.setBlockBounds(maxSize, minSize, minSize, 1.0F, maxSize, maxSize);
      renderblocks.func_83018_a(block);
      renderblocks.renderStandardBlock(block, i, j, k);
    }

    if (Utils.checkLegacyPipesConnections(iblockaccess, i, j, k, i, j - 1, k)) {
      block.setBlockBounds(minSize, 0.0F, minSize, maxSize, minSize, maxSize);
      renderblocks.func_83018_a(block);
      renderblocks.renderStandardBlock(block, i, j, k);
    }

    if (Utils.checkLegacyPipesConnections(iblockaccess, i, j, k, i, j + 1, k)) {
      block.setBlockBounds(minSize, maxSize, minSize, maxSize, 1.0F, maxSize);
      renderblocks.func_83018_a(block);
      renderblocks.renderStandardBlock(block, i, j, k);
    }

    if (Utils.checkLegacyPipesConnections(iblockaccess, i, j, k, i, j, k - 1)) {
      block.setBlockBounds(minSize, minSize, 0.0F, maxSize, maxSize, minSize);
      renderblocks.func_83018_a(block);
      renderblocks.renderStandardBlock(block, i, j, k);
    }

    if (Utils.checkLegacyPipesConnections(iblockaccess, i, j, k, i, j, k + 1)) {
      block.setBlockBounds(minSize, minSize, maxSize, maxSize, maxSize, 1.0F);
      renderblocks.func_83018_a(block);
      renderblocks.renderStandardBlock(block, i, j, k);
    }

    block.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
  }
Beispiel #15
0
  /** If this pipe is open on one side, return it. */
  public ForgeDirection getOpenOrientation() {
    int Connections_num = 0;

    ForgeDirection target_orientation = ForgeDirection.UNKNOWN;

    for (ForgeDirection o : ForgeDirection.VALID_DIRECTIONS)
      if (Utils.checkPipesConnections(container.getTile(o), container)) {

        Connections_num++;

        if (Connections_num == 1) {
          target_orientation = o;
        }
      }

    if (Connections_num > 1 || Connections_num == 0) return ForgeDirection.UNKNOWN;

    return target_orientation.getOpposite();
  }
Beispiel #16
0
  @Override
  public void readFromNBT(NBTTagCompound nbttagcompound) {
    super.readFromNBT(nbttagcompound);

    Utils.readStacksFromNBT(nbttagcompound, "Items", items);

    if (nbttagcompound.hasKey("box")) {
      box.initialize(nbttagcompound.getCompoundTag("box"));
    }

    if (nbttagcompound.hasKey("path")) {
      path = new LinkedList<BlockIndex>();
      NBTTagList list = nbttagcompound.getTagList("path");

      for (int i = 0; i < list.tagCount(); ++i) {
        path.add(new BlockIndex((NBTTagCompound) list.tagAt(i)));
      }
    }

    done = nbttagcompound.getBoolean("done");
  }
  @Override
  public void writeToNBT(NBTTagCompound nbttagcompound) {
    super.writeToNBT(nbttagcompound);

    Utils.writeStacksToNBT(nbttagcompound, "items", items);

    nbttagcompound.setFloat("energyStored", energyStored);

    NBTTagList list = new NBTTagList();

    for (AssemblyRecipe recipe : plannedOutput) {
      NBTTagCompound cpt = new NBTTagCompound();
      recipe.output.writeToNBT(cpt);
      list.appendTag(cpt);
    }

    nbttagcompound.setTag("planned", list);

    if (currentRecipe != null) {
      NBTTagCompound recipe = new NBTTagCompound();
      currentRecipe.output.writeToNBT(recipe);
      nbttagcompound.setTag("recipe", recipe);
    }
  }
Beispiel #18
0
 @Override
 public void breakBlock(World world, int x, int y, int z, int par5, int par6) {
   Utils.preDestroyBlock(world, x, y, z);
   super.breakBlock(world, x, y, z, par5, par6);
 }
public class TileAdvancedCraftingTable extends TileLaserTableBase
    implements IInventory, ILaserTarget, IMachine, IActionReceptor, ISidedInventory {

  private final class InternalInventoryCraftingContainer extends Container {

    @Override
    public boolean canInteractWith(EntityPlayer var1) {
      return false;
    }
  }

  private final class CraftingGrid extends SimpleInventory {

    public int[] oreIDs = new int[9];

    public CraftingGrid() {
      super(9, "CraftingSlots", 1);
      Arrays.fill(oreIDs, -1);
    }

    @Override
    public void setInventorySlotContents(int slotId, ItemStack itemstack) {
      super.setInventorySlotContents(slotId, itemstack);
      if (TileAdvancedCraftingTable.this.getWorldObj() == null
          || !TileAdvancedCraftingTable.this.getWorldObj().isRemote)
        oreIDs[slotId] = itemstack == null ? -1 : OreDictionary.getOreID(itemstack);
    }
  }

  private final class InternalInventoryCrafting extends InventoryCrafting {

    int[] bindings = new int[9];
    ItemStack[] tempStacks;
    public int[] hitCount;
    private boolean useRecipeStack;

    private InternalInventoryCrafting() {
      super(new InternalInventoryCraftingContainer(), 3, 3);
    }

    @Override
    public ItemStack getStackInSlot(int slot) {
      if (slot >= 0 && slot < 9) {
        if (useRecipeStack || tempStacks == null) {
          return craftingSlots.getStackInSlot(slot);
        } else {
          if (bindings[slot] >= 0) {
            return tempStacks[bindings[slot]];
          }
        }
      }

      // vanilla returns null for out of bound stacks in InventoryCrafting as well
      return null;
    }

    @Override
    public void setInventorySlotContents(int slot, ItemStack par2ItemStack) {
      if (tempStacks != null && slot >= 0 && slot < 9 && bindings[slot] >= 0) {
        tempStacks[bindings[slot]] = par2ItemStack;
      }
    }

    @Override
    public ItemStack decrStackSize(int slot, int amount) {
      if (tempStacks != null && slot >= 0 && slot < 9 && bindings[slot] >= 0) {
        if (tempStacks[bindings[slot]].stackSize <= amount) {
          ItemStack result = tempStacks[bindings[slot]];
          tempStacks[bindings[slot]] = null;
          return result;
        } else {
          ItemStack result = tempStacks[bindings[slot]].splitStack(amount);
          if (tempStacks[bindings[slot]].stackSize <= 0) {
            tempStacks[bindings[slot]] = null;
          }
          return result;
        }
      } else {
        return null;
      }
    }

    public void recipeUpdate(boolean flag) {
      useRecipeStack = flag;
    }
  }

  private final class InternalPlayer extends EntityPlayer {

    public InternalPlayer() {
      super(TileAdvancedCraftingTable.this.getWorldObj(), new GameProfile(null, "[BuildCraft]"));
      posX = TileAdvancedCraftingTable.this.xCoord;
      posY = TileAdvancedCraftingTable.this.yCoord + 1;
      posZ = TileAdvancedCraftingTable.this.zCoord;
    }

    @Override
    public void addChatMessage(IChatComponent var1) {}

    @Override
    public boolean canCommandSenderUseCommand(int var1, String var2) {
      return false;
    }

    @Override
    public ChunkCoordinates getPlayerCoordinates() {
      return null;
    }
  }

  public InventoryCraftResult craftResult;
  private InternalInventoryCrafting internalInventoryCrafting;

  public TileAdvancedCraftingTable() {
    craftingSlots = new CraftingGrid();
    inv.addListener(this);
    invInput = new InventoryMapper(inv, 0, 15);
    invOutput = new InventoryMapper(inv, 15, 9);
    craftResult = new InventoryCraftResult();
  }

  private static final int[] SLOTS = Utils.createSlotArray(0, 24);
  private static final EnumSet<ForgeDirection> SEARCH_SIDES =
      EnumSet.of(DOWN, NORTH, SOUTH, EAST, WEST);
  private static final float REQUIRED_POWER = 500F;
  private final CraftingGrid craftingSlots;
  private final InventoryMapper invInput;
  private final InventoryMapper invOutput;
  private SlotCrafting craftSlot;
  private boolean craftable;
  private boolean justCrafted;
  private InternalPlayer internalPlayer;
  private IRecipe currentRecipe;
  private ActionMachineControl.Mode lastMode = ActionMachineControl.Mode.Unknown;
  private TileBuffer[] cache;

  @Override
  public void writeToNBT(NBTTagCompound data) {
    super.writeToNBT(data);
    craftingSlots.writeToNBT(data, "craftingSlots");
  }

  @Override
  public void readFromNBT(NBTTagCompound data) {
    super.readFromNBT(data);
    if (data.hasKey("StorageSlots")) inv.readFromNBT(data, "StorageSlots");

    if (data.hasKey("items")) craftingSlots.readFromNBT(data);
    else craftingSlots.readFromNBT(data, "craftingSlots");
  }

  @Override
  public int getSizeInventory() {
    return 24;
  }

  @Override
  public String getInventoryName() {
    return StringUtils.localize("tile.assemblyWorkbenchBlock.name");
  }

  @Override
  public void markDirty() {
    super.markDirty();
    craftable = craftResult.getStackInSlot(0) != null;
  }

  @Override
  public double getRequiredEnergy() {
    return craftResult.getStackInSlot(0) != null ? REQUIRED_POWER : 0f;
  }

  public int getProgressScaled(int i) {
    return (int) ((getEnergy() * i) / REQUIRED_POWER);
  }

  @Override
  public void invalidate() {
    super.invalidate();
    cache = null;
  }

  @Override
  public void updateEntity() {
    if (internalPlayer == null) {
      internalInventoryCrafting = new InternalInventoryCrafting();
      internalPlayer = new InternalPlayer();
      craftSlot = new SlotCrafting(internalPlayer, internalInventoryCrafting, craftResult, 0, 0, 0);
      updateRecipe();
    }
    if (!!worldObj.isRemote) return;
    if (lastMode == ActionMachineControl.Mode.Off) return;
    updateRecipe();
    searchNeighborsForIngredients();
    locateAndBindIngredients();
    updateRecipeOutputDisplay();
    justCrafted = false;
    if (canCraftAndOutput()) {
      if (getEnergy() >= getRequiredEnergy()) {
        craftItem();
        justCrafted = true;
      }
    } else {
      craftable = false;
      internalInventoryCrafting.tempStacks = null;
      internalInventoryCrafting.hitCount = null;
      setEnergy(0);
    }
  }

  private boolean canCraftAndOutput() {
    if (!hasIngredients()) return false;
    ItemStack output = getRecipeOutput();
    if (output == null) return false;
    return InvUtils.isRoomForStack(output, ForgeDirection.UP, invOutput);
  }

  private void locateAndBindIngredients() {
    internalInventoryCrafting.tempStacks = new InventoryCopy(inv).getItemStacks();
    internalInventoryCrafting.hitCount = new int[internalInventoryCrafting.tempStacks.length];
    ItemStack[] inputSlots = internalInventoryCrafting.tempStacks;
    for (int gridSlot = 0; gridSlot < craftingSlots.getSizeInventory(); gridSlot++) {
      internalInventoryCrafting.bindings[gridSlot] = -1;
      if (craftingSlots.getStackInSlot(gridSlot) == null) continue;
      boolean foundMatch = false;
      for (int inputSlot = 0; inputSlot < inputSlots.length; inputSlot++) {
        if (!isMatchingIngredient(gridSlot, inputSlot)) continue;
        if (internalInventoryCrafting.hitCount[inputSlot] < inputSlots[inputSlot].stackSize
            && internalInventoryCrafting.hitCount[inputSlot]
                < inputSlots[inputSlot].getMaxStackSize()) {
          internalInventoryCrafting.bindings[gridSlot] = inputSlot;
          internalInventoryCrafting.hitCount[inputSlot]++;
          foundMatch = true;
          break;
        }
      }
      if (!foundMatch) return;
    }
  }

  private boolean isMatchingIngredient(int gridSlot, int inputSlot) {
    ItemStack inputStack = internalInventoryCrafting.tempStacks[inputSlot];
    if (inputStack == null) return false;
    if (StackHelper.instance()
        .isMatchingItem(craftingSlots.getStackInSlot(gridSlot), inputStack, true, false))
      return true;
    if (StackHelper.instance().isCraftingEquivalent(craftingSlots.oreIDs[gridSlot], inputStack))
      return true;
    return false;
  }

  private boolean hasIngredients() {
    return currentRecipe != null && currentRecipe.matches(internalInventoryCrafting, worldObj);
  }

  private void craftItem() {
    ItemStack recipeOutput = getRecipeOutput();
    craftSlot.onPickupFromSlot(internalPlayer, recipeOutput);
    ItemStack[] tempStorage = internalInventoryCrafting.tempStacks;
    for (int i = 0; i < tempStorage.length; i++) {
      if (tempStorage[i] != null && tempStorage[i].stackSize <= 0) {
        tempStorage[i] = null;
      }
      inv.getItemStacks()[i] = tempStorage[i];
    }
    subtractEnergy(getRequiredEnergy());
    List<ItemStack> outputs = Lists.newArrayList(recipeOutput.copy());
    for (int i = 0; i < internalPlayer.inventory.mainInventory.length; i++) {
      if (internalPlayer.inventory.mainInventory[i] != null) {
        outputs.add(internalPlayer.inventory.mainInventory[i]);
        internalPlayer.inventory.mainInventory[i] = null;
      }
    }
    for (ItemStack output : outputs) {
      output.stackSize -=
          Transactor.getTransactorFor(invOutput).add(output, ForgeDirection.UP, true).stackSize;
      if (output.stackSize > 0) {
        output.stackSize -=
            Utils.addToRandomInventoryAround(worldObj, xCoord, yCoord, zCoord, output);
      }
      if (output.stackSize > 0) {
        InvUtils.dropItems(worldObj, output, xCoord, yCoord + 1, zCoord);
      }
    }
  }

  private void searchNeighborsForIngredients() {
    if (cache == null) {
      cache = TileBuffer.makeBuffer(worldObj, xCoord, yCoord, zCoord, false);
    }
    for (IInvSlot slot : InventoryIterator.getIterable(craftingSlots, ForgeDirection.UP)) {
      ItemStack ingred = slot.getStackInSlot();
      if (ingred == null) continue;
      IStackFilter filter = new CraftingFilter(ingred);
      if (InvUtils.countItems(invInput, ForgeDirection.UP, filter)
          < InvUtils.countItems(craftingSlots, ForgeDirection.UP, filter)) {
        for (ForgeDirection side : SEARCH_SIDES) {
          TileEntity tile = cache[side.ordinal()].getTile();
          if (tile instanceof IInventory) {
            IInventory inv = InvUtils.getInventory(((IInventory) tile));
            ItemStack result =
                InvUtils.moveOneItem(inv, side.getOpposite(), invInput, side, filter);
            if (result != null) {
              return;
            }
          }
        }
      }
    }
  }

  public void updateCraftingMatrix(int slot, ItemStack stack) {
    craftingSlots.setInventorySlotContents(slot, stack);
    updateRecipe();
    if (worldObj.isRemote) {
      PacketSlotChange packet =
          new PacketSlotChange(
              PacketIds.ADVANCED_WORKBENCH_SETSLOT, xCoord, yCoord, zCoord, slot, stack);
      BuildCraftSilicon.instance.sendToServer(packet);
    }
  }

  private void updateRecipe() {
    if (internalInventoryCrafting == null) {
      return;
    }
    internalInventoryCrafting.recipeUpdate(true);
    if (this.currentRecipe == null
        || !this.currentRecipe.matches(internalInventoryCrafting, worldObj)) {
      currentRecipe = CraftingHelper.findMatchingRecipe(internalInventoryCrafting, worldObj);
    }
    internalInventoryCrafting.recipeUpdate(false);
    markDirty();
  }

  private void updateRecipeOutputDisplay() {
    if (internalInventoryCrafting == null || currentRecipe == null) {
      craftResult.setInventorySlotContents(0, null);
      return;
    }
    ItemStack resultStack = getRecipeOutput();
    if (resultStack == null) {
      internalInventoryCrafting.recipeUpdate(true);
      resultStack = getRecipeOutput();
      internalInventoryCrafting.recipeUpdate(false);
    }
    craftResult.setInventorySlotContents(0, resultStack);
    markDirty();
  }

  private ItemStack getRecipeOutput() {
    if (internalInventoryCrafting == null || currentRecipe == null) {
      return null;
    }
    return currentRecipe.getCraftingResult(internalInventoryCrafting);
  }

  public IInventory getCraftingSlots() {
    return craftingSlots;
  }

  public IInventory getOutputSlot() {
    return craftResult;
  }

  @Override
  public boolean canCraft() {
    return craftable && !justCrafted && lastMode != ActionMachineControl.Mode.Off;
  }

  @Override
  public boolean isActive() {
    return requiresLaserEnergy();
  }

  @Override
  public boolean manageFluids() {
    return false;
  }

  @Override
  public boolean manageSolids() {
    return false;
  }

  @Override
  public boolean allowAction(IAction action) {
    return action == BuildCraftCore.actionOn || action == BuildCraftCore.actionOff;
  }

  @Override
  public int[] getAccessibleSlotsFromSide(int side) {
    return SLOTS;
  }

  @Override
  public boolean canInsertItem(int slot, ItemStack stack, int side) {
    return isItemValidForSlot(slot, stack);
  }

  @Override
  public boolean canExtractItem(int slot, ItemStack stack, int side) {
    return slot >= 15;
  }

  @Override
  public boolean isItemValidForSlot(int slot, ItemStack stack) {
    return slot < 15;
  }

  @Override
  public void actionActivated(IAction action) {
    if (action == BuildCraftCore.actionOn) {
      lastMode = ActionMachineControl.Mode.On;
    } else if (action == BuildCraftCore.actionOff) {
      lastMode = ActionMachineControl.Mode.Off;
    }
  }

  @Override
  public boolean hasCustomInventoryName() {
    return false;
  }
}
Beispiel #20
0
  @Override
  public boolean onBlockActivated(
      World world,
      int i,
      int j,
      int k,
      EntityPlayer entityplayer,
      int par6,
      float par7,
      float par8,
      float par9) {
    // Drop through if the player is sneaking
    if (entityplayer.isSneaking()) return false;

    Item equipped =
        entityplayer.getCurrentEquippedItem() != null
            ? entityplayer.getCurrentEquippedItem().getItem()
            : null;
    if (equipped instanceof IToolWrench
        && ((IToolWrench) equipped).canWrench(entityplayer, i, j, k)) {

      int meta = world.getBlockMetadata(i, j, k);

      switch (ForgeDirection.values()[meta]) {
        case WEST:
          world.setBlockMetadata(i, j, k, ForgeDirection.SOUTH.ordinal());
          break;
        case EAST:
          world.setBlockMetadata(i, j, k, ForgeDirection.NORTH.ordinal());
          break;
        case NORTH:
          world.setBlockMetadata(i, j, k, ForgeDirection.WEST.ordinal());
          break;
        case SOUTH:
        default:
          world.setBlockMetadata(i, j, k, ForgeDirection.EAST.ordinal());
          break;
      }
      ((IToolWrench) equipped).wrenchUsed(entityplayer, i, j, k);
      world.markBlockNeedsUpdate(i, j, k);
      return true;
    } else {

      LiquidStack liquid =
          LiquidManager.getLiquidForFilledItem(entityplayer.getCurrentEquippedItem());

      if (liquid != null) {
        int qty =
            ((TileRefinery) world.getBlockTileEntity(i, j, k))
                .fill(ForgeDirection.UNKNOWN, liquid, true);

        if (qty != 0 && !BuildCraftCore.debugMode && !entityplayer.capabilities.isCreativeMode) {
          entityplayer.inventory.setInventorySlotContents(
              entityplayer.inventory.currentItem,
              Utils.consumeItem(entityplayer.inventory.getCurrentItem()));
        }

        return true;
      }
    }

    if (!CoreProxy.proxy.isRenderWorld(world))
      entityplayer.openGui(BuildCraftFactory.instance, GuiIds.REFINERY, world, i, j, k);

    return true;
  }
  @Override
  public void updateEntity() {
    tick++;
    tick = tick % recentEnergy.length;
    recentEnergy[tick] = 0.0f;

    if (currentRecipe == null) return;

    if (!currentRecipe.canBeDone(items)) {
      setNextCurrentRecipe();

      if (currentRecipe == null) return;
    }

    if (energyStored >= currentRecipe.energy) {
      energyStored = 0;

      if (currentRecipe.canBeDone(items)) {

        for (ItemStack in : currentRecipe.input) {
          if (in == null) {
            continue; // Optimisation, reduces calculation for a null ingredient
          }

          int found = 0; // Amount of ingredient found in inventory

          for (int i = 0; i < items.length; ++i) {
            if (items[i] == null) {
              continue; // Broken out of large if statement, increases clarity
            }

            if (items[i].isItemEqual(in)) {

              int supply = items[i].stackSize;
              int toBeFound = in.stackSize - found;

              if (supply >= toBeFound) {
                found +=
                    decrStackSize(i, toBeFound)
                        .stackSize; // Adds the amount of ingredient taken (in this case the total
                                    // still needed)
              } else {
                found +=
                    decrStackSize(i, supply)
                        .stackSize; // Adds the amount of ingredient taken (in this case the total
                                    // in that slot)
              }
              if (found >= in.stackSize) {
                break; // Breaks out of the for loop when the required amount of ingredient has been
                       // taken
              }
            }
          }
        }

        ItemStack remaining = currentRecipe.output.copy();
        ItemStack added =
            Utils.addToRandomInventory(
                remaining, worldObj, xCoord, yCoord, zCoord, ForgeDirection.UNKNOWN);
        remaining.stackSize -= added.stackSize;

        if (remaining.stackSize > 0) {
          Utils.addToRandomPipeEntry(this, ForgeDirection.UNKNOWN, remaining);
        }

        if (remaining.stackSize > 0) {
          EntityItem entityitem =
              new EntityItem(
                  worldObj, xCoord + 0.5, yCoord + 0.7, zCoord + 0.5, currentRecipe.output.copy());

          worldObj.spawnEntityInWorld(entityitem);
        }

        setNextCurrentRecipe();
      }
    }
  }
 public InventoryWrapperSimple(IInventory inventory) {
   super(inventory);
   slots = Utils.createSlotArray(0, inventory.getSizeInventory());
 }
Beispiel #23
0
 @Override
 public void createLaserData() {
   lasersData = Utils.createLaserDataBox(xMin, yMin, zMin, xMax, yMax, zMax);
 }
  @SideOnly(Side.CLIENT)
  public void activateLasers() {
    deactivateLasers();
    EntityClientPlayerMP player = FMLClientHandler.instance().getClient().thePlayer;
    int playerY = (int) player.posY - 1;
    for (ChunkCoordIntPair coords : persistentChunks) {
      int xCoord = coords.chunkXPos * 16;
      int zCoord = coords.chunkZPos * 16;

      addLasersToList(
          Utils.createLaserBox(
              player.worldObj,
              xCoord,
              playerY,
              zCoord,
              xCoord + 16,
              playerY,
              zCoord + 16,
              buildcraft.core.LaserKind.Blue));
      addLasersToList(
          Utils.createLaserBox(
              player.worldObj,
              xCoord,
              playerY - 20,
              zCoord,
              xCoord + 16,
              playerY - 20,
              zCoord + 16,
              buildcraft.core.LaserKind.Blue));
      addLasersToList(
          Utils.createLaserBox(
              player.worldObj,
              xCoord,
              playerY + 20,
              zCoord,
              xCoord + 16,
              playerY + 20,
              zCoord + 16,
              buildcraft.core.LaserKind.Blue));

      addLasersToList(
          Utils.createLaserBox(
              player.worldObj,
              xCoord + 7,
              playerY,
              zCoord + 7,
              xCoord + 9,
              playerY,
              zCoord + 9,
              buildcraft.core.LaserKind.Blue));
      addLasersToList(
          Utils.createLaserBox(
              player.worldObj,
              xCoord + 7,
              playerY - 20,
              zCoord + 7,
              xCoord + 9,
              playerY - 20,
              zCoord + 9,
              buildcraft.core.LaserKind.Blue));
      addLasersToList(
          Utils.createLaserBox(
              player.worldObj,
              xCoord + 7,
              playerY + 20,
              zCoord + 7,
              xCoord + 9,
              playerY + 20,
              zCoord + 9,
              buildcraft.core.LaserKind.Blue));
    }
    active = true;
  }
 @Override
 public boolean doDrop() {
   Utils.preDestroyBlock(getWorld(), container.xCoord, container.yCoord, container.zCoord);
   return true;
 }