From fce0b080565dad81950142018ac6ac01bf0dcf12 Mon Sep 17 00:00:00 2001 From: BallOfEnergy <66693744+BallOfEnergy1@users.noreply.github.com> Date: Mon, 19 Aug 2024 19:11:54 -0500 Subject: [PATCH] this is fucking insane dude RBMK optimization update soon!!!!!!! --- .../java/api/hbm/energymk2/Nodespace.java | 1 + .../com/hbm/blocks/machine/rbmk/RBMKBase.java | 8 + .../com/hbm/handler/rbmkmk2/RBMKHandler.java | 316 +++++++++++------- .../com/hbm/items/machine/ItemRBMKLid.java | 10 +- .../java/com/hbm/main/ModEventHandler.java | 8 +- .../machine/rbmk/TileEntityRBMKBase.java | 19 +- .../machine/rbmk/TileEntityRBMKOutgasser.java | 2 +- .../machine/rbmk/TileEntityRBMKRod.java | 22 +- .../rbmk/TileEntityRBMKSlottedBase.java | 4 - 9 files changed, 239 insertions(+), 151 deletions(-) diff --git a/src/main/java/api/hbm/energymk2/Nodespace.java b/src/main/java/api/hbm/energymk2/Nodespace.java index cdc618f51..07a5b94b2 100644 --- a/src/main/java/api/hbm/energymk2/Nodespace.java +++ b/src/main/java/api/hbm/energymk2/Nodespace.java @@ -8,6 +8,7 @@ import java.util.Set; import com.hbm.util.fauxpointtwelve.BlockPos; import com.hbm.util.fauxpointtwelve.DirPos; +import cpw.mods.fml.common.gameevent.TickEvent; import net.minecraft.server.MinecraftServer; import net.minecraft.world.World; diff --git a/src/main/java/com/hbm/blocks/machine/rbmk/RBMKBase.java b/src/main/java/com/hbm/blocks/machine/rbmk/RBMKBase.java index 1293874a8..55975c521 100644 --- a/src/main/java/com/hbm/blocks/machine/rbmk/RBMKBase.java +++ b/src/main/java/com/hbm/blocks/machine/rbmk/RBMKBase.java @@ -3,6 +3,7 @@ package com.hbm.blocks.machine.rbmk; import com.hbm.blocks.BlockDummyable; import com.hbm.blocks.ILookOverlay; import com.hbm.handler.MultiblockHandlerXR; +import com.hbm.handler.rbmkmk2.RBMKHandler; import com.hbm.items.ModItems; import com.hbm.items.machine.ItemRBMKLid; import com.hbm.lib.RefStrings; @@ -11,6 +12,7 @@ import com.hbm.tileentity.machine.rbmk.RBMKDials; import com.hbm.tileentity.machine.rbmk.TileEntityRBMKBase; import api.hbm.block.IToolable; +import com.hbm.util.fauxpointtwelve.BlockPos; import cpw.mods.fml.client.registry.RenderingRegistry; import cpw.mods.fml.common.network.internal.FMLNetworkHandler; import cpw.mods.fml.relauncher.Side; @@ -27,6 +29,8 @@ import net.minecraft.world.World; import net.minecraftforge.client.event.RenderGameOverlayEvent.Pre; import net.minecraftforge.common.util.ForgeDirection; +import static com.hbm.handler.rbmkmk2.RBMKHandler.getNode; + public abstract class RBMKBase extends BlockDummyable implements IToolable, ILookOverlay { public static boolean dropLids = true; @@ -170,6 +174,10 @@ public abstract class RBMKBase extends BlockDummyable implements IToolable, ILoo int i = rbmk.getBlockMetadata(); if(rbmk.hasLid() && rbmk.isLidRemovable()) { + + RBMKHandler.RBMKNode node = getNode(new BlockPos(te)); + if (node != null) + node.removeLid(); if(!world.isRemote) { if(i == DIR_NORMAL_LID.ordinal() + offset) { diff --git a/src/main/java/com/hbm/handler/rbmkmk2/RBMKHandler.java b/src/main/java/com/hbm/handler/rbmkmk2/RBMKHandler.java index 03d369ae6..1b92d92a6 100644 --- a/src/main/java/com/hbm/handler/rbmkmk2/RBMKHandler.java +++ b/src/main/java/com/hbm/handler/rbmkmk2/RBMKHandler.java @@ -4,13 +4,16 @@ import com.hbm.blocks.machine.rbmk.RBMKBase; import com.hbm.handler.radiation.ChunkRadiationManager; import com.hbm.tileentity.machine.rbmk.*; import com.hbm.util.fauxpointtwelve.BlockPos; -import net.minecraft.block.Block; -import net.minecraft.server.MinecraftServer; + +import java.util.HashMap; +import java.util.Map.Entry; +import java.util.ArrayList; +import java.util.List; + import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Vec3; import net.minecraft.world.World; - -import java.util.*; +import net.minecraftforge.common.util.ForgeDirection; public class RBMKHandler { @@ -30,6 +33,10 @@ public class RBMKHandler { OTHER // why do neutron calculations on them if they won't change anything? } + private static TileEntity blockPosToTE(World worldObj, BlockPos pos) { + return worldObj.getTileEntity(pos.getX(), pos.getY(), pos.getZ()); + } + public static class RBMKNode { protected RBMKType type; @@ -40,16 +47,66 @@ public class RBMKHandler { this.type = type; this.tile = tile; this.hasLid = tile.hasLid(); - addNode(this); + } + + public void addLid() { + this.hasLid = true; + } + + public void removeLid() { + this.hasLid = false; + } + + public void checkNode(BlockPos pos) { + + if (tile == null) + removeNode(pos); // what the fuck??? + + if (tile.isInvalid()) + removeNode(pos); + + if (tile instanceof TileEntityRBMKRod && !(tile instanceof TileEntityRBMKRodReaSim)) { + TileEntityRBMKRod rod = (TileEntityRBMKRod) tile; + if (!rod.hasRod) { + + // Simulate streams coming out of the RBMK rod find nodes to uncache. + + for (ForgeDirection dir : TileEntityRBMKRod.fluxDirs) { + NeutronStream stream = new NeutronStream(this, Vec3.createVectorHelper(dir.offsetX, 0, dir.offsetZ)); + + List nodes = stream.getNodes(false); + for (RBMKNode nodeToRemove : nodes) + removeNode(new BlockPos(nodeToRemove.tile)); + } + } + } + + // TODO: Implement `hasRodInRange` for non-rod tile uncaching. } } - private static TileEntity blockPosToTE(World worldObj, BlockPos pos) { - return worldObj.getTileEntity(pos.getX(), pos.getY(), pos.getZ()); + public static RBMKNode makeNode(TileEntityRBMKBase tile) { + BlockPos pos = new BlockPos(tile); + if (nodeCache.containsKey(pos)) + return getNode(pos); + return new RBMKNode(tile, tile.getRBMKType()); } - public static RBMKNode makeNode(TileEntityRBMKBase tile) { - return new RBMKNode(tile, tile.getRBMKType()); + public static class StreamWorld { + + List streams; + + public StreamWorld() { + streams = new ArrayList<>(); + } + + public void addStream(NeutronStream stream) { + this.streams.add(stream); + } + + public void removeAllStreams() { + this.streams.clear(); + } } public static class NeutronStream { @@ -66,12 +123,25 @@ public class RBMKHandler { // Vector for direction of neutron flow. public Vec3 vector; + // Primarily used as a "dummy stream", not to be added to the streams list. + public NeutronStream(RBMKNode origin, Vec3 vector) { + this.origin = origin; + this.vector = vector; + } + public NeutronStream(RBMKNode origin, Vec3 vector, double flux, double ratio) { this.origin = origin; this.vector = vector; this.fluxQuantity = flux; this.fluxRatio = ratio; - streams.put(this, origin.tile.getWorldObj()); + World worldObj = origin.tile.getWorldObj(); + if (streamWorlds.get(worldObj) != null) + streamWorlds.get(worldObj).addStream(this); + else { + StreamWorld world = new StreamWorld(); + world.addStream(this); + streamWorlds.put(worldObj, world); + } } public List getBlocks() { @@ -90,7 +160,7 @@ public class RBMKHandler { // This, however, is used for actual RBMK flux calculations. // Does NOT include the origin node // USES THE CACHE!!! - public List getNodes() { + public List getNodes(boolean cache) { List positions = new ArrayList<>(); for (int i = 1; i <= fluxRange; i++) { @@ -99,24 +169,18 @@ public class RBMKHandler { BlockPos pos = new BlockPos(origin.tile).add(x, 0, z); - if (nodeCache.containsKey(pos)) { - positions.add(nodeCache.get(pos)); - continue; - } + if (nodeCache.containsKey(pos) && cache) + positions.add(getNode(pos)); - // If it isn't an RBMK block then don't do anything with it - if(!(origin.tile.getBlockType() instanceof RBMKBase)) - continue; - - TileEntity te = blockPosToTE(origin.tile.getWorldObj(), pos); - - if (te instanceof TileEntityRBMKBase) { - TileEntityRBMKBase rbmkBase = (TileEntityRBMKBase) te; - RBMKType type = rbmkBase.getRBMKType(); - // they should ALL be RBMKBase TEs - RBMKNode node = new RBMKNode(rbmkBase, type); - positions.add(node); - addNode(node); + else if (this.origin.tile.getBlockType() instanceof RBMKBase) { + TileEntity te = blockPosToTE(this.origin.tile.getWorldObj(), pos); + if (te instanceof TileEntityRBMKBase) { + TileEntityRBMKBase rbmkBase = (TileEntityRBMKBase)te; + RBMKNode node = makeNode(rbmkBase); + positions.add(node); + if (cache) + addNode(node); + } } } return positions; @@ -143,6 +207,7 @@ public class RBMKHandler { } int moderatedCount = 0; + double totalFluxMod = 1; for(BlockPos nodePos : getBlocks()) { @@ -152,33 +217,28 @@ public class RBMKHandler { RBMKNode node = nodeCache.get(nodePos); if(node == null) { - TileEntity te = blockPosToTE(worldObj, nodePos); // ok, maybe it didn't get added to the list somehow? + TileEntity te = blockPosToTE(worldObj, nodePos); // ok, maybe it didn't get added to the list somehow?? if (te instanceof TileEntityRBMKBase) { node = makeNode((TileEntityRBMKBase) te); addNode(node); // whoops! - } else - return; // TE no longer exists, die!! + } else { + int hits = getHits(nodePos); // Get the amount of hits on blocks. + if (hits == columnHeight) // If stream is fully blocked. + return; + else if (hits > 0) { // If stream is partially blocked. + irradiateFromFlux(pos, hits); + fluxQuantity *= 1 - ((double) hits / columnHeight); // Inverse to get partial blocking by blocks. + continue; + } else { // Nothing hit! + irradiateFromFlux(pos, 0); + continue; + } + } } if(node.type == RBMKType.OTHER) // pass right on by! continue; - Block block = node.tile.getBlockType(); - - if (!(block instanceof RBMKBase)) { - int hits = getHits(nodePos); // Get the amount of hits on blocks. - if (hits == columnHeight) // If stream is fully blocked. - return; - else if (hits > 0) { // If stream is partially blocked. - irradiateFromFlux(pos, hits); - fluxQuantity *= 1 - ((double) hits / columnHeight); // Inverse to get partial blocking by blocks. - continue; - } else { // Nothing hit! - irradiateFromFlux(pos, 0); - continue; - } - } - // we established earlier during `getNodes()` that they should all be RBMKBase TEs // no issue with casting here! TileEntityRBMKBase nodeTE = node.tile; @@ -186,17 +246,17 @@ public class RBMKHandler { if(!node.hasLid) ChunkRadiationManager.proxy.incrementRad(worldObj, nodePos.getX(), nodePos.getY(), nodePos.getZ(), (float) (this.fluxQuantity * 0.05F)); - if(node.type == RBMKType.MODERATOR) { - moderatedCount += 1; + if (node.type == RBMKHandler.RBMKType.MODERATOR) { + moderatedCount++; moderateStream(); } - if(node.tile instanceof IRBMKFluxReceiver) { - IRBMKFluxReceiver column = ((IRBMKFluxReceiver) nodeTE); - if(node.type == RBMKType.ROD) { - TileEntityRBMKRod rod = ((TileEntityRBMKRod) column); - if(rod.hasRod) { - if(rod.isModerated()) + if (nodeTE instanceof IRBMKFluxReceiver) { + IRBMKFluxReceiver column = (IRBMKFluxReceiver)nodeTE; + if (node.type == RBMKHandler.RBMKType.ROD) { + TileEntityRBMKRod rod = (TileEntityRBMKRod)column; + if (rod.hasRod) { + if (rod.isModerated()) moderateStream(); rod.receiveFlux(this); return; @@ -208,67 +268,54 @@ public class RBMKHandler { return; } } - } - else if(node.type == RBMKType.CONTROL_ROD) { - TileEntityRBMKControl rod = ((TileEntityRBMKControl) nodeTE); - if (rod.level > 0D) - fluxQuantity *= ((TileEntityRBMKControl) nodeTE).getMult(); - else - return; - } - - else if(node.type == RBMKType.REFLECTOR) { - if((origin.tile).isModerated()) - moderatedCount += 1; - if (fluxRatio > 0D && moderatedCount > 0) { - for (int i = 0; i < moderatedCount; i++) { - moderateStream(); // Moderate streams on the way back! - } - } - if(reflectorEfficiency != 1) { - fluxQuantity *= reflectorEfficiency; - } else { - ((TileEntityRBMKRod) originTE).receiveFlux(this); - // this one missing return line was baffling me for half an hour - // "why is this rod jumping to double the flux randomly????" - // because you aren't fucking returning from the function, and it's hitting the reflector after it, you idiot - return; + } else if (node.type == RBMKHandler.RBMKType.CONTROL_ROD) { + TileEntityRBMKControl rod = (TileEntityRBMKControl)nodeTE; + if (rod.level > 0.0D) { + this.fluxQuantity *= rod.getMult(); + totalFluxMod *= rod.getMult(); + continue; } + return; } - else if(node.type == RBMKType.ABSORBER) { - if (absorberEfficiency == 1) - return; // Instantly stop stream processing. - else - fluxQuantity *= absorberEfficiency; + if (node.type == RBMKHandler.RBMKType.REFLECTOR) { + if (this.origin.tile.isModerated()) + moderatedCount++; + if (this.fluxRatio > 0 && moderatedCount > 0) + for (int i = 0; i < moderatedCount; i++) + moderateStream(); + if (totalFluxMod < 1) + this.fluxQuantity *= totalFluxMod; + if (RBMKHandler.reflectorEfficiency != 1.0D) { + this.fluxQuantity *= RBMKHandler.reflectorEfficiency; + continue; + } + ((TileEntityRBMKRod)originTE).receiveFlux(this); + return; + } + if (node.type == RBMKHandler.RBMKType.ABSORBER) { + if (RBMKHandler.absorberEfficiency == 1) + return; + this.fluxQuantity *= RBMKHandler.absorberEfficiency; } } - // Called *after* most streams have returned. - List nodes = getNodes(); - - if(nodes.isEmpty()) // how tf did we get here if its empty + List nodes = getNodes(true); + if (nodes.isEmpty()) return; - // Get the last node in the stream. - RBMKNode lastNode = nodes.get(nodes.size() - 1); + RBMKHandler.RBMKNode lastNode = nodes.get(nodes.size() - 1); - // Block hits don't have to be considered here, since if it's fully blocked it'll return the function before getting here. - if(lastNode.type != RBMKType.REFLECTOR && lastNode.type != RBMKType.ABSORBER && lastNode.type != RBMKType.CONTROL_ROD) { - // Neutrons must not have been caught then! - irradiateFromFlux(new BlockPos(lastNode.tile).add(vector.xCoord, 0, vector.zCoord)); - } + if (lastNode.type != RBMKHandler.RBMKType.REFLECTOR && lastNode.type != RBMKHandler.RBMKType.ABSORBER && lastNode.type != RBMKHandler.RBMKType.CONTROL_ROD) + irradiateFromFlux((new BlockPos(lastNode.tile)).add(this.vector.xCoord, 0.0D, this.vector.zCoord)); - // but oh wait, control rods exist - if(lastNode.type == RBMKType.CONTROL_ROD) { - TileEntityRBMKControl rod = ((TileEntityRBMKControl) lastNode.tile); - // just get level and irradiate based on that - if(rod.getMult() > 0D) { - fluxQuantity = fluxQuantity * rod.getMult(); - irradiateFromFlux(new BlockPos(lastNode.tile).add(vector.xCoord, 0, vector.zCoord)); + if (lastNode.type == RBMKHandler.RBMKType.CONTROL_ROD) { + TileEntityRBMKControl rod = (TileEntityRBMKControl)lastNode.tile; + if (rod.getMult() > 0.0D) { + this.fluxQuantity *= rod.getMult(); + irradiateFromFlux((new BlockPos(lastNode.tile)).add(this.vector.xCoord, 0.0D, this.vector.zCoord)); } - } } @@ -279,8 +326,8 @@ public class RBMKHandler { // holy fucking shit // I have had this one line cause me like tens of problems // I FUCKING HATE THIS - // total count of bugs fixed attributed to this function: 6 - if (!origin.tile.getWorldObj().getBlock(pos.getX(), pos.getY() + h, pos.getZ()).isOpaqueCube()) + // total count of bugs fixed attributed to this function: 10 + if (origin.tile.getWorldObj().getBlock(pos.getX(), pos.getY() + h, pos.getZ()).isOpaqueCube()) hits += 1; } @@ -296,16 +343,20 @@ public class RBMKHandler { } public void moderateStream() { - fluxRatio = fluxRatio * (1 - moderatorEfficiency); + fluxRatio *= (1 - moderatorEfficiency); } } + // List of all stream worlds. + public static HashMap streamWorlds = new HashMap<>(); + + public static void removeAllWorlds() { + streamWorlds.clear(); + } + // HashMap of all RBMK nodes and their positions. protected static HashMap nodeCache = new HashMap<>(); - // List of all active neutron streams. - public static HashMap streams = new HashMap<>(); - public static void addNode(RBMKNode node) { nodeCache.put(new BlockPos(node.tile), node); } @@ -314,26 +365,47 @@ public class RBMKHandler { nodeCache.remove(position); } + public static RBMKNode getNode(BlockPos position) { + return nodeCache.get(position); + } + + public static void removeAllNodes() { + nodeCache.clear(); + } + + static int cacheTime = 40; + static int ticks = 0; + // The big one!! Runs all interactions for neutrons. public static void runAllInteractions() { - for (World worldObj : MinecraftServer.getServer().worldServers) { + for (Entry world : streamWorlds.entrySet()) { + // Gamerule caching because this apparently is kinda slow? // meh, good enough - reflectorEfficiency = 1; //RBMKDials.getReflectorEfficiency(); - absorberEfficiency = 1; //RBMKDials.getAbsorberEfficiency(); - moderatorEfficiency = RBMKDials.getModeratorEfficiency(worldObj); + reflectorEfficiency = 1; //RBMKDials.getReflectorEfficiency(world.worldObj); + absorberEfficiency = 1; //RBMKDials.getAbsorberEfficiency(world.worldObj); + moderatorEfficiency = RBMKDials.getModeratorEfficiency(world.getKey()); + // I hate this. // this broke everything because it was ONE OFF // IT'S NOT THE TOTAL HEIGHT IT'S THE AMOUNT OF BLOCKS ABOVE AAAAAAAAAAAAA - columnHeight = RBMKDials.getColumnHeight(worldObj) + 1; - fluxRange = RBMKDials.getFluxRange(worldObj); - streams.forEach((stream, world) -> { - if (world == worldObj) - // WOO!! - stream.runStreamInteraction(world); - }); + columnHeight = RBMKDials.getColumnHeight(world.getKey()) + 1; + fluxRange = RBMKDials.getFluxRange(world.getKey()); + + for (NeutronStream stream : world.getValue().streams) { + stream.runStreamInteraction(world.getKey()); + } + world.getValue().removeAllStreams(); } - streams.clear(); + + // Freshen the node cache every `cacheTime` ticks to prevent huge RAM usage. + if (ticks >= cacheTime) { + ticks = 0; + for(Entry cachedNode : nodeCache.entrySet()) { + cachedNode.getValue().checkNode(cachedNode.getKey()); + } + } + ticks++; } } diff --git a/src/main/java/com/hbm/items/machine/ItemRBMKLid.java b/src/main/java/com/hbm/items/machine/ItemRBMKLid.java index 1c1490798..c2e215307 100644 --- a/src/main/java/com/hbm/items/machine/ItemRBMKLid.java +++ b/src/main/java/com/hbm/items/machine/ItemRBMKLid.java @@ -2,9 +2,11 @@ package com.hbm.items.machine; import com.hbm.blocks.ModBlocks; import com.hbm.blocks.machine.rbmk.RBMKBase; +import com.hbm.handler.rbmkmk2.RBMKHandler; import com.hbm.items.ModItems; import com.hbm.tileentity.machine.rbmk.TileEntityRBMKBase; +import com.hbm.util.fauxpointtwelve.BlockPos; import net.minecraft.block.Block; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.Blocks; @@ -13,6 +15,8 @@ import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; import net.minecraft.world.World; +import static com.hbm.handler.rbmkmk2.RBMKHandler.getNode; + public class ItemRBMKLid extends Item { @Override @@ -37,7 +41,11 @@ public class ItemRBMKLid extends Item { if(tile.hasLid()) return false; - + + RBMKHandler.RBMKNode node = getNode(new BlockPos(te)); + if (node != null) + node.addLid(); + int meta = RBMKBase.DIR_NORMAL_LID.ordinal(); if(this == ModItems.rbmk_lid_glass) { diff --git a/src/main/java/com/hbm/main/ModEventHandler.java b/src/main/java/com/hbm/main/ModEventHandler.java index bf1e44abb..f6b34c1b8 100644 --- a/src/main/java/com/hbm/main/ModEventHandler.java +++ b/src/main/java/com/hbm/main/ModEventHandler.java @@ -535,6 +535,12 @@ public class ModEventHandler { public void onLoad(WorldEvent.Load event) { BobmazonOfferFactory.init(); } + + @SubscribeEvent + public void onUnload(WorldEvent.Unload event) { + RBMKHandler.removeAllWorlds(); // Remove world from worlds when unloaded to avoid world issues. + RBMKHandler.removeAllNodes(); // Remove all nodes. + } public static boolean didSit = false; public static Field reference = null; @@ -1146,9 +1152,7 @@ public class ModEventHandler { TileEntityMachineRadarNT.updateSystem(); Nodespace.updateNodespace(); // RBMK!!!! - MinecraftServer.getServer().theProfiler.startSection("rbmkHandler_flux_interaction"); RBMKHandler.runAllInteractions(); - MinecraftServer.getServer().theProfiler.endSection(); } } diff --git a/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKBase.java b/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKBase.java index f83fa95c2..d53979773 100644 --- a/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKBase.java +++ b/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKBase.java @@ -22,6 +22,7 @@ import com.hbm.tileentity.IOverpressurable; import com.hbm.tileentity.TileEntityLoadedBase; import com.hbm.tileentity.machine.rbmk.TileEntityRBMKConsole.ColumnType; import com.hbm.util.Compat; +import com.hbm.util.GameRuleHelper; import com.hbm.util.I18nUtil; import com.hbm.util.fauxpointtwelve.BlockPos; import cpw.mods.fml.common.network.NetworkRegistry.TargetPoint; @@ -51,7 +52,7 @@ import java.util.*; * @author hbm * */ -public abstract class TileEntityRBMKBase extends TileEntityLoadedBase implements INBTPacketReceiver, IBufPacketReceiver { +public abstract class TileEntityRBMKBase extends TileEntityLoadedBase implements IBufPacketReceiver { public double heat; @@ -276,22 +277,6 @@ public abstract class TileEntityRBMKBase extends TileEntityLoadedBase implements nbt.setInteger("steam", this.steam); } - @Deprecated - public void networkPack(NBTTagCompound nbt, int range) { - diag = true; - if(!worldObj.isRemote) - PacketDispatcher.wrapper.sendToAllAround(new NBTPacket(nbt, xCoord, yCoord, zCoord), new TargetPoint(this.worldObj.provider.dimensionId, xCoord, yCoord, zCoord, range)); - diag = false; - } - - @Deprecated - public void networkUnpack(NBTTagCompound nbt) { - - diag = true; - this.readFromNBT(nbt); - diag = false; - } - public void networkPackNT(int range) { if(!worldObj.isRemote) PacketDispatcher.wrapper.sendToAllAround(new BufPacket(xCoord, yCoord, zCoord, this), new TargetPoint(this.worldObj.provider.dimensionId, xCoord, yCoord, zCoord, range)); } diff --git a/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKOutgasser.java b/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKOutgasser.java index 95a851736..3b701fc0e 100644 --- a/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKOutgasser.java +++ b/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKOutgasser.java @@ -96,7 +96,7 @@ public class TileEntityRBMKOutgasser extends TileEntityRBMKSlottedBase implement if(canProcess()) { - double efficiency = Math.min((1 - stream.fluxRatio) * 0.8, 1); + double efficiency = Math.min(1 - stream.fluxRatio * 0.8, 1); progress += stream.fluxQuantity * efficiency * RBMKDials.getOutgasserMod(worldObj); diff --git a/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKRod.java b/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKRod.java index ad88de20b..05045ca37 100644 --- a/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKRod.java +++ b/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKRod.java @@ -17,6 +17,7 @@ import com.hbm.util.CompatEnergyControl; import com.hbm.util.ParticleUtil; import api.hbm.tile.IInfoProviderEC; +import com.hbm.util.fauxpointtwelve.BlockPos; import cpw.mods.fml.common.Optional; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -38,6 +39,9 @@ import net.minecraftforge.common.util.ForgeDirection; import java.util.ArrayList; import java.util.List; +import static com.hbm.handler.rbmkmk2.RBMKHandler.addNode; +import static com.hbm.handler.rbmkmk2.RBMKHandler.getNode; + @Optional.InterfaceList({@Optional.Interface(iface = "li.cil.oc.api.network.SimpleComponent", modid = "OpenComputers")}) public class TileEntityRBMKRod extends TileEntityRBMKSlottedBase implements IRBMKFluxReceiver, IRBMKLoadable, SimpleComponent, IInfoProviderEC, CompatHandler.OCComponent { @@ -116,6 +120,8 @@ public class TileEntityRBMKRod extends TileEntityRBMKSlottedBase implements IRBM if(this.heat > 10_000) this.heat = 10_000; + this.markDirty(); + //for spreading, we want the buffered flux to be 0 because we want to know exactly how much gets reflected back this.fluxQuantity = 0; spreadFlux(fluxQuantityOut, fluxRatioOut); @@ -139,7 +145,7 @@ public class TileEntityRBMKRod extends TileEntityRBMKSlottedBase implements IRBM switch(type) { case SLOW: return (this.fluxQuantity * (1 - this.fluxRatio) + Math.min(this.fluxRatio * 0.5, 1)); - case FAST: return (this.fluxQuantity * this.fluxRatio + Math.min((1 - this.fluxRatio) * 0.3, 1)); + case FAST: return (this.fluxQuantity * this.fluxRatio + Math.min(1 - this.fluxRatio * 0.3, 1)); case ANY: return this.fluxQuantity; } @@ -153,16 +159,24 @@ public class TileEntityRBMKRod extends TileEntityRBMKSlottedBase implements IRBM ForgeDirection.WEST }; - protected static NType stream; - public void spreadFlux(double flux, double ratio) { + BlockPos pos = new BlockPos(this); + + RBMKHandler.RBMKNode node; + + if(getNode(pos) == null) { + node = RBMKHandler.makeNode(this); + addNode(node); + } else + node = getNode(pos); + for(ForgeDirection dir : fluxDirs) { Vec3 neutronVector = Vec3.createVectorHelper(dir.offsetX, dir.offsetY, dir.offsetZ); - new NeutronStream(RBMKHandler.makeNode(this), neutronVector, flux, ratio); // Create new neutron streams + new NeutronStream(node, neutronVector, flux, ratio); } } diff --git a/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKSlottedBase.java b/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKSlottedBase.java index 7c6278c84..8fa2d7317 100644 --- a/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKSlottedBase.java +++ b/src/main/java/com/hbm/tileentity/machine/rbmk/TileEntityRBMKSlottedBase.java @@ -134,10 +134,6 @@ public abstract class TileEntityRBMKSlottedBase extends TileEntityRBMKActiveBase PacketDispatcher.wrapper.sendToAllAround(new NBTPacket(nbt, xCoord, yCoord, zCoord), new TargetPoint(this.worldObj.provider.dimensionId, xCoord, yCoord, zCoord, range)); } - public void networkUnpack(NBTTagCompound nbt) { - super.networkUnpack(nbt); - } - public void handleButtonPacket(int value, int meta) { }