From 176a2e58ee950cf4f2c3963324864e4ac3ece0e5 Mon Sep 17 00:00:00 2001 From: George Paton Date: Fri, 31 Oct 2025 13:00:40 +1100 Subject: [PATCH 1/2] fix crash in highlands mod due to it using a deprecated biome hook --- src/main/java/com/hbm/lib/HbmWorldGen.java | 6 ++++ .../com/hbm/world/gen/MapGenChainloader.java | 32 ++++++++++++++++++- .../hbm/world/gen/terrain/MapGenBubble.java | 2 +- 3 files changed, 38 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/hbm/lib/HbmWorldGen.java b/src/main/java/com/hbm/lib/HbmWorldGen.java index 3a2b61833..e483d5489 100644 --- a/src/main/java/com/hbm/lib/HbmWorldGen.java +++ b/src/main/java/com/hbm/lib/HbmWorldGen.java @@ -21,6 +21,7 @@ import com.hbm.util.WeightedRandomGeneric; import com.hbm.world.dungeon.*; import com.hbm.world.feature.*; import com.hbm.world.feature.BedrockOre.BedrockOreDefinition; +import com.hbm.world.gen.MapGenChainloader; import com.hbm.world.generator.CellularDungeonFactory; import com.hbm.world.generator.DungeonToolbox; import cpw.mods.fml.common.IWorldGenerator; @@ -40,6 +41,11 @@ public class HbmWorldGen implements IWorldGenerator { @Override public void generate(Random rand, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider) { + // quick fix for bad generators + if(world.provider.dimensionId == 0) { + MapGenChainloader.repairBadGeneration(world, chunkX, chunkZ); + } + switch (world.provider.dimensionId) { case -1: generateNether(world, rand, chunkX * 16, chunkZ * 16); break; diff --git a/src/main/java/com/hbm/world/gen/MapGenChainloader.java b/src/main/java/com/hbm/world/gen/MapGenChainloader.java index 93dbc96e5..01a605a4c 100644 --- a/src/main/java/com/hbm/world/gen/MapGenChainloader.java +++ b/src/main/java/com/hbm/world/gen/MapGenChainloader.java @@ -1,11 +1,13 @@ package com.hbm.world.gen; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import cpw.mods.fml.common.eventhandler.EventPriority; import cpw.mods.fml.common.eventhandler.SubscribeEvent; import net.minecraft.block.Block; +import net.minecraft.world.ChunkCoordIntPair; import net.minecraft.world.World; import net.minecraft.world.chunk.IChunkProvider; import net.minecraft.world.gen.MapGenBase; @@ -32,6 +34,9 @@ public class MapGenChainloader extends MapGenBase { // Hack to provide the current generating chunk's block metas to the generation function private static byte[] blockMetas; + // Double hack to check we actually get the damn metas, if not we will have to do a quick bit of post gen! + private static HashMap blockMetaMap = new HashMap<>(); + // Executes our chainloaded parent, and all our child generators @Override public void func_151539_a(IChunkProvider chunk, World world, int chunkX, int chunkZ, Block[] blocks) { @@ -62,6 +67,24 @@ public class MapGenChainloader extends MapGenBase { netherGenerators.add(generator); } + public static void repairBadGeneration(World world, int chunkX, int chunkZ) { + ChunkCoordIntPair coords = new ChunkCoordIntPair(chunkX, chunkZ); + if(MapGenChainloader.blockMetaMap.containsKey(coords)) { + byte[] metas = MapGenChainloader.blockMetaMap.get(coords); + for(int i = 0; i < metas.length; i++) { + if(metas[i] == 0) continue; + int y = i % 256; + int xz = (i - y) / 256; + int z = xz % 16; + int x = (xz - z) / 16; + + world.setBlockMetadataWithNotify(chunkX * 16 + x, y, chunkZ * 16 + z, metas[i], 3); + } + + MapGenChainloader.blockMetaMap.remove(coords); + } + } + public static class MapGenEventHandler { // Register as late as possible to pick up any modded cave generators @@ -84,7 +107,14 @@ public class MapGenChainloader extends MapGenBase { @SubscribeEvent public void storeLatestBlockMeta(ReplaceBiomeBlocks event) { - blockMetas = event.metaArray; + if(event.metaArray.length == 256) { + // a mod is using a deprecated forge hook! fuck! + // we will store our own meta array and apply metas _after_ chunk gen has finished + blockMetas = new byte[65536]; + blockMetaMap.put(new ChunkCoordIntPair(event.chunkX, event.chunkZ), blockMetas); + } else { + blockMetas = event.metaArray; + } } } diff --git a/src/main/java/com/hbm/world/gen/terrain/MapGenBubble.java b/src/main/java/com/hbm/world/gen/terrain/MapGenBubble.java index 5562090cd..f7a4a05fd 100644 --- a/src/main/java/com/hbm/world/gen/terrain/MapGenBubble.java +++ b/src/main/java/com/hbm/world/gen/terrain/MapGenBubble.java @@ -53,7 +53,7 @@ public class MapGenBubble extends MapGenBase { double radiusSqr = (radius * radius) / 2; // original OilBubble implementation divided the square by 2 for some reason int yMin = Math.max(1, MathHelper.floor_double(yCoord - radius)); - int yMax = MathHelper.ceiling_double_int(yCoord + radius); + int yMax = Math.min(127, MathHelper.ceiling_double_int(yCoord + radius)); for(int bx = 15; bx >= 0; bx--) // bx, bz is the coordinate of the block we're modifying, relative to the generating chunk origin for(int bz = 15; bz >= 0; bz--) From 09dd5e37b53d5c77debb92086a81452039946212 Mon Sep 17 00:00:00 2001 From: George Paton Date: Fri, 31 Oct 2025 14:33:09 +1100 Subject: [PATCH 2/2] nodespace foundry channels! (also fix arc furnace only accepting one stack from IO port if it triggers it to close) --- .../hbm/blocks/machine/FoundryChannel.java | 60 ++++-- .../machine/TileEntityFoundryChannel.java | 195 ++++++++---------- .../TileEntityMachineArcFurnaceLarge.java | 16 +- .../networkproviders/FoundryNetwork.java | 10 + .../FoundryNetworkProvider.java | 14 ++ 5 files changed, 154 insertions(+), 141 deletions(-) create mode 100644 src/main/java/com/hbm/uninos/networkproviders/FoundryNetwork.java create mode 100644 src/main/java/com/hbm/uninos/networkproviders/FoundryNetworkProvider.java diff --git a/src/main/java/com/hbm/blocks/machine/FoundryChannel.java b/src/main/java/com/hbm/blocks/machine/FoundryChannel.java index 84faf6dee..206babecb 100644 --- a/src/main/java/com/hbm/blocks/machine/FoundryChannel.java +++ b/src/main/java/com/hbm/blocks/machine/FoundryChannel.java @@ -4,11 +4,17 @@ import java.util.ArrayList; import java.util.List; import com.hbm.blocks.ModBlocks; +import com.hbm.inventory.material.NTMMaterial; import com.hbm.inventory.material.Mats.MaterialStack; import com.hbm.items.machine.ItemScraps; import com.hbm.lib.Library; import com.hbm.lib.RefStrings; import com.hbm.tileentity.machine.TileEntityFoundryChannel; +import com.hbm.uninos.GenNode; +import com.hbm.uninos.INetworkProvider; +import com.hbm.uninos.networkproviders.FoundryNetwork; +import com.hbm.util.fauxpointtwelve.BlockPos; +import com.hbm.util.fauxpointtwelve.DirPos; import api.hbm.block.ICrucibleAcceptor; import cpw.mods.fml.client.registry.RenderingRegistry; @@ -41,7 +47,7 @@ public class FoundryChannel extends BlockContainer implements ICrucibleAcceptor public FoundryChannel() { super(Material.rock); } - + @Override @SideOnly(Side.CLIENT) public void registerBlockIcons(IIconRegister iconRegister) { @@ -65,16 +71,16 @@ public class FoundryChannel extends BlockContainer implements ICrucibleAcceptor @Override public void addCollisionBoxesToList(World world, int x, int y, int z, AxisAlignedBB entityBounding, List list, Entity entity) { - + List bbs = new ArrayList(); - + bbs.add(AxisAlignedBB.getBoundingBox(x + 0.3125D, y, z + 0.3125D, x + 0.6875D, y + 0.5D, z + 0.6875D)); if(canConnectTo(world, x, y, z, Library.POS_X)) bbs.add(AxisAlignedBB.getBoundingBox(x + 0.6875D, y, z + 0.3125D, x + 1D, y + 0.5D, z + 0.6875D)); if(canConnectTo(world, x, y, z, Library.NEG_X)) bbs.add(AxisAlignedBB.getBoundingBox(x, y, z + 0.3125D, x + 0.3125D, y + 0.5D, z + 0.6875D)); if(canConnectTo(world, x, y, z, Library.POS_Z)) bbs.add(AxisAlignedBB.getBoundingBox(x + 0.3125D, y, z + 0.6875D, x + 0.6875D, y + 0.5D, z + 1D)); if(canConnectTo(world, x, y, z, Library.NEG_Z)) bbs.add(AxisAlignedBB.getBoundingBox(x + 0.3125D, y, z, x + 0.6875D, y + 0.5D, z + 0.3125D)); - + for(AxisAlignedBB bb : bbs) { if(entityBounding.intersectsWith(bb)) { list.add(bb); @@ -120,23 +126,23 @@ public class FoundryChannel extends BlockContainer implements ICrucibleAcceptor public boolean canAcceptPartialFlow(World world, int x, int y, int z, ForgeDirection side, MaterialStack stack) { return ((ICrucibleAcceptor) world.getTileEntity(x, y, z)).canAcceptPartialFlow(world, x, y, z, side, stack); } - + @Override public MaterialStack flow(World world, int x, int y, int z, ForgeDirection side, MaterialStack stack) { return ((ICrucibleAcceptor) world.getTileEntity(x, y, z)).flow(world, x, y, z, side, stack); } - + public boolean canConnectTo(IBlockAccess world, int x, int y, int z, ForgeDirection dir) { - + if(dir == ForgeDirection.UP || dir == ForgeDirection.DOWN || dir == ForgeDirection.UNKNOWN) return false; - + Block b = world.getBlock(x + dir.offsetX, y, z + dir.offsetZ); int meta = world.getBlockMetadata(x + dir.offsetX, y, z + dir.offsetZ); - + if((b == ModBlocks.foundry_outlet || b == ModBlocks.foundry_slagtap) && meta == dir.ordinal()) return true; - + return b == ModBlocks.foundry_channel || b == ModBlocks.foundry_mold; } @@ -146,25 +152,25 @@ public class FoundryChannel extends BlockContainer implements ICrucibleAcceptor public int getRenderType() { return renderID; } - + @Override public boolean isOpaqueCube() { return false; } - + @Override public boolean renderAsNormalBlock() { return false; } - + @Override public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ) { if(world.isRemote) { return true; } - + TileEntityFoundryChannel cast = (TileEntityFoundryChannel) world.getTileEntity(x, y, z); - + if(player.getHeldItem() != null && player.getHeldItem().getItem() instanceof ItemTool && ((ItemTool) player.getHeldItem().getItem()).getToolClasses(player.getHeldItem()).contains("shovel")) { if(cast.amount > 0) { ItemStack scrap = ItemScraps.create(new MaterialStack(cast.type, cast.amount)); @@ -176,19 +182,18 @@ public class FoundryChannel extends BlockContainer implements ICrucibleAcceptor } cast.amount = 0; cast.type = null; - cast.propagateMaterial(null); cast.markDirty(); world.markBlockForUpdate(x, y, z); } return true; } - + return false; } @Override public void breakBlock(World world, int x, int y, int z, Block b, int i) { - + TileEntityFoundryChannel channel = (TileEntityFoundryChannel) world.getTileEntity(x, y, z); if(channel.amount > 0) { ItemStack scrap = ItemScraps.create(new MaterialStack(channel.type, channel.amount)); @@ -196,7 +201,24 @@ public class FoundryChannel extends BlockContainer implements ICrucibleAcceptor world.spawnEntityInWorld(item); channel.amount = 0; } - + super.breakBlock(world, x, y, z, b, i); } + + public static class FoundryNode extends GenNode { + + public NTMMaterial type; + + public FoundryNode(INetworkProvider provider, BlockPos... positions) { + super(provider, positions); + } + + @Override + public FoundryNode setConnections(DirPos... connections) { + super.setConnections(connections); + return this; + } + + } + } diff --git a/src/main/java/com/hbm/tileentity/machine/TileEntityFoundryChannel.java b/src/main/java/com/hbm/tileentity/machine/TileEntityFoundryChannel.java index d20e8acb0..0ffaffefe 100644 --- a/src/main/java/com/hbm/tileentity/machine/TileEntityFoundryChannel.java +++ b/src/main/java/com/hbm/tileentity/machine/TileEntityFoundryChannel.java @@ -5,10 +5,14 @@ import java.util.Collections; import java.util.List; import com.hbm.blocks.ModBlocks; +import com.hbm.blocks.machine.FoundryChannel.FoundryNode; import com.hbm.inventory.material.MaterialShapes; -import com.hbm.inventory.material.Mats; import com.hbm.inventory.material.Mats.MaterialStack; -import com.hbm.inventory.material.NTMMaterial; +import com.hbm.lib.Library; +import com.hbm.uninos.UniNodespace; +import com.hbm.uninos.networkproviders.FoundryNetworkProvider; +import com.hbm.util.fauxpointtwelve.BlockPos; +import com.hbm.util.fauxpointtwelve.DirPos; import api.hbm.block.ICrucibleAcceptor; import net.minecraft.block.Block; @@ -18,60 +22,54 @@ import net.minecraft.world.World; import net.minecraftforge.common.util.ForgeDirection; public class TileEntityFoundryChannel extends TileEntityFoundryBase { - + public int nextUpdate; public int lastFlow = 0; - protected NTMMaterial neighborType; - protected boolean hasCheckedNeighbors; - protected int unpropagateTime; - + protected FoundryNode node; + @Override public void updateEntity() { - + if(!worldObj.isRemote) { + initNode(); - // Initialise before allowing pours, so newly added channels will avoid causing clog feeds - if(!hasCheckedNeighbors) { - List visited = new ArrayList(); - visited.add(this); - - neighborType = checkNeighbors(visited); - hasCheckedNeighbors = true; + if(this.node.type != null && this.amount == 0) { + this.node.type = null; } - + if(this.type == null && this.amount != 0) { this.amount = 0; } - + nextUpdate--; - + if(nextUpdate <= 0 && this.amount > 0 && this.type != null) { - + boolean hasOp = false; nextUpdate = 5; - + List ints = new ArrayList() {{ add(2); add(3); add(4); add(5); }}; Collections.shuffle(ints); if(lastFlow > 0) { ints.remove((Integer) this.lastFlow); ints.add(this.lastFlow); } - + for(Integer i : ints) { ForgeDirection dir = ForgeDirection.getOrientation(i); Block b = worldObj.getBlock(xCoord + dir.offsetX, yCoord, zCoord + dir.offsetZ); - + if(b instanceof ICrucibleAcceptor && b != ModBlocks.foundry_channel) { ICrucibleAcceptor acc = (ICrucibleAcceptor) b; - + if(acc.canAcceptPartialFlow(worldObj, xCoord + dir.offsetX, yCoord, zCoord + dir.offsetZ, dir.getOpposite(), new MaterialStack(this.type, this.amount))) { MaterialStack left = acc.flow(worldObj, xCoord + dir.offsetX, yCoord, zCoord + dir.offsetZ, dir.getOpposite(), new MaterialStack(this.type, this.amount)); if(left == null) { this.type = null; this.amount = 0; - propagateMaterial(null); + this.node.type = null; } else { this.amount = left.amount; } @@ -80,31 +78,33 @@ public class TileEntityFoundryChannel extends TileEntityFoundryBase { } } } - + if(!hasOp) { for(Integer i : ints) { ForgeDirection dir = ForgeDirection.getOrientation(i); TileEntity b = worldObj.getTileEntity(xCoord + dir.offsetX, yCoord, zCoord + dir.offsetZ); - + if(b instanceof TileEntityFoundryChannel) { TileEntityFoundryChannel acc = (TileEntityFoundryChannel) b; - + if(acc.type == null || acc.type == this.type || acc.amount == 0) { acc.type = this.type; - + acc.initNode(); + acc.node.type = this.type; + acc.lastFlow = dir.getOpposite().ordinal(); - + if(worldObj.rand.nextInt(5) == 0 || this.amount == 1) { //force swap operations with single quanta to keep them moving //1:4 chance that the fill states are simply swapped //this promotes faster spreading and prevents spread limits int buf = this.amount; this.amount = acc.amount; acc.amount = buf; - + } else { //otherwise, equalize the neighbors int diff = this.amount - acc.amount; - + if(diff > 0) { diff /= 2; this.amount -= diff; @@ -117,24 +117,28 @@ public class TileEntityFoundryChannel extends TileEntityFoundryBase { } } - if(neighborType != null && amount == 0) unpropagateTime++; - - // every 5 seconds do a unprop test, will only occur once per contiguous channel per 5 seconds due to the timer getting updated in all channels from the prop - if(unpropagateTime > 100) { - propagateMaterial(null); - } - if(this.amount == 0) { this.lastFlow = 0; this.nextUpdate = 5; - } else { - unpropagateTime = 0; } } - + super.updateEntity(); } + protected void initNode() { + if(this.node == null || this.node.expired) { + + this.node = (FoundryNode) UniNodespace.getNode(worldObj, xCoord, yCoord, zCoord, FoundryNetworkProvider.THE_PROVIDER); + + if(this.node == null || this.node.expired) { + this.node = this.createNode(); + this.node.type = this.type; + UniNodespace.createNode(worldObj, this.node); + } + } + } + @Override public int getCapacity() { return MaterialShapes.INGOT.q(2); @@ -144,95 +148,58 @@ public class TileEntityFoundryChannel extends TileEntityFoundryBase { public void readFromNBT(NBTTagCompound nbt) { super.readFromNBT(nbt); this.lastFlow = nbt.getByte("flow"); - this.neighborType = Mats.matById.get(nbt.getInteger("nType")); - this.hasCheckedNeighbors = nbt.getBoolean("init"); } @Override public void writeToNBT(NBTTagCompound nbt) { super.writeToNBT(nbt); nbt.setByte("flow", (byte) this.lastFlow); - nbt.setInteger("nType", this.neighborType != null ? this.neighborType.id : -1); - nbt.setBoolean("init", hasCheckedNeighbors); } - /** - * Channels accept pouring as normal, except when neighbor channels already have material. - * This prevents a contiguous channel from having multiple different types of material in it, causing clogs. - * If you connect two channels that have different materials already in them, god help you (nah jokes it'll just be clogged until you fix manually) - */ + @Override + public void invalidate() { + super.invalidate(); + + if(!worldObj.isRemote) { + if(this.node != null) { + UniNodespace.destroyNode(worldObj, xCoord, yCoord, zCoord, FoundryNetworkProvider.THE_PROVIDER); + } + } + } + + public FoundryNode createNode() { + TileEntity tile = (TileEntity) this; + return new FoundryNode(FoundryNetworkProvider.THE_PROVIDER, new BlockPos(tile.xCoord, tile.yCoord, tile.zCoord)).setConnections( + new DirPos(tile.xCoord + 1, tile.yCoord, tile.zCoord, Library.POS_X), + new DirPos(tile.xCoord - 1, tile.yCoord, tile.zCoord, Library.NEG_X), + new DirPos(tile.xCoord, tile.yCoord, tile.zCoord + 1, Library.POS_Z), + new DirPos(tile.xCoord, tile.yCoord, tile.zCoord - 1, Library.NEG_Z) + ); + } + @Override public boolean canAcceptPartialPour(World world, int x, int y, int z, double dX, double dY, double dZ, ForgeDirection side, MaterialStack stack) { - if(!hasCheckedNeighbors || (neighborType != null && neighborType != stack.material)) return false; + if(this.node == null) return false; + for(Object o : this.node.net.links) { + FoundryNode node = (FoundryNode) o; + if(node.type != null && node.type != stack.material) { + return false; + } + } + return super.canAcceptPartialPour(world, x, y, z, dX, dY, dZ, side, stack); } - /** Upon pouring, propagate the current material type along contiguous channels */ + @Override + public MaterialStack flow(World world, int x, int y, int z, ForgeDirection side, MaterialStack stack) { + if(this.node != null) this.node.type = stack.material; + return super.flow(world, x, y, z, side, stack); + } + @Override public MaterialStack pour(World world, int x, int y, int z, double dX, double dY, double dZ, ForgeDirection side, MaterialStack stack) { - propagateMaterial(stack.material); + if(this.node != null) this.node.type = stack.material; return super.pour(world, x, y, z, dX, dY, dZ, side, stack); } - public void propagateMaterial(NTMMaterial propType) { - if(propType != null && neighborType != null) return; // optimise away any pours that change nothing - - List visited = new ArrayList(); - visited.add(this); - - boolean hasMaterial = propagateMaterial(propType, visited, false); - - // since we are now fully clear, it's safe to unassign the contiguous channel type - if(propType == null && !hasMaterial) { - for(TileEntityFoundryChannel acc : visited) { - acc.neighborType = null; - } - } - } - - protected boolean propagateMaterial(NTMMaterial propType, List visited, boolean hasMaterial) { - // if emptying, don't mark the channel as ready for a new material until it is entirely clear - if(propType != null) { - neighborType = propType; - } else { - // and when empty testing, update the last unpropagate time - unpropagateTime = 0; - } - - for(ForgeDirection dir : new ForgeDirection[] { ForgeDirection.NORTH, ForgeDirection.SOUTH, ForgeDirection.WEST, ForgeDirection.EAST }) { - TileEntity b = worldObj.getTileEntity(xCoord + dir.offsetX, yCoord, zCoord + dir.offsetZ); - - if(b instanceof TileEntityFoundryChannel && !visited.contains(b)) { - TileEntityFoundryChannel acc = (TileEntityFoundryChannel) b; - visited.add(acc); - - if(acc.amount > 0) hasMaterial = true; - - hasMaterial = acc.propagateMaterial(propType, visited, hasMaterial); - } - } - - return hasMaterial; - } - - protected NTMMaterial checkNeighbors(List visited) { - if(neighborType != null) return neighborType; - - for(ForgeDirection dir : new ForgeDirection[] { ForgeDirection.NORTH, ForgeDirection.SOUTH, ForgeDirection.WEST, ForgeDirection.EAST }) { - TileEntity b = worldObj.getTileEntity(xCoord + dir.offsetX, yCoord, zCoord + dir.offsetZ); - - if(b instanceof TileEntityFoundryChannel && !visited.contains(b)) { - TileEntityFoundryChannel acc = (TileEntityFoundryChannel) b; - visited.add(acc); - - NTMMaterial neighborMaterial = acc.checkNeighbors(visited); - - // immediately propagate backwards if a material is found - if(neighborMaterial != null) return neighborMaterial; - } - } - - return null; - } - } diff --git a/src/main/java/com/hbm/tileentity/machine/TileEntityMachineArcFurnaceLarge.java b/src/main/java/com/hbm/tileentity/machine/TileEntityMachineArcFurnaceLarge.java index 1bf233ed7..3ae1e58a6 100644 --- a/src/main/java/com/hbm/tileentity/machine/TileEntityMachineArcFurnaceLarge.java +++ b/src/main/java/com/hbm/tileentity/machine/TileEntityMachineArcFurnaceLarge.java @@ -113,8 +113,8 @@ public class TileEntityMachineArcFurnaceLarge extends TileEntityMachineBase impl this.isProgressing = false; for(DirPos pos : getConPos()) this.trySubscribe(worldObj, pos.getX(), pos.getY(), pos.getZ(), pos.getDir()); - - if(lid == 1) loadIngredients(); + + if(lid > 0) loadIngredients(); if(power > 0) { @@ -269,17 +269,17 @@ public class TileEntityMachineArcFurnaceLarge extends TileEntityMachineBase impl } } } - + /** Moves items from the input queue to the main grid */ public void loadIngredients() { - + boolean markDirty = false; - + for(int q /* queue */ = 25; q < 30; q++) { if(slots[q] == null) continue; ArcFurnaceRecipe recipe = ArcFurnaceRecipes.getOutput(slots[q], this.liquidMode); if(recipe == null) continue; - + // add to existing stacks for(int i /* ingredient */ = 5; i < 25; i++) { if(slots[i] == null) continue; @@ -293,7 +293,7 @@ public class TileEntityMachineArcFurnaceLarge extends TileEntityMachineBase impl } if(slots[q] == null) break; } - + // add to empty slot if(slots[q] != null) for(int i /* ingredient */ = 5; i < 25; i++) { if(slots[i] != null) continue; @@ -306,7 +306,7 @@ public class TileEntityMachineArcFurnaceLarge extends TileEntityMachineBase impl if(slots[q] == null) break; } } - + if(markDirty) this.markDirty(); } diff --git a/src/main/java/com/hbm/uninos/networkproviders/FoundryNetwork.java b/src/main/java/com/hbm/uninos/networkproviders/FoundryNetwork.java new file mode 100644 index 000000000..1d8a99525 --- /dev/null +++ b/src/main/java/com/hbm/uninos/networkproviders/FoundryNetwork.java @@ -0,0 +1,10 @@ +package com.hbm.uninos.networkproviders; + +import com.hbm.uninos.NodeNet; + +public class FoundryNetwork extends NodeNet { + + @Override + public void update() { } + +} diff --git a/src/main/java/com/hbm/uninos/networkproviders/FoundryNetworkProvider.java b/src/main/java/com/hbm/uninos/networkproviders/FoundryNetworkProvider.java new file mode 100644 index 000000000..c61fe58a4 --- /dev/null +++ b/src/main/java/com/hbm/uninos/networkproviders/FoundryNetworkProvider.java @@ -0,0 +1,14 @@ +package com.hbm.uninos.networkproviders; + +import com.hbm.uninos.INetworkProvider; + +public class FoundryNetworkProvider implements INetworkProvider { + + public static FoundryNetworkProvider THE_PROVIDER = new FoundryNetworkProvider(); + + @Override + public FoundryNetwork provideNetwork() { + return new FoundryNetwork(); + } + +}