Compare text

Find the difference between two text files

Real-time editor

Hide unchanged lines

Disable line wrap

Layout

Diff precision

Syntax highlighting

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 11 years agoDiff never expires

5 removals

Lines
Total
Removed

Characters
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

220 lines

5 additions

Lines
Total
Added

Characters
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

220 lines

package buildcraft.krapht.pipes;

import aan;

import buildcraft.api.EntityPassiveItem;

import buildcraft.api.Orientations;

import buildcraft.api.Position;

import buildcraft.core.Utils;

import buildcraft.factory.TileAutoWorkbench;

import buildcraft.api.ISpecialInventory;

import buildcraft.krapht.CraftingTemplate;

import buildcraft.krapht.IBuildCraftProxy;

import buildcraft.krapht.ICraftItems;

import buildcraft.krapht.IRequestItems;

import buildcraft.krapht.LogisticsOrderManager;

import buildcraft.krapht.LogisticsPromise;

import buildcraft.krapht.LogisticsRequest;

import buildcraft.krapht.LogisticsTransaction;

import buildcraft.krapht.RoutedPipe;

import buildcraft.krapht.SimpleServiceLocator;

import buildcraft.krapht.logic.LogicCrafting;

import buildcraft.krapht.routing.IRouter;

import buildcraft.logisticspipes.IRoutedItem;

import buildcraft.logisticspipes.IRoutedItem.TransportMode;

import buildcraft.logisticspipes.modules.ILogisticsModule;

import buildcraft.transport.PipeTransportItems;

import buildcraft.transport.TileGenericPipe;

import core_LogisticsPipes;

import io;

import java.io.PrintStream;

import java.util.HashMap;

import java.util.LinkedList;

import krapht.AdjacentTile;

import krapht.InventoryUtil;

import krapht.ItemIdentifier;

import krapht.ItemIdentifierStack;

import krapht.WorldUtil;

import kw;

import xd;

public class PipeItemsCraftingLogistics extends RoutedPipe

implements ICraftItems

{

private LogisticsOrderManager _orderManager = new LogisticsOrderManager();

private int _extras;

public PipeItemsCraftingLogistics(int itemID)

{

super(new LogicCrafting(), itemID);

}

private LinkedList locateCrafters() {

WorldUtil worldUtil = new WorldUtil(this.worldObj, this.xCoord, this.yCoord, this.zCoord);

LinkedList crafters = new LinkedList();

for (AdjacentTile tile : worldUtil.getAdjacentTileEntities()) {

if (((tile.tile instanceof TileGenericPipe)) ||

(!(tile.tile instanceof io))) continue;

crafters.add(tile);

}

return crafters;

}

private aan extractFromAutoWorkbench(TileAutoWorkbench workbench) {

private aan extractFromISpecialInventory(ISpecialInventory inv) {

return workbench.extractItem(true, Orientations.Unknown);

return inv.extractItem(true, Orientations.Unknown);

}

private aan extractFromIInventory(io inv)

{

InventoryUtil invUtil = new InventoryUtil(inv, false);

LogicCrafting craftingLogic = (LogicCrafting)this.logic;

aan itemstack = craftingLogic.getCraftedItem();

if (itemstack == null) return null;

ItemIdentifierStack targetItemStack = ItemIdentifierStack.GetFromStack(itemstack);

return invUtil.getSingleItem(targetItemStack.getItem());

}

public void updateEntity()

{

super.updateEntity();

if (((!this._orderManager.hasOrders()) && (this._extras < 1)) || (this.worldObj.w() % 6L != 0L)) return;

LinkedList crafters = locateCrafters();

if (crafters.size() < 1) {

this._orderManager.sendFailed();

return;

}

for (AdjacentTile tile : locateCrafters()) {

aan extracted = null;

if ((tile.tile instanceof TileAutoWorkbench))

if ((tile.tile instanceof ISpecialInventory))

extracted = extractFromAutoWorkbench((TileAutoWorkbench)tile.tile);

extracted = extractFromISpecialInventory((ISpecialInventory)tile.tile);

else if ((tile.tile instanceof io)) {

extracted = extractFromIInventory((io)tile.tile);

}

if (extracted != null)

while (extracted.a > 0) {

aan stackToSend = extracted.a(1);

Position p = new Position(tile.tile.j, tile.tile.k, tile.tile.l, tile.orientation);

if (this._orderManager.hasOrders()) {

LogisticsRequest order = this._orderManager.getNextRequest();

IRoutedItem item = SimpleServiceLocator.buildCraftProxy.CreateRoutedItem(stackToSend, this.worldObj);

item.setSource(getRouter().getId());

item.setDestination(order.getDestination().getRouter().getId());

item.setTransportMode(IRoutedItem.TransportMode.Active);

super.queueRoutedItem(item, tile.orientation);

this._orderManager.sendSuccessfull(1);

} else {

this._extras -= 1;

System.out.println("Extra dropped, " + this._extras + " remaining");

Position entityPos = new Position(p.x + 0.5D, p.y + Utils.getPipeFloorOf(stackToSend), p.z + 0.5D, p.orientation.reverse());

entityPos.moveForwards(0.5D);

EntityPassiveItem entityItem = new EntityPassiveItem(this.worldObj, entityPos.x, entityPos.y, entityPos.z, stackToSend);

entityItem.speed = (Utils.pipeNormalSpeed * 10.0F);

((PipeTransportItems)this.transport).entityEntering(entityItem, entityPos.orientation);

}

private ItemIdentifier providedItem() {

LogicCrafting craftingLogic = (LogicCrafting)this.logic;

aan stack = craftingLogic.getCraftedItem();

if (stack == null) return null;

return ItemIdentifier.get(stack);

}

public int getCenterTexture()

{

return core_LogisticsPipes.LOGISTICSPIPE_CRAFTER_TEXTURE;

}

public void canProvide(LogisticsTransaction transaction)

{

if (!isEnabled()) {

return;

}

if (this._extras < 1) return;

for (LogisticsRequest request : transaction.getRemainingRequests()) {

ItemIdentifier providedItem = providedItem();

if (request.getItem() == providedItem) {

HashMap promised = transaction.getTotalPromised(this);

int alreadyPromised = promised.containsKey(providedItem) ? ((Integer)promised.get(providedItem)).intValue() : 0;

if (alreadyPromised < this._extras) {

int remaining = this._extras - alreadyPromised;

LogisticsPromise promise = new LogisticsPromise();

promise.item = providedItem;

promise.numberOfItems = Math.min(remaining, request.notYetAllocated());

promise.sender = this;

promise.extra = true;

request.addPromise(promise);

}

public void canCraft(LogisticsTransaction transaction) {

if (!isEnabled()) {

return;

}

LogicCrafting craftingLogic = (LogicCrafting)this.logic;

aan stack = craftingLogic.getCraftedItem();

if (stack == null) return;

CraftingTemplate template = new CraftingTemplate(ItemIdentifierStack.GetFromStack(stack), this);

boolean hasSatellite = craftingLogic.isSatelliteConnected();

for (int i = 0; i < 9; i++) {

aan resourceStack = craftingLogic.getMaterials(i);

if ((resourceStack != null) && (resourceStack.a != 0)) {

if ((i < 6) || (!hasSatellite)) {

template.addRequirement(ItemIdentifierStack.GetFromStack(resourceStack), this);

}

else {

template.addRequirement(ItemIdentifierStack.GetFromStack(resourceStack), craftingLogic.getSatelliteRouter().getPipe());

}

transaction.addCraftingTemplate(template);

}

public void fullFill(LogisticsPromise promise, IRequestItems destination)

{

if (promise.extra) {

this._extras -= promise.numberOfItems;

}

this._orderManager.addOrder(new LogisticsRequest(promise.item, promise.numberOfItems, destination));

}

public int getAvailableItemCount(ItemIdentifier item)

{

return 0;

}

public void registerExtras(int count)

{

this._extras += count;

System.out.println(count + " extras registered");

}

public HashMap getAllItems()

{

return new HashMap();

}

public ItemIdentifier getCraftedItem()

{

if (!isEnabled()) {

return null;

}

return providedItem();

}

public ILogisticsModule getLogisticsModule()

{

return null;

}

Saved diffs

Original text

Open file

package buildcraft.krapht.pipes;

import aan;
import buildcraft.api.EntityPassiveItem;
import buildcraft.api.Orientations;
import buildcraft.api.Position;
import buildcraft.core.Utils;
import buildcraft.factory.TileAutoWorkbench;
import buildcraft.krapht.CraftingTemplate;
import buildcraft.krapht.IBuildCraftProxy;
import buildcraft.krapht.ICraftItems;
import buildcraft.krapht.IRequestItems;
import buildcraft.krapht.LogisticsOrderManager;
import buildcraft.krapht.LogisticsPromise;
import buildcraft.krapht.LogisticsRequest;
import buildcraft.krapht.LogisticsTransaction;
import buildcraft.krapht.RoutedPipe;
import buildcraft.krapht.SimpleServiceLocator;
import buildcraft.krapht.logic.LogicCrafting;
import buildcraft.krapht.routing.IRouter;
import buildcraft.logisticspipes.IRoutedItem;
import buildcraft.logisticspipes.IRoutedItem.TransportMode;
import buildcraft.logisticspipes.modules.ILogisticsModule;
import buildcraft.transport.PipeTransportItems;
import buildcraft.transport.TileGenericPipe;
import core_LogisticsPipes;
import io;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.LinkedList;
import krapht.AdjacentTile;
import krapht.InventoryUtil;
import krapht.ItemIdentifier;
import krapht.ItemIdentifierStack;
import krapht.WorldUtil;
import kw;
import xd;

public class PipeItemsCraftingLogistics extends RoutedPipe
  implements ICraftItems
{
  private LogisticsOrderManager _orderManager = new LogisticsOrderManager();
  private int _extras;

public PipeItemsCraftingLogistics(int itemID)
  {
    super(new LogicCrafting(), itemID);
  }

private LinkedList locateCrafters() {
    WorldUtil worldUtil = new WorldUtil(this.worldObj, this.xCoord, this.yCoord, this.zCoord);
    LinkedList crafters = new LinkedList();
    for (AdjacentTile tile : worldUtil.getAdjacentTileEntities()) {
      if (((tile.tile instanceof TileGenericPipe)) || 
        (!(tile.tile instanceof io))) continue;
      crafters.add(tile);
    }
    return crafters;
  }

private aan extractFromAutoWorkbench(TileAutoWorkbench workbench) {
    return workbench.extractItem(true, Orientations.Unknown);
  }

private aan extractFromIInventory(io inv)
  {
    InventoryUtil invUtil = new InventoryUtil(inv, false);
    LogicCrafting craftingLogic = (LogicCrafting)this.logic;
    aan itemstack = craftingLogic.getCraftedItem();
    if (itemstack == null) return null;

ItemIdentifierStack targetItemStack = ItemIdentifierStack.GetFromStack(itemstack);

return invUtil.getSingleItem(targetItemStack.getItem());
  }

public void updateEntity()
  {
    super.updateEntity();
    if (((!this._orderManager.hasOrders()) && (this._extras < 1)) || (this.worldObj.w() % 6L != 0L)) return;

LinkedList crafters = locateCrafters();
    if (crafters.size() < 1) {
      this._orderManager.sendFailed();
      return;
    }

for (AdjacentTile tile : locateCrafters()) {
      aan extracted = null;
      if ((tile.tile instanceof TileAutoWorkbench))
        extracted = extractFromAutoWorkbench((TileAutoWorkbench)tile.tile);
      else if ((tile.tile instanceof io)) {
        extracted = extractFromIInventory((io)tile.tile);
      }
      if (extracted != null)
        while (extracted.a > 0) {
          aan stackToSend = extracted.a(1);
          Position p = new Position(tile.tile.j, tile.tile.k, tile.tile.l, tile.orientation);
          if (this._orderManager.hasOrders()) {
            LogisticsRequest order = this._orderManager.getNextRequest();
            IRoutedItem item = SimpleServiceLocator.buildCraftProxy.CreateRoutedItem(stackToSend, this.worldObj);
            item.setSource(getRouter().getId());
            item.setDestination(order.getDestination().getRouter().getId());
            item.setTransportMode(IRoutedItem.TransportMode.Active);
            super.queueRoutedItem(item, tile.orientation);

this._orderManager.sendSuccessfull(1);
          } else {
            this._extras -= 1;
            System.out.println("Extra dropped, " + this._extras + " remaining");
            Position entityPos = new Position(p.x + 0.5D, p.y + Utils.getPipeFloorOf(stackToSend), p.z + 0.5D, p.orientation.reverse());
            entityPos.moveForwards(0.5D);
            EntityPassiveItem entityItem = new EntityPassiveItem(this.worldObj, entityPos.x, entityPos.y, entityPos.z, stackToSend);
            entityItem.speed = (Utils.pipeNormalSpeed * 10.0F);
            ((PipeTransportItems)this.transport).entityEntering(entityItem, entityPos.orientation);
          }
        }
    }
  }

private ItemIdentifier providedItem() {
    LogicCrafting craftingLogic = (LogicCrafting)this.logic;
    aan stack = craftingLogic.getCraftedItem();
    if (stack == null) return null;
    return ItemIdentifier.get(stack);
  }

public int getCenterTexture()
  {
    return core_LogisticsPipes.LOGISTICSPIPE_CRAFTER_TEXTURE;
  }

public void canProvide(LogisticsTransaction transaction)
  {
    if (!isEnabled()) {
      return;
    }

if (this._extras < 1) return;
    for (LogisticsRequest request : transaction.getRemainingRequests()) {
      ItemIdentifier providedItem = providedItem();
      if (request.getItem() == providedItem) {
        HashMap promised = transaction.getTotalPromised(this);
        int alreadyPromised = promised.containsKey(providedItem) ? ((Integer)promised.get(providedItem)).intValue() : 0;
        if (alreadyPromised < this._extras) {
          int remaining = this._extras - alreadyPromised;
          LogisticsPromise promise = new LogisticsPromise();
          promise.item = providedItem;
          promise.numberOfItems = Math.min(remaining, request.notYetAllocated());
          promise.sender = this;
          promise.extra = true;
          request.addPromise(promise);
        }
      }
    }
  }

public void canCraft(LogisticsTransaction transaction) {
    if (!isEnabled()) {
      return;
    }

LogicCrafting craftingLogic = (LogicCrafting)this.logic;
    aan stack = craftingLogic.getCraftedItem();
    if (stack == null) return;

CraftingTemplate template = new CraftingTemplate(ItemIdentifierStack.GetFromStack(stack), this);

boolean hasSatellite = craftingLogic.isSatelliteConnected();
    for (int i = 0; i < 9; i++) {
      aan resourceStack = craftingLogic.getMaterials(i);
      if ((resourceStack != null) && (resourceStack.a != 0)) {
        if ((i < 6) || (!hasSatellite)) {
          template.addRequirement(ItemIdentifierStack.GetFromStack(resourceStack), this);
        }
        else {
          template.addRequirement(ItemIdentifierStack.GetFromStack(resourceStack), craftingLogic.getSatelliteRouter().getPipe());
        }
      }
    }
    transaction.addCraftingTemplate(template);
  }

public void fullFill(LogisticsPromise promise, IRequestItems destination)
  {
    if (promise.extra) {
      this._extras -= promise.numberOfItems;
    }
    this._orderManager.addOrder(new LogisticsRequest(promise.item, promise.numberOfItems, destination));
  }

public int getAvailableItemCount(ItemIdentifier item)
  {
    return 0;
  }

public void registerExtras(int count)
  {
    this._extras += count;
    System.out.println(count + " extras registered");
  }

public HashMap getAllItems()
  {
    return new HashMap();
  }

public ItemIdentifier getCraftedItem()
  {
    if (!isEnabled()) {
      return null;
    }
    return providedItem();
  }

public ILogisticsModule getLogisticsModule()
  {
    return null;
  }
}

Changed text

Open file

package buildcraft.krapht.pipes;

import aan;
import buildcraft.api.EntityPassiveItem;
import buildcraft.api.Orientations;
import buildcraft.api.Position;
import buildcraft.core.Utils;
import buildcraft.api.ISpecialInventory;
import buildcraft.krapht.CraftingTemplate;
import buildcraft.krapht.IBuildCraftProxy;
import buildcraft.krapht.ICraftItems;
import buildcraft.krapht.IRequestItems;
import buildcraft.krapht.LogisticsOrderManager;
import buildcraft.krapht.LogisticsPromise;
import buildcraft.krapht.LogisticsRequest;
import buildcraft.krapht.LogisticsTransaction;
import buildcraft.krapht.RoutedPipe;
import buildcraft.krapht.SimpleServiceLocator;
import buildcraft.krapht.logic.LogicCrafting;
import buildcraft.krapht.routing.IRouter;
import buildcraft.logisticspipes.IRoutedItem;
import buildcraft.logisticspipes.IRoutedItem.TransportMode;
import buildcraft.logisticspipes.modules.ILogisticsModule;
import buildcraft.transport.PipeTransportItems;
import buildcraft.transport.TileGenericPipe;
import core_LogisticsPipes;
import io;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.LinkedList;
import krapht.AdjacentTile;
import krapht.InventoryUtil;
import krapht.ItemIdentifier;
import krapht.ItemIdentifierStack;
import krapht.WorldUtil;
import kw;
import xd;

public class PipeItemsCraftingLogistics extends RoutedPipe
  implements ICraftItems
{
  private LogisticsOrderManager _orderManager = new LogisticsOrderManager();
  private int _extras;

public PipeItemsCraftingLogistics(int itemID)
  {
    super(new LogicCrafting(), itemID);
  }

private aan extractFromISpecialInventory(ISpecialInventory inv) {
    return inv.extractItem(true, Orientations.Unknown);
  }

ItemIdentifierStack targetItemStack = ItemIdentifierStack.GetFromStack(itemstack);

return invUtil.getSingleItem(targetItemStack.getItem());
  }

public void updateEntity()
  {
    super.updateEntity();
    if (((!this._orderManager.hasOrders()) && (this._extras < 1)) || (this.worldObj.w() % 6L != 0L)) return;

LinkedList crafters = locateCrafters();
    if (crafters.size() < 1) {
      this._orderManager.sendFailed();
      return;
    }

for (AdjacentTile tile : locateCrafters()) {
      aan extracted = null;
      if ((tile.tile instanceof ISpecialInventory))
        extracted = extractFromISpecialInventory((ISpecialInventory)tile.tile);
      else if ((tile.tile instanceof io)) {
        extracted = extractFromIInventory((io)tile.tile);
      }
      if (extracted != null)
        while (extracted.a > 0) {
          aan stackToSend = extracted.a(1);
          Position p = new Position(tile.tile.j, tile.tile.k, tile.tile.l, tile.orientation);
          if (this._orderManager.hasOrders()) {
            LogisticsRequest order = this._orderManager.getNextRequest();
            IRoutedItem item = SimpleServiceLocator.buildCraftProxy.CreateRoutedItem(stackToSend, this.worldObj);
            item.setSource(getRouter().getId());
            item.setDestination(order.getDestination().getRouter().getId());
            item.setTransportMode(IRoutedItem.TransportMode.Active);
            super.queueRoutedItem(item, tile.orientation);