public boolean verifyCache() { if (itemDuct.getGrid() == null) { return false; } RouteCache<DuctUnitItem, GridItem> cache1 = itemDuct.getCache(false); if (!cache1.isFinishedGenerating()) { return false; } if (cache1 != cache || routesWithInsertSideList.type != getSortType()) { cache = cache1; Stream<Route<DuctUnitItem, GridItem>> routesWithDestinations = getRoutesWithDestinations(cache.outputRoutes); LinkedList<Route<DuctUnitItem, GridItem>> objects = Lists.newLinkedList(); routesWithDestinations.forEach(objects::add); routesWithInsertSideList.setList(objects, getSortType()); } return true; }
public void tickForward(DuctUnitItem homeTile) { progress += step; if (myPath == null) { bounceItem(homeTile); } else if (progress >= homeTile.getDuctLength()) { progress %= homeTile.getDuctLength(); advanceTile(homeTile); } else if (progress >= homeTile.getPipeHalfLength() && progress - step < homeTile.getPipeHalfLength()) { if (reRoute || homeTile.getRenderConnectionType(direction) == BlockDuct.ConnectionType.NONE) { bounceItem(homeTile); } } }
public TileDuctItem(Duct duct) { addDuctUnits(DuctToken.ITEMS, new DuctUnitItem(this, duct)); }
public static Stream<Route<DuctUnitItem, GridItem>> getRoutesWithDestinations(Collection<Route<DuctUnitItem, GridItem>> outputRoutes) { return outputRoutes.stream().flatMap(route -> IntStream.range(0, 6).filter(i -> route.endPoint.isOutput(i) && route.endPoint.getConnectionType((byte) i).allowTransfer && route.endPoint.tileCache[i] != null).mapToObj(i -> { Route<DuctUnitItem, GridItem> ductUnitItemGridItemRoute = new Route<>(route); ductUnitItemGridItemRoute.pathDirections.add((byte) i); return ductUnitItemGridItemRoute; })); }
public void tickClientForward(DuctUnitItem homeTile) { progress += step; if (progress >= homeTile.getDuctLength()) { progress %= homeTile.getDuctLength(); if (shouldDie) { homeTile.removeItem(this, true); } else { homeTile.removeItem(this, false); shouldDie = true; TileEntity newTile = BlockHelper.getAdjacentTileEntity(homeTile.parent, direction); if (newTile instanceof IDuctHolder) { DuctUnitItem itemDuct = ((IDuctHolder) newTile).getDuct(DuctToken.ITEMS); if (itemDuct != null) { oldDirection = direction; itemDuct.myItems.add(this); if (!TickHandlerClient.tickBlocks.contains(itemDuct) && !TickHandlerClient.tickBlocksToAdd.contains(itemDuct)) { TickHandlerClient.tickBlocksToAdd.add(itemDuct); } } } } } }
public void bounceItem(DuctUnitItem homeTile) { RouteCache<DuctUnitItem, GridItem> routes = homeTile.getCache(); if (aRoute.endPoint.isNode() && aRoute.endPoint.x() == destX && aRoute.endPoint.y() == destY && aRoute.endPoint.z() == destZ) { for (byte side = 0; side < 6; side++) { if (aRoute.endPoint.canRouteItem(stack, side) != -1) { myPath = aRoute.copy(); myPath.pathDirections.add(side); if (aRoute.endPoint.isNode()) { for (byte side = 0; side < 6; side++) { if (aRoute.endPoint.canRouteItem(stack, side) != -1) { myPath = aRoute.copy(); myPath.pathDirections.add(side); if (homeTile.acceptingStuff()) { byte d = homeTile.getStuffedSide(); if (d == direction) { homeTile.stuffItem(this); homeTile.removeItem(this, true); } else { myPath = new Route(homeTile); homeTile.hasChanged = true; } else if (homeTile.ticksExisted == DuctUnitItem.MAX_TICKS_EXISTED_BEFORE_DUMP) { CoreUtils.dropItemStackIntoWorld(stack, homeTile.world(), new Vec3d(homeTile.pos())); homeTile.removeItem(this, true);
public void advanceTile(DuctUnitItem homeTile) { DuctUnitItem newHome = homeTile.getConnectedSide(direction); if (newHome != null) { if (newHome.ductCache[direction ^ 1] != null) { homeTile.removeItem(this, false); newHome.transferItem(this); if (myPath.hasNextDirection()) { oldDirection = direction; } else if (homeTile.isOutput(direction) && homeTile.parent.getConnectionType(direction).allowTransfer) { stack.setCount(homeTile.insertIntoInventory(stack.copy(), direction)); return; homeTile.removeItem(this, true); } else if (homeTile.isInput(direction) && goingToStuff) { if (homeTile.canStuffItem()) { goingToStuff = false; homeTile.stuffItem(this); homeTile.removeItem(this, true); } else { goingToStuff = false;
public ItemStack insertItem(EnumFacing from, ItemStack item, boolean simulate) { int side = from.ordinal(); if (!((isInput(side)) || (isOutput(side) && parent.getConnectionType(side).allowTransfer))) { return item; } if (grid == null) { return item; } RouteCache<DuctUnitItem, GridItem> routeCache = getCache(false); TravelingItem routeForItem = ServoItem.findRouteForItem(ItemHelper.cloneStack(item, Math.min(INSERT_SIZE, item.getCount())), ServoItem.getRoutesWithDestinations(routeCache.outputRoutes).filter(t -> t.endPoint != this || t.getLastSide() != side).iterator(), this, side, ServoItem.range[0], (byte) 1); if (routeForItem == null) { return item; } if (!simulate) { insertNewItem(routeForItem); } return ItemHelper.cloneStack(item, item.getCount() - routeForItem.stack.getCount()); }
if (cache == null || (!endPoint.isInput(i) && !endPoint.isOutput(i)) || !endPoint.parent.getConnectionType(i).allowTransfer) { continue; continue; ItemStack remainder = DuctUnitItem.simulateInsertItemStackIntoInventory(simulatedInv, item.copy(), side ^ 1, filter.getMaxStock()); if (!remainder.isEmpty()) { item.shrink(remainder.getCount()); continue; Route route1 = endPoint.getRoute(itemDuct); if (route1 == null) { continue; endPoint.insertNewItem(new TravelingItem(item, endPoint, route1, (byte) (i ^ 1), getSpeed())); routesWithInsertSideList.advanceCursor(); return;
duct.pulseLine(travelingItem.direction, (byte) (travelingItem.oldDirection ^ 1)); DuctUnitItem newHome = duct.getConnectedSide(travelingItem.direction); if (newHome != null) { if (newHome.getConnectedSide(travelingItem.direction ^ 1) != null) { duct = newHome; if (travelingItem.myPath.hasNextDirection()) { return; } else if (duct.isOutput(travelingItem.direction)) { travelingItem.stack.setCount(duct.insertIntoInventory(travelingItem.stack, travelingItem.direction));
return false; RouteCache routes = duct.getDuct(DuctToken.ITEMS).getCache(true); Iterable<Route> paramIterable = routes.outputRoutes; Route route = null; duct.getDuct(DuctToken.ITEMS).insertNewItem(travelItem); return true;
public void handleStuffedItems() { for (Iterator<ItemStack> iterator = stuffedItems.iterator(); iterator.hasNext(); ) { ItemStack stuffedItem = iterator.next(); ItemStack send = stuffedItem.copy(); send.setCount(Math.min(send.getCount(), send.getMaxStackSize())); TravelingItem travelingItem = getRouteForItem(send); if (travelingItem == null) { continue; } stuffedItem.shrink(travelingItem.stack.getCount()); if (stuffedItem.getCount() <= 0) { iterator.remove(); } itemDuct.insertNewItem(travelingItem); routesWithInsertSideList.advanceCursor(); return; } }
public RouteCache<DuctUnitItem, GridItem> getCache() { return getCache(true); }
@Override public double getDistance() { return Math.max(duct.getDuct(DuctToken.ITEMS).getDuctLength(), 0); }
public static TravelingItem findRouteForItem(ItemStack item, Iterator<Route<DuctUnitItem, GridItem>> routes, DuctUnitItem duct, int side, int maxRange, byte speed) { if (item.isEmpty() || item.getCount() == 0) { return null; } item = item.copy(); if (item.getCount() == 0) { return null; } while (routes.hasNext()) { Route<DuctUnitItem, GridItem> outputRoute = routes.next(); if (outputRoute.pathDirections.size() <= maxRange) { int amountRemaining = outputRoute.endPoint.canRouteItem(item, outputRoute.getLastSide()); if (amountRemaining != -1) { int stackSize = item.getCount() - amountRemaining; if (stackSize <= 0) { continue; } Route itemRoute = outputRoute.copy(); item.setCount(stackSize); return new TravelingItem(item, duct, itemRoute, (byte) (side ^ 1), speed); } } } return null; }
@Override public void insertNewItem(TravelingItem travelingItem) { if (enderEnergy.getGrid() != null && enderEnergy.getGrid().myStorage.getEnergyStored() >= TDProps.ENDER_TRANSMIT_COST && enderEnergy.getGrid().myStorage.extractEnergy(TDProps.ENDER_TRANSMIT_COST, true) >= TDProps.ENDER_TRANSMIT_COST) { enderEnergy.getGrid().myStorage.extractEnergy(TDProps.ENDER_TRANSMIT_COST, false); multiAdvance(travelingItem, true); } else { super.insertNewItem(travelingItem); } }
.getCache(true).outputRoutes; double closesedConnection = Integer.MAX_VALUE; for (Route<DuctUnitItem, GridItem> localRoute1 : paramIterable) {
continue; double v = (renderItem.progress + frame * renderItem.step) / (duct.getDuctLength());
@Override public List<RouteInfo> getConnectedPipes(EnumFacing from) { List<RouteInfo> list = new ArrayList<>(); if (duct.getDuct(DuctToken.ITEMS).getGrid() == null) { return null; } LinkedList<Route<DuctUnitItem, GridItem>> paramIterable = duct.getDuct(DuctToken.ITEMS).getCache(true).outputRoutes; for (Route<DuctUnitItem, GridItem> localRoute1 : paramIterable) { if (localRoute1.endPoint instanceof LPDuctUnitItem) { LPDuctUnitItem lpDuct = (LPDuctUnitItem) localRoute1.endPoint; list.add(new RouteInfo(lpDuct.pipe, localRoute1.pathWeight, EnumFacing.getFront(localRoute1.pathDirections.get(localRoute1.pathDirections.size() - 1)))); } } return list; } }