From 0daba1a5771c92dbd3526d40b44a14ce35bd7948 Mon Sep 17 00:00:00 2001 From: Calclavia Date: Fri, 20 Jun 2014 16:58:16 -0700 Subject: [PATCH] Patched some sync blocks preventing mechanical concurrent modification --- .../energy/grid/MechanicalNode.java | 667 +++++++++--------- .../mechanical/gear/GearNode.java | 487 ++++++------- .../mechanical/gearshaft/GearShaftNode.java | 195 ++--- 3 files changed, 695 insertions(+), 654 deletions(-) diff --git a/mechanical/src/main/scala/resonantinduction/mechanical/energy/grid/MechanicalNode.java b/mechanical/src/main/scala/resonantinduction/mechanical/energy/grid/MechanicalNode.java index b3309fb0..5015a15e 100644 --- a/mechanical/src/main/scala/resonantinduction/mechanical/energy/grid/MechanicalNode.java +++ b/mechanical/src/main/scala/resonantinduction/mechanical/energy/grid/MechanicalNode.java @@ -17,382 +17,413 @@ import universalelectricity.api.vector.IVectorWorld; import universalelectricity.api.vector.Vector3; import codechicken.multipart.TMultiPart; -/** A mechanical node for mechanical energy. - * - * @author Calclavia, Darkguardsman */ +/** + * A mechanical node for mechanical energy. + * + * @author Calclavia, Darkguardsman + */ public class MechanicalNode implements IMechanicalNode, ISaveObj, IVectorWorld { - /** Is debug enabled for the node */ - public boolean doDebug = false; - /** Used to note that you should trigger a packet update for rotation */ - public boolean markRotationUpdate = false; - public boolean markTorqueUpdate = false; - /** Which section of debug is enabled */ - public int debugCue = 0, maxDebugCue = 1, minDebugCue = 0; - public static final int UPDATE_DEBUG = 0, CONNECTION_DEBUG = 1; - /** Rotational Force */ - public double torque = 0, prevTorque; - /** Rotational speed */ - public double prevAngularVelocity, angularVelocity = 0; - /** Rotational acceleration */ - public float acceleration = 2f; + /** + * Is debug enabled for the node + */ + public boolean doDebug = false; + /** + * Used to note that you should trigger a packet update for rotation + */ + public boolean markRotationUpdate = false; + public boolean markTorqueUpdate = false; + /** + * Which section of debug is enabled + */ + public int debugCue = 0, maxDebugCue = 1, minDebugCue = 0; + public static final int UPDATE_DEBUG = 0, CONNECTION_DEBUG = 1; + /** + * Rotational Force + */ + public double torque = 0, prevTorque; + /** + * Rotational speed + */ + public double prevAngularVelocity, angularVelocity = 0; + /** + * Rotational acceleration + */ + public float acceleration = 2f; - /** The current rotation of the mechanical node. */ - public double renderAngle = 0, prev_angle = 0; - /** Limits the max distance an object can rotate in a single update */ - protected double maxDeltaAngle = Math.toRadians(180); + /** + * The current rotation of the mechanical node. + */ + public double renderAngle = 0, prev_angle = 0; + /** + * Limits the max distance an object can rotate in a single update + */ + protected double maxDeltaAngle = Math.toRadians(180); - protected double load = 2; - protected byte connectionMap = Byte.parseByte("111111", 2); + protected double load = 2; + protected byte connectionMap = Byte.parseByte("111111", 2); - private double power = 0; - private INodeProvider parent; - private long ticks = 0; + private double power = 0; + private INodeProvider parent; + private long ticks = 0; - private final AbstractMap connections = new WeakHashMap(); + private final AbstractMap connections = new WeakHashMap(); - public MechanicalNode(INodeProvider parent) - { - this.setParent(parent); - } + public MechanicalNode(INodeProvider parent) + { + this.setParent(parent); + } - @Override - public MechanicalNode setLoad(double load) - { - this.load = load; - return this; - } + @Override + public MechanicalNode setLoad(double load) + { + this.load = load; + return this; + } - public MechanicalNode setConnection(byte connectionMap) - { - this.connectionMap = connectionMap; - return this; - } + public MechanicalNode setConnection(byte connectionMap) + { + this.connectionMap = connectionMap; + return this; + } - @Override - public double getRadius() - { - return 0.5; - } + @Override + public double getRadius() + { + return 0.5; + } - public void update() - { - update(0.05f); - } + public void update() + { + update(0.05f); + } - @Override - public void update(float deltaTime) - { - ticks++; - if (ticks >= Long.MAX_VALUE) - { - ticks = 1; - } - //temp, TODO find a better way to trigger this - if (ticks % 100 == 0) - { - this.recache(); - } - //----------------------------------- - // Render Update - //----------------------------------- + @Override + public void update(float deltaTime) + { + ticks++; + if (ticks >= Long.MAX_VALUE) + { + ticks = 1; + } + //temp, TODO find a better way to trigger this + if (ticks % 100 == 0) + { + this.recache(); + } + //----------------------------------- + // Render Update + //----------------------------------- - if (angularVelocity >= 0) - { - renderAngle += Math.min(angularVelocity, this.maxDeltaAngle) * deltaTime; - } - else - { - renderAngle += Math.max(angularVelocity, -this.maxDeltaAngle) * deltaTime; - } + if (angularVelocity >= 0) + { + renderAngle += Math.min(angularVelocity, this.maxDeltaAngle) * deltaTime; + } + else + { + renderAngle += Math.max(angularVelocity, -this.maxDeltaAngle) * deltaTime; + } - if (renderAngle % (Math.PI * 2) != renderAngle) - { - revolve(); - renderAngle = renderAngle % (Math.PI * 2); - } + if (renderAngle % (Math.PI * 2) != renderAngle) + { + revolve(); + renderAngle = renderAngle % (Math.PI * 2); + } - //----------------------------------- - // Server side Update - //----------------------------------- - if (world() != null && !world().isRemote) - { - final double acceleration = this.acceleration * deltaTime; + //----------------------------------- + // Server side Update + //----------------------------------- + if (world() != null && !world().isRemote) + { + final double acceleration = this.acceleration * deltaTime; - if (Math.abs(prevAngularVelocity - angularVelocity) > 0.01f) - { - prevAngularVelocity = angularVelocity; - markRotationUpdate = true; - } + if (Math.abs(prevAngularVelocity - angularVelocity) > 0.01f) + { + prevAngularVelocity = angularVelocity; + markRotationUpdate = true; + } - if (Math.abs(prevTorque - torque) > 0.01f) - { - prevTorque = torque; - markTorqueUpdate = true; - } + if (Math.abs(prevTorque - torque) > 0.01f) + { + prevTorque = torque; + markTorqueUpdate = true; + } - //----------------------------------- - // Loss calculations - //----------------------------------- - double torqueLoss = Math.min(Math.abs(getTorque()), (Math.abs(getTorque() * getTorqueLoad()) + getTorqueLoad() / 10) * deltaTime); - torque += torque > 0 ? -torqueLoss : torqueLoss; + //----------------------------------- + // Loss calculations + //----------------------------------- + double torqueLoss = Math.min(Math.abs(getTorque()), (Math.abs(getTorque() * getTorqueLoad()) + getTorqueLoad() / 10) * deltaTime); + torque += torque > 0 ? -torqueLoss : torqueLoss; - double velocityLoss = Math.min(Math.abs(getAngularSpeed()), (Math.abs(getAngularSpeed() * getAngularVelocityLoad()) + getAngularVelocityLoad() / 10) * deltaTime); - angularVelocity += angularVelocity > 0 ? -velocityLoss : velocityLoss; + double velocityLoss = Math.min(Math.abs(getAngularSpeed()), (Math.abs(getAngularSpeed() * getAngularVelocityLoad()) + getAngularVelocityLoad() / 10) * deltaTime); + angularVelocity += angularVelocity > 0 ? -velocityLoss : velocityLoss; - if (getEnergy() <= 0) - { - angularVelocity = torque = 0; - } + if (getEnergy() <= 0) + { + angularVelocity = torque = 0; + } - power = getEnergy() / deltaTime; + power = getEnergy() / deltaTime; - //----------------------------------- - // Connection application of force and speed - //----------------------------------- - synchronized (getConnections()) - { - Iterator> it = getConnections().entrySet().iterator(); + //----------------------------------- + // Connection application of force and speed + //----------------------------------- + synchronized (getConnections()) + { + Iterator> it = getConnections().entrySet().iterator(); - while (it.hasNext()) - { - Entry entry = it.next(); + while (it.hasNext()) + { + Entry entry = it.next(); - ForgeDirection dir = entry.getValue(); - MechanicalNode adjacentMech = entry.getKey(); - /** Calculate angular velocity and torque. */ - float ratio = adjacentMech.getRatio(dir.getOpposite(), this) / getRatio(dir, adjacentMech); - boolean inverseRotation = inverseRotation(dir, adjacentMech) && adjacentMech.inverseRotation(dir.getOpposite(), this); + ForgeDirection dir = entry.getValue(); + MechanicalNode adjacentMech = entry.getKey(); + /** Calculate angular velocity and torque. */ + float ratio = adjacentMech.getRatio(dir.getOpposite(), this) / getRatio(dir, adjacentMech); + boolean inverseRotation = inverseRotation(dir, adjacentMech) && adjacentMech.inverseRotation(dir.getOpposite(), this); - int inversion = inverseRotation ? -1 : 1; + int inversion = inverseRotation ? -1 : 1; - double targetTorque = inversion * adjacentMech.getTorque() / ratio; - double applyTorque = targetTorque * acceleration; + double targetTorque = inversion * adjacentMech.getTorque() / ratio; + double applyTorque = targetTorque * acceleration; - if (Math.abs(torque + applyTorque) < Math.abs(targetTorque)) - { - torque += applyTorque; - } - else if (Math.abs(torque - applyTorque) > Math.abs(targetTorque)) - { - torque -= applyTorque; - } + if (Math.abs(torque + applyTorque) < Math.abs(targetTorque)) + { + torque += applyTorque; + } + else if (Math.abs(torque - applyTorque) > Math.abs(targetTorque)) + { + torque -= applyTorque; + } - double targetVelocity = inversion * adjacentMech.getAngularSpeed() * ratio; - double applyVelocity = targetVelocity * acceleration; + double targetVelocity = inversion * adjacentMech.getAngularSpeed() * ratio; + double applyVelocity = targetVelocity * acceleration; - if (Math.abs(angularVelocity + applyVelocity) < Math.abs(targetVelocity)) - { - angularVelocity += applyVelocity; - } - else if (Math.abs(angularVelocity - applyVelocity) > Math.abs(targetVelocity)) - { - angularVelocity -= applyVelocity; - } + if (Math.abs(angularVelocity + applyVelocity) < Math.abs(targetVelocity)) + { + angularVelocity += applyVelocity; + } + else if (Math.abs(angularVelocity - applyVelocity) > Math.abs(targetVelocity)) + { + angularVelocity -= applyVelocity; + } - /** Set all current rotations */ - // adjacentMech.angle = Math.abs(angle) * (adjacentMech.angle >= 0 ? 1 : -1); - } - } - } + /** Set all current rotations */ + // adjacentMech.angle = Math.abs(angle) * (adjacentMech.angle >= 0 ? 1 : -1); + } + } + } - onUpdate(); - prev_angle = renderAngle; - } + onUpdate(); + prev_angle = renderAngle; + } - protected void onUpdate() - { + protected void onUpdate() + { - } + } - /** Called when one revolution is made. */ - protected void revolve() - { + /** + * Called when one revolution is made. + */ + protected void revolve() + { - } + } - @Override - public void apply(Object source, double torque, double angularVelocity) - { - this.torque += torque; - this.angularVelocity += angularVelocity; - } + @Override + public void apply(Object source, double torque, double angularVelocity) + { + this.torque += torque; + this.angularVelocity += angularVelocity; + } - @Override - public double getTorque() - { - return angularVelocity != 0 ? torque : 0; - } + @Override + public double getTorque() + { + return angularVelocity != 0 ? torque : 0; + } - @Override - public double getAngularSpeed() - { - return torque != 0 ? angularVelocity : 0; - } + @Override + public double getAngularSpeed() + { + return torque != 0 ? angularVelocity : 0; + } - @Override - public float getRatio(ForgeDirection dir, IMechanicalNode with) - { - return 0.5f; - } + @Override + public float getRatio(ForgeDirection dir, IMechanicalNode with) + { + return 0.5f; + } - @Override - public boolean inverseRotation(ForgeDirection dir, IMechanicalNode with) - { - return true; - } + @Override + public boolean inverseRotation(ForgeDirection dir, IMechanicalNode with) + { + return true; + } - /** The energy percentage loss due to resistance in seconds. */ - public double getTorqueLoad() - { - return load; - } + /** + * The energy percentage loss due to resistance in seconds. + */ + public double getTorqueLoad() + { + return load; + } - public double getAngularVelocityLoad() - { - return load; - } + public double getAngularVelocityLoad() + { + return load; + } - /** Checks to see if a connection is allowed from side and from a source */ - public boolean canConnect(ForgeDirection from, Object source) - { - if (source instanceof MechanicalNode) - { - boolean flag = (connectionMap & (1 << from.ordinal())) != 0; - return flag; - } - return false; - } + /** + * Checks to see if a connection is allowed from side and from a source + */ + public boolean canConnect(ForgeDirection from, Object source) + { + if (source instanceof MechanicalNode) + { + boolean flag = (connectionMap & (1 << from.ordinal())) != 0; + return flag; + } + return false; + } - @Override - public double getEnergy() - { - return getTorque() * getAngularSpeed(); - } + @Override + public double getEnergy() + { + return getTorque() * getAngularSpeed(); + } - @Override - public double getPower() - { - return power; - } + @Override + public double getPower() + { + return power; + } - @Override - public void load(NBTTagCompound nbt) - { - torque = nbt.getDouble("torque"); - angularVelocity = nbt.getDouble("angularVelocity"); - } + @Override + public void load(NBTTagCompound nbt) + { + torque = nbt.getDouble("torque"); + angularVelocity = nbt.getDouble("angularVelocity"); + } - @Override - public void save(NBTTagCompound nbt) - { - nbt.setDouble("torque", torque); - nbt.setDouble("angularVelocity", angularVelocity); - } + @Override + public void save(NBTTagCompound nbt) + { + nbt.setDouble("torque", torque); + nbt.setDouble("angularVelocity", angularVelocity); + } - @Override - public void reconstruct() - { - recache(); - } + @Override + public void reconstruct() + { + recache(); + } - @Override - public void deconstruct() - { - for (Entry entry : getConnections().entrySet()) - { - entry.getKey().getConnections().remove(this); - entry.getKey().recache(); - } - getConnections().clear(); - } + @Override + public void deconstruct() + { + for (Entry entry : getConnections().entrySet()) + { + entry.getKey().getConnections().remove(this); + entry.getKey().recache(); + } + getConnections().clear(); + } - @Override - public void recache() - { - getConnections().clear(); + @Override + public void recache() + { + synchronized (this) + { + getConnections().clear(); - for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) - { - TileEntity tile = position().translate(dir).getTileEntity(world()); - if (tile instanceof INodeProvider) - { - INode node = ((INodeProvider) tile).getNode(MechanicalNode.class, dir.getOpposite()); - if (node instanceof MechanicalNode) - { - MechanicalNode check = (MechanicalNode) node; - boolean canConnect = canConnect(dir, check); - boolean canOtherConnect = check.canConnect(dir.getOpposite(), this); - if (canConnect && canOtherConnect) - { - getConnections().put(check, dir); - } - } - } - } - } + for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) + { + TileEntity tile = position().translate(dir).getTileEntity(world()); + if (tile instanceof INodeProvider) + { + INode node = ((INodeProvider) tile).getNode(MechanicalNode.class, dir.getOpposite()); + if (node instanceof MechanicalNode) + { + MechanicalNode check = (MechanicalNode) node; + boolean canConnect = canConnect(dir, check); + boolean canOtherConnect = check.canConnect(dir.getOpposite(), this); + if (canConnect && canOtherConnect) + { + getConnections().put(check, dir); + } + } + } + } + } + } - /** Gets the node provider for this node */ - public INodeProvider getParent() - { - return parent; - } + /** + * Gets the node provider for this node + */ + public INodeProvider getParent() + { + return parent; + } - /** Sets the node provider for the node */ - public void setParent(INodeProvider parent) - { - this.parent = parent; - } + /** + * Sets the node provider for the node + */ + public void setParent(INodeProvider parent) + { + this.parent = parent; + } - @Override - public String toString() - { - return this.getClass().getSimpleName() + this.hashCode(); - } + @Override + public String toString() + { + return this.getClass().getSimpleName() + this.hashCode(); + } - public AbstractMap getConnections() - { - return connections; - } + public AbstractMap getConnections() + { + return connections; + } - @Override - public World world() - { - return getParent() instanceof TMultiPart ? ((TMultiPart) getParent()).world() : getParent() instanceof TileEntity ? ((TileEntity) getParent()).getWorldObj() : null; - } + @Override + public World world() + { + return getParent() instanceof TMultiPart ? ((TMultiPart) getParent()).world() : getParent() instanceof TileEntity ? ((TileEntity) getParent()).getWorldObj() : null; + } - public Vector3 position() - { - return new Vector3(x(), y(), z()); - } + public Vector3 position() + { + return new Vector3(x(), y(), z()); + } - @Override - public double z() - { - if(this.getParent() instanceof TileEntity) - { - return ((TileEntity)this.getParent()).zCoord; - } - return this.getParent() instanceof TMultiPart && ((TMultiPart) this.getParent()).tile() != null ? ((TMultiPart) this.getParent()).z() : 0; - } + @Override + public double z() + { + if (this.getParent() instanceof TileEntity) + { + return ((TileEntity) this.getParent()).zCoord; + } + return this.getParent() instanceof TMultiPart && ((TMultiPart) this.getParent()).tile() != null ? ((TMultiPart) this.getParent()).z() : 0; + } - @Override - public double x() - { - if(this.getParent() instanceof TileEntity) - { - return ((TileEntity)this.getParent()).xCoord; - } - return this.getParent() instanceof TMultiPart && ((TMultiPart) this.getParent()).tile() != null ? ((TMultiPart) this.getParent()).x() : 0; - } + @Override + public double x() + { + if (this.getParent() instanceof TileEntity) + { + return ((TileEntity) this.getParent()).xCoord; + } + return this.getParent() instanceof TMultiPart && ((TMultiPart) this.getParent()).tile() != null ? ((TMultiPart) this.getParent()).x() : 0; + } - @Override - public double y() - { - if(this.getParent() instanceof TileEntity) - { - return ((TileEntity)this.getParent()).yCoord; - } - return this.getParent() instanceof TMultiPart && ((TMultiPart) this.getParent()).tile() != null ? ((TMultiPart) this.getParent()).y() : 0; - } + @Override + public double y() + { + if (this.getParent() instanceof TileEntity) + { + return ((TileEntity) this.getParent()).yCoord; + } + return this.getParent() instanceof TMultiPart && ((TMultiPart) this.getParent()).tile() != null ? ((TMultiPart) this.getParent()).y() : 0; + } } diff --git a/mechanical/src/main/scala/resonantinduction/mechanical/gear/GearNode.java b/mechanical/src/main/scala/resonantinduction/mechanical/gear/GearNode.java index 7a404b6e..e7055f88 100644 --- a/mechanical/src/main/scala/resonantinduction/mechanical/gear/GearNode.java +++ b/mechanical/src/main/scala/resonantinduction/mechanical/gear/GearNode.java @@ -10,283 +10,290 @@ import codechicken.lib.vec.Rotation; import codechicken.multipart.TMultiPart; import codechicken.multipart.TileMultipart; -/** Node for the gear - * - * @author Calclavia, Edited by: Darkguardsman */ +/** + * Node for the gear + * + * @author Calclavia, Edited by: Darkguardsman + */ public class GearNode extends MechanicalNode { - public GearNode(PartGear parent) - { - super(parent); - } + public GearNode(PartGear parent) + { + super(parent); + } - protected PartGear gear() - { - return (PartGear) this.getParent(); - } + protected PartGear gear() + { + return (PartGear) this.getParent(); + } - @Override - public void onUpdate() - { - super.onUpdate(); - if (!gear().getMultiBlock().isPrimary()) - { - torque = 0; - angularVelocity = 0; - } - else - { - if (gear().tier == 10) - { - torque = 100; - angularVelocity = 100; - } - } - } + @Override + public void onUpdate() + { + super.onUpdate(); + if (!gear().getMultiBlock().isPrimary()) + { + torque = 0; + angularVelocity = 0; + } + else + { + if (gear().tier == 10) + { + torque = 100; + angularVelocity = 100; + } + } + } - @Override - public double getTorqueLoad() - { - // Decelerate the gear based on tier. - switch (gear().tier) - { - default: - return 0.3; - case 1: - return 0.2; - case 2: - return 0.1; - case 10: - return 0; - } - } + @Override + public double getTorqueLoad() + { + // Decelerate the gear based on tier. + switch (gear().tier) + { + default: + return 0.3; + case 1: + return 0.2; + case 2: + return 0.1; + case 10: + return 0; + } + } - @Override - public double getAngularVelocityLoad() - { - // Decelerate the gear based on tier. - switch (gear().tier) - { - default: - return 0.03; - case 1: - return 0.02; - case 2: - return 0.01; - case 10: - return 0; - } - } + @Override + public double getAngularVelocityLoad() + { + // Decelerate the gear based on tier. + switch (gear().tier) + { + default: + return 0.03; + case 1: + return 0.02; + case 2: + return 0.01; + case 10: + return 0; + } + } - @Override - public void recache() - { - getConnections().clear(); + @Override + public void recache() + { + synchronized (this) + { + getConnections().clear(); - /** Only call refresh if this is the main block of a multiblock gear or a single gear block. */ - if (!gear().getMultiBlock().isPrimary() || world() == null) - { - return; - } + /** Only call refresh if this is the main block of a multiblock gear or a single gear block. */ + if (!gear().getMultiBlock().isPrimary() || world() == null) + { + return; + } - /** Look for gears that are back-to-back with this gear. Equate torque. */ - TileEntity tileBehind = new universalelectricity.api.vector.Vector3(gear().tile()).translate(gear().placementSide).getTileEntity(world()); + /** Look for gears that are back-to-back with this gear. Equate torque. */ + TileEntity tileBehind = new universalelectricity.api.vector.Vector3(gear().tile()).translate(gear().placementSide).getTileEntity(world()); - if (tileBehind instanceof INodeProvider) - { - MechanicalNode instance = (MechanicalNode) ((INodeProvider) tileBehind).getNode(MechanicalNode.class, gear().placementSide.getOpposite()); + if (tileBehind instanceof INodeProvider) + { + MechanicalNode instance = (MechanicalNode) ((INodeProvider) tileBehind).getNode(MechanicalNode.class, gear().placementSide.getOpposite()); - if (instance != null && instance != this && !(instance.getParent() instanceof PartGearShaft) && instance.canConnect(gear().placementSide.getOpposite(), this)) - { - getConnections().put(instance, gear().placementSide); - } - } + if (instance != null && instance != this && !(instance.getParent() instanceof PartGearShaft) && instance.canConnect(gear().placementSide.getOpposite(), this)) + { + getConnections().put(instance, gear().placementSide); + } + } - /** Look for gears that are internal and adjacent to this gear. (The 4 sides + the internal - * center) */ - for (int i = 0; i < 6; i++) - { - ForgeDirection checkDir = ForgeDirection.getOrientation(i); + /** Look for gears that are internal and adjacent to this gear. (The 4 sides + the internal + * center) */ + for (int i = 0; i < 6; i++) + { + ForgeDirection checkDir = ForgeDirection.getOrientation(i); - TileEntity tile = gear().tile(); + TileEntity tile = gear().tile(); - if (gear().getMultiBlock().isConstructed() && checkDir != gear().placementSide && checkDir != gear().placementSide.getOpposite()) - { - tile = new universalelectricity.api.vector.Vector3(gear().tile()).translate(checkDir).getTileEntity(world()); - } + if (gear().getMultiBlock().isConstructed() && checkDir != gear().placementSide && checkDir != gear().placementSide.getOpposite()) + { + tile = new universalelectricity.api.vector.Vector3(gear().tile()).translate(checkDir).getTileEntity(world()); + } - if (tile instanceof INodeProvider) - { - /** If we're checking for the block that is opposite to the gear's placement side - * (the center), then we try to look for a gear shaft in the center. */ - MechanicalNode instance = (MechanicalNode) ((INodeProvider) tile).getNode(MechanicalNode.class, checkDir == gear().placementSide.getOpposite() ? ForgeDirection.UNKNOWN : checkDir); + if (tile instanceof INodeProvider) + { + /** If we're checking for the block that is opposite to the gear's placement side + * (the center), then we try to look for a gear shaft in the center. */ + MechanicalNode instance = (MechanicalNode) ((INodeProvider) tile).getNode(MechanicalNode.class, checkDir == gear().placementSide.getOpposite() ? ForgeDirection.UNKNOWN : checkDir); - if (!getConnections().containsValue(checkDir) && instance != this && checkDir != gear().placementSide && instance != null && instance.canConnect(checkDir.getOpposite(), this)) - { - getConnections().put(instance, checkDir); - } - } - } + if (!getConnections().containsValue(checkDir) && instance != this && checkDir != gear().placementSide && instance != null && instance.canConnect(checkDir.getOpposite(), this)) + { + getConnections().put(instance, checkDir); + } + } + } - int displaceCheck = 1; + int displaceCheck = 1; - if (gear().getMultiBlock().isPrimary() && gear().getMultiBlock().isConstructed()) - { - displaceCheck = 2; - } + if (gear().getMultiBlock().isPrimary() && gear().getMultiBlock().isConstructed()) + { + displaceCheck = 2; + } - /** Look for gears outside this block space, the relative UP, DOWN, LEFT, RIGHT */ - for (int i = 0; i < 4; i++) - { - ForgeDirection checkDir = ForgeDirection.getOrientation(Rotation.rotateSide(gear().placementSide.ordinal(), i)); - TileEntity checkTile = new universalelectricity.api.vector.Vector3(gear().tile()).translate(checkDir, displaceCheck).getTileEntity(world()); + /** Look for gears outside this block space, the relative UP, DOWN, LEFT, RIGHT */ + for (int i = 0; i < 4; i++) + { + ForgeDirection checkDir = ForgeDirection.getOrientation(Rotation.rotateSide(gear().placementSide.ordinal(), i)); + TileEntity checkTile = new universalelectricity.api.vector.Vector3(gear().tile()).translate(checkDir, displaceCheck).getTileEntity(world()); - if (!getConnections().containsValue(checkDir) && checkTile instanceof INodeProvider) - { - MechanicalNode instance = (MechanicalNode) ((INodeProvider) checkTile).getNode(MechanicalNode.class, gear().placementSide); + if (!getConnections().containsValue(checkDir) && checkTile instanceof INodeProvider) + { + MechanicalNode instance = (MechanicalNode) ((INodeProvider) checkTile).getNode(MechanicalNode.class, gear().placementSide); - if (instance != null && instance != this && instance.canConnect(checkDir.getOpposite(), this) && !(instance.getParent() instanceof PartGearShaft)) - { - getConnections().put(instance, checkDir); - } - } - } - } + if (instance != null && instance != this && instance.canConnect(checkDir.getOpposite(), this) && !(instance.getParent() instanceof PartGearShaft)) + { + getConnections().put(instance, checkDir); + } + } + } + } + } - /** Can this gear be connected BY the source? - * - * @param from - Direction source is coming from. - * @param with - The source of the connection. - * @return True is so. */ - @Override - public boolean canConnect(ForgeDirection from, Object with) - { - if (!gear().getMultiBlock().isPrimary()) - { - return false; - } + /** + * Can this gear be connected BY the source? + * + * @param from - Direction source is coming from. + * @param with - The source of the connection. + * @return True is so. + */ + @Override + public boolean canConnect(ForgeDirection from, Object with) + { + if (!gear().getMultiBlock().isPrimary()) + { + return false; + } - if (with instanceof MechanicalNode) - { - INodeProvider parent = ((MechanicalNode) with).getParent(); + if (with instanceof MechanicalNode) + { + INodeProvider parent = ((MechanicalNode) with).getParent(); - /** Check for flat connections (gear face on gear face) to make sure it's actually on - * this gear block. */ - if (from == gear().placementSide.getOpposite()) - { - if (parent instanceof PartGear || parent instanceof PartGearShaft) - { - if (parent instanceof PartGearShaft) - { - PartGearShaft shaft = (PartGearShaft) parent; - return shaft.tile().partMap(from.getOpposite().ordinal()) == gear() && Math.abs(shaft.placementSide.offsetX) == Math.abs(gear().placementSide.offsetX) && Math.abs(shaft.placementSide.offsetY) == Math.abs(gear().placementSide.offsetY) && Math.abs(shaft.placementSide.offsetZ) == Math.abs(gear().placementSide.offsetZ); - } - else if (parent instanceof PartGear) - { - if (((PartGear) parent).tile() == gear().tile() && !gear().getMultiBlock().isConstructed()) - { - return true; - } + /** Check for flat connections (gear face on gear face) to make sure it's actually on + * this gear block. */ + if (from == gear().placementSide.getOpposite()) + { + if (parent instanceof PartGear || parent instanceof PartGearShaft) + { + if (parent instanceof PartGearShaft) + { + PartGearShaft shaft = (PartGearShaft) parent; + return shaft.tile().partMap(from.getOpposite().ordinal()) == gear() && Math.abs(shaft.placementSide.offsetX) == Math.abs(gear().placementSide.offsetX) && Math.abs(shaft.placementSide.offsetY) == Math.abs(gear().placementSide.offsetY) && Math.abs(shaft.placementSide.offsetZ) == Math.abs(gear().placementSide.offsetZ); + } + else if (parent instanceof PartGear) + { + if (((PartGear) parent).tile() == gear().tile() && !gear().getMultiBlock().isConstructed()) + { + return true; + } - if (((PartGear) parent).placementSide != gear().placementSide) - { - TMultiPart part = gear().tile().partMap(((PartGear) parent).placementSide.ordinal()); + if (((PartGear) parent).placementSide != gear().placementSide) + { + TMultiPart part = gear().tile().partMap(((PartGear) parent).placementSide.ordinal()); - if (part instanceof PartGear) - { - /** Case when we connect gears via edges internally. Large gear - * attempt to connect to small gear. */ - PartGear sourceGear = (PartGear) part; + if (part instanceof PartGear) + { + /** Case when we connect gears via edges internally. Large gear + * attempt to connect to small gear. */ + PartGear sourceGear = (PartGear) part; - if (sourceGear.isCenterMultiBlock() && !sourceGear.getMultiBlock().isPrimary()) - { - // For large gear to small gear on edge connection. - return true; - } - } - else - { - /** Small gear attempting to connect to large gear. */ - if (gear().getMultiBlock().isConstructed()) - { - TMultiPart checkPart = ((PartGear) parent).tile().partMap(gear().placementSide.ordinal()); + if (sourceGear.isCenterMultiBlock() && !sourceGear.getMultiBlock().isPrimary()) + { + // For large gear to small gear on edge connection. + return true; + } + } + else + { + /** Small gear attempting to connect to large gear. */ + if (gear().getMultiBlock().isConstructed()) + { + TMultiPart checkPart = ((PartGear) parent).tile().partMap(gear().placementSide.ordinal()); - if (checkPart instanceof PartGear) - { - ForgeDirection requiredDirection = ((PartGear) checkPart).getPosition().subtract(position()).toForgeDirection(); - return ((PartGear) checkPart).isCenterMultiBlock() && ((PartGear) parent).placementSide == requiredDirection; - } - } - } - } - } - } + if (checkPart instanceof PartGear) + { + ForgeDirection requiredDirection = ((PartGear) checkPart).getPosition().subtract(position()).toForgeDirection(); + return ((PartGear) checkPart).isCenterMultiBlock() && ((PartGear) parent).placementSide == requiredDirection; + } + } + } + } + } + } - /** Face to face stick connection. */ - TileEntity sourceTile = position().translate(from.getOpposite()).getTileEntity(world()); + /** Face to face stick connection. */ + TileEntity sourceTile = position().translate(from.getOpposite()).getTileEntity(world()); - if (sourceTile instanceof INodeProvider) - { - MechanicalNode sourceInstance = (MechanicalNode) ((INodeProvider) sourceTile).getNode(MechanicalNode.class, from); - return sourceInstance == with; - } - } - else if (from == gear().placementSide) - { - /** Face to face stick connection. */ - TileEntity sourceTile = position().translate(from).getTileEntity(world()); + if (sourceTile instanceof INodeProvider) + { + MechanicalNode sourceInstance = (MechanicalNode) ((INodeProvider) sourceTile).getNode(MechanicalNode.class, from); + return sourceInstance == with; + } + } + else if (from == gear().placementSide) + { + /** Face to face stick connection. */ + TileEntity sourceTile = position().translate(from).getTileEntity(world()); - if (sourceTile instanceof INodeProvider) - { - MechanicalNode sourceInstance = (MechanicalNode) ((INodeProvider) sourceTile).getNode(MechanicalNode.class, from.getOpposite()); - return sourceInstance == with; - } - } - else - { - TileEntity destinationTile = ((MechanicalNode) with).position().translate(from.getOpposite()).getTileEntity(world()); + if (sourceTile instanceof INodeProvider) + { + MechanicalNode sourceInstance = (MechanicalNode) ((INodeProvider) sourceTile).getNode(MechanicalNode.class, from.getOpposite()); + return sourceInstance == with; + } + } + else + { + TileEntity destinationTile = ((MechanicalNode) with).position().translate(from.getOpposite()).getTileEntity(world()); - if (destinationTile instanceof INodeProvider && destinationTile instanceof TileMultipart) - { - TMultiPart destinationPart = ((TileMultipart) destinationTile).partMap(gear().placementSide.ordinal()); + if (destinationTile instanceof INodeProvider && destinationTile instanceof TileMultipart) + { + TMultiPart destinationPart = ((TileMultipart) destinationTile).partMap(gear().placementSide.ordinal()); - if (destinationPart instanceof PartGear) - { - if (gear() != destinationPart) - { - return ((PartGear) destinationPart).isCenterMultiBlock(); - } - else - { - return true; - } - } - else - { - return true; - } - } - } - } + if (destinationPart instanceof PartGear) + { + if (gear() != destinationPart) + { + return ((PartGear) destinationPart).isCenterMultiBlock(); + } + else + { + return true; + } + } + else + { + return true; + } + } + } + } - return false; - } + return false; + } - @Override - public float getRatio(ForgeDirection dir, IMechanicalNode with) - { - universalelectricity.api.vector.Vector3 deltaPos = with.position().subtract(position()); + @Override + public float getRatio(ForgeDirection dir, IMechanicalNode with) + { + universalelectricity.api.vector.Vector3 deltaPos = with.position().subtract(position()); - boolean caseX = gear().placementSide.offsetX != 0 && deltaPos.y == 0 && deltaPos.z == 0; - boolean caseY = gear().placementSide.offsetY != 0 && deltaPos.x == 0 && deltaPos.z == 0; - boolean caseZ = gear().placementSide.offsetZ != 0 && deltaPos.x == 0 && deltaPos.y == 0; + boolean caseX = gear().placementSide.offsetX != 0 && deltaPos.y == 0 && deltaPos.z == 0; + boolean caseY = gear().placementSide.offsetY != 0 && deltaPos.x == 0 && deltaPos.z == 0; + boolean caseZ = gear().placementSide.offsetZ != 0 && deltaPos.x == 0 && deltaPos.y == 0; - if (caseX || caseY || caseZ) - { - return super.getRatio(dir, with); - } + if (caseX || caseY || caseZ) + { + return super.getRatio(dir, with); + } - return gear().getMultiBlock().isConstructed() ? 1.5f : super.getRatio(dir, with); - } + return gear().getMultiBlock().isConstructed() ? 1.5f : super.getRatio(dir, with); + } } diff --git a/mechanical/src/main/scala/resonantinduction/mechanical/gearshaft/GearShaftNode.java b/mechanical/src/main/scala/resonantinduction/mechanical/gearshaft/GearShaftNode.java index 6ab2ca3d..91c54645 100644 --- a/mechanical/src/main/scala/resonantinduction/mechanical/gearshaft/GearShaftNode.java +++ b/mechanical/src/main/scala/resonantinduction/mechanical/gearshaft/GearShaftNode.java @@ -14,113 +14,116 @@ import universalelectricity.api.vector.Vector3; public class GearShaftNode extends MechanicalNode { - public GearShaftNode(PartGearShaft parent) - { - super(parent); - } + public GearShaftNode(PartGearShaft parent) + { + super(parent); + } - @Override - public double getTorqueLoad() - { - // Decelerate the gear based on tier. - switch (shaft().tier) - { - default: - return 0.03; - case 1: - return 0.02; - case 2: - return 0.01; - } - } + @Override + public double getTorqueLoad() + { + // Decelerate the gear based on tier. + switch (shaft().tier) + { + default: + return 0.03; + case 1: + return 0.02; + case 2: + return 0.01; + } + } - @Override - public double getAngularVelocityLoad() - { - return 0; - } + @Override + public double getAngularVelocityLoad() + { + return 0; + } - @Override - public void recache() - { - getConnections().clear(); - List dirs = new ArrayList(); - dirs.add(shaft().placementSide); - dirs.add(shaft().placementSide.getOpposite()); - /** Check for internal connections, the FRONT and BACK. */ - Iterator it = dirs.iterator(); - while (it.hasNext()) - { - ForgeDirection checkDir = it.next(); - if (checkDir == shaft().placementSide || checkDir == shaft().placementSide.getOpposite()) - { - if (shaft().tile() instanceof INodeProvider) - { - MechanicalNode instance = (MechanicalNode) ((INodeProvider) shaft().tile()).getNode(MechanicalNode.class, checkDir); + @Override + public void recache() + { + synchronized (this) + { + getConnections().clear(); + List dirs = new ArrayList(); + dirs.add(shaft().placementSide); + dirs.add(shaft().placementSide.getOpposite()); + /** Check for internal connections, the FRONT and BACK. */ + Iterator it = dirs.iterator(); + while (it.hasNext()) + { + ForgeDirection checkDir = it.next(); + if (checkDir == shaft().placementSide || checkDir == shaft().placementSide.getOpposite()) + { + if (shaft().tile() instanceof INodeProvider) + { + MechanicalNode instance = (MechanicalNode) ((INodeProvider) shaft().tile()).getNode(MechanicalNode.class, checkDir); - if (instance != null && instance != this && instance.canConnect(checkDir.getOpposite(), this)) - { - getConnections().put(instance, checkDir); - it.remove(); - } - } - } - } + if (instance != null && instance != this && instance.canConnect(checkDir.getOpposite(), this)) + { + getConnections().put(instance, checkDir); + it.remove(); + } + } + } + } - /** Look for connections outside this block space, the relative FRONT and BACK */ - if (!dirs.isEmpty()) - for (ForgeDirection checkDir : dirs) - { - if (!getConnections().containsValue(checkDir) && (checkDir == shaft().placementSide || checkDir == shaft().placementSide.getOpposite())) - { - TileEntity checkTile = new Vector3(shaft().tile()).translate(checkDir).getTileEntity(world()); + /** Look for connections outside this block space, the relative FRONT and BACK */ + if (!dirs.isEmpty()) + for (ForgeDirection checkDir : dirs) + { + if (!getConnections().containsValue(checkDir) && (checkDir == shaft().placementSide || checkDir == shaft().placementSide.getOpposite())) + { + TileEntity checkTile = new Vector3(shaft().tile()).translate(checkDir).getTileEntity(world()); - if (checkTile instanceof INodeProvider) - { - MechanicalNode instance = (MechanicalNode) ((INodeProvider) checkTile).getNode(MechanicalNode.class, checkDir.getOpposite()); + if (checkTile instanceof INodeProvider) + { + MechanicalNode instance = (MechanicalNode) ((INodeProvider) checkTile).getNode(MechanicalNode.class, checkDir.getOpposite()); - // Only connect to shafts outside of this block space. - if (instance != null && instance != this && instance.getParent() instanceof PartGearShaft && instance.canConnect(checkDir.getOpposite(), this)) - { - getConnections().put(instance, checkDir); - } - } - } - } - } + // Only connect to shafts outside of this block space. + if (instance != null && instance != this && instance.getParent() instanceof PartGearShaft && instance.canConnect(checkDir.getOpposite(), this)) + { + getConnections().put(instance, checkDir); + } + } + } + } + } + } - @Override - public boolean canConnect(ForgeDirection from, Object source) - { - if (source instanceof MechanicalNode) - { - if (((MechanicalNode) source).getParent() instanceof PartGear) - { - PartGear gear = (PartGear) ((MechanicalNode) source).getParent(); + @Override + public boolean canConnect(ForgeDirection from, Object source) + { + if (source instanceof MechanicalNode) + { + if (((MechanicalNode) source).getParent() instanceof PartGear) + { + PartGear gear = (PartGear) ((MechanicalNode) source).getParent(); - if (!(Math.abs(gear.placementSide.offsetX) == Math.abs(shaft().placementSide.offsetX) && Math.abs(gear.placementSide.offsetY) == Math.abs(shaft().placementSide.offsetY) && Math.abs(gear.placementSide.offsetZ) == Math.abs(shaft().placementSide.offsetZ))) - { - return false; - } - } - } + if (!(Math.abs(gear.placementSide.offsetX) == Math.abs(shaft().placementSide.offsetX) && Math.abs(gear.placementSide.offsetY) == Math.abs(shaft().placementSide.offsetY) && Math.abs(gear.placementSide.offsetZ) == Math.abs(shaft().placementSide.offsetZ))) + { + return false; + } + } + } - return from == shaft().placementSide || from == shaft().placementSide.getOpposite(); - } + return from == shaft().placementSide || from == shaft().placementSide.getOpposite(); + } - @Override - public boolean inverseRotation(ForgeDirection dir, IMechanicalNode with) - { - if (shaft().placementSide.offsetY != 0 || shaft().placementSide.offsetZ != 0) - { - return dir == shaft().placementSide.getOpposite(); - } + @Override + public boolean inverseRotation(ForgeDirection dir, IMechanicalNode with) + { + if (shaft().placementSide.offsetY != 0 || shaft().placementSide.offsetZ != 0) + { + return dir == shaft().placementSide.getOpposite(); + } - return dir == shaft().placementSide; - } + return dir == shaft().placementSide; + } - public PartGearShaft shaft() - { - return (PartGearShaft) this.getParent(); - } + public PartGearShaft shaft() + { + return (PartGearShaft) this.getParent(); + } }