Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live

Ocultar sin cambios

Sin ajuste de línea

Vista

Nivel de detalle

Resaltado de sintaxis

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

Untitled diff

Creado hace 11 añosEl diff nunca expira

5 eliminaciones

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

220 líneas

5 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

220 líneas

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;

}

Diferencias guardadas

Texto original

Abrir archivo

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;
  }
}

Texto modificado

Abrir archivo

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);