public MechanicalNetworkOld createAndRegisterNetwork(IMechanicalPowerNetworkNode originatorNode)
{
MechanicalNetworkOld network = createAndRegisterNetwork();
network.register(originatorNode);
network.firstPowerNode = originatorNode.getPosition();
return(network);
}
public void rediscoverNetwork(IWorldAccessor world)
{
// System.out.println("rediscovering networks");
BlockEntity te = world.BlockAccessor.GetBlockEntity(firstPowerNode);
if (te is IMechanicalPowerNetworkNode)
{
// System.out.println("go");
IMechanicalPowerNetworkNode node = (IMechanicalPowerNetworkNode)te;
node.propagateNetworkToNeighbours(myManager.getUniquePropagationId(), networkId, node.getOutputSideForNetworkPropagation());
}
//System.out.println("rediscovery complete, found " + powerNodes.size() + " power nodes");
}
public void forkMechanicalNetwork(IMechanicalPowerNetworkNode powernode, BlockFacing facing)
{
powernode.createMechanicalNetwork(this, facing);
}
public void rebuildNetwork()
{
//System.out.println("rebuilding network");
foreach (IMechanicalPowerDevice device in powerRelays)
{
if (device != null)
{
device.clearNetwork();
}
}
if (powerNodes.Count == 0)
{
//System.out.println("no more power nodes in the network :(");
return;
}
IMechanicalPowerNetworkNode firstNode = powerNodes[0];
Dictionary <IMechanicalPowerNetworkNode, BlockFacing> otherNodes = new Dictionary <IMechanicalPowerNetworkNode, BlockFacing>();
foreach (IMechanicalPowerNetworkNode powernode in powerNodes)
{
if (powernode != null && firstNode != powernode)
{
otherNodes[powernode] = powernode.getFacing(this);
powernode.clearNetwork();
}
}
if (firstNode == null)
{
//System.out.println("node is null");
return;
}
powerNodes.Clear();
powerRelays.Clear();
firstNode.propagateNetworkToNeighbours(
myManager.getUniquePropagationId(),
networkId,
firstNode.getOutputSideForNetworkPropagation()
);
// Whatever power nodes are now not in the current network now need to have the current network forked for them
foreach (IMechanicalPowerNetworkNode otherNode in otherNodes.Keys)
{
bool found = false;
foreach (MechanicalNetwork network in otherNode.getNetworks())
{
if (network.networkId == networkId)
{
found = true;
}
}
if (!found)
{
//System.out.println("forked network");
forkMechanicalNetwork(otherNode, otherNodes[otherNode]);
}
}
//System.out.println("total networks in game: " + myManager.networksById.size());
}
// Should run every 5 ticks or so
public void updateNetwork()
{
/* 1. Verify network */
IMechanicalPowerNetworkNode[] powernodesArray = powerNodes.ToArray();
foreach (IMechanicalPowerNetworkNode node in powernodesArray)
{
if (!node.exists())
{
unregister(node);
}
}
if (powerNodes.Count == 0)
{
isDead = true;
return;
}
/* 2. Determine total available torque and total resistance of the network */
totalAvailableTorque = 0;
totalResistance = 0;
IMechanicalPowerNetworkNode dominantNode = null;
foreach (IMechanicalPowerNetworkNode powerNode in powerNodes)
{
totalAvailableTorque += powerNode.getTorque(this);
totalResistance += powerNode.getResistance(this);
if (dominantNode == null || powerNode.getTorque(this) > dominantNode.getTorque(this))
{
dominantNode = powerNode;
}
}
directionFromFacing = dominantNode.getDirectionFromFacing();
/* 3. Unconsumed torque changes the network speed */
// Positive free torque => increase speed until maxSpeed
// Negative free torque => decrease speed until -maxSpeed
// No free torque => lower speed until 0
float unusedTorque = Math.Abs(totalAvailableTorque) - totalResistance;
int speedChange = (totalAvailableTorque > 0) ? 1 : -1;
if (unusedTorque <= 0)
{
speedChange = 0;
}
/*if (networkId == 6) {
* System.out.println("unusedTorque: " + unusedTorque + " / speedChange: " + speedChange);
* }*/
// TODO: This step value should be determined by the total system drag
float step = 0.75f;
switch (speedChange)
{
case 1:
speed = speed + step;
break;
case -1:
speed = speed - step;
break;
case 0:
if (speed > 0)
{
speed = Math.Max(0, speed - step);
}
if (speed < 0)
{
speed = Math.Max(0, speed + step);
}
break;
}
/* 4. Set direction, also did the direction change? Propagate it through the network */
int olddirection = direction;
direction = (int)Math.Sign(speed);
if (olddirection != direction)
{
//System.out.println("=====propagate direction to neighbours");
foreach (IMechanicalPowerNetworkNode powerNode in powerNodes)
{
// FIXME: This assumes there is only 1 power producer per network
if (powerNode.getTorque(this) > 0)
{
powerNode.propagateDirectionToNeightbours(
myManager.getUniquePropagationId(),
powerNode.getOutputSideForNetworkPropagation(),
direction > 0
);
break;
}
}
}
}
