In my game the map is represented by connected nodes, each node has a number of connected nodes. The nodes represent a system in which players can build structures and move units about. If you're familiar with Sins of a Solar Empire the game map is very similar.
I want each node to be able to produce power and share it with all connected nodes.
For example if A, B, C & D are all connected and produce 100 power units, then each system
should have 400 power units available. If node B builds a structure that consumes 100 power units then A, B, C & D should then have 300 power units available.
I've been working on this system all day and haven't been able to get it working quite the way I want.
My current implementation is to first recurse through each nodes's connected node adding up the power, I keep a list of closed nodes so it doesn't loop, it's quite similar to A* actually.
Pseudo code:
All nodes start with the properties
node.power = 0
node.basePower = 100 // could be different for each node.
node.initialPower = node.basePower
-
function propagatePower( node, initialPower, closedNodes )
node.power += initialPower
add( closedNodes, node )
connectedNodes = connected_nodes_except_from( closedNodes )
foreach node in connectedNodes do
propagatePower( node, initialPower, closedNodes )
end
end
After this I iterate through all power consumers.
foreach consumer in consumers do
node = consumer.parentNode
if node.power >= consumer.powerConsumption then
consumer.powerConsumed += consumer.powerConsumption
node.producedPower -= consumer.powerConsumption
end
end
Then I adjust the initial power for the next propagation cycle.
foreach node in nodes do
node.initialPower = node.basePower - node.producedPower
node.displayPower = node.power // for rendering the power.
node.power = 0
end
This seemed to work at first but then I came into a problem.
Say two nodes A & B produce 100Pu each, it's shared so both A & B have 200Pu.
I then make two structures that consume 80Pu each on A (160Pu).
Then the nodes power is adjusted to basePower - producedPower (100-160 = -60).
Nodes are propagated, both nodes now have 40Pu (A: -60 + B: 100 = 40).
Which is correct because they started with 200Pu - 160Pu = 40Pu.
However now node.power >= consumer.powerConsumption is false.
Whats worse is it's false for any structure that uses more that 40Pu, so the whole system goes down.
I could deduct from consumer.powerConsumption but what do I do if power is reduced elsewhere? I don't have the correct data to perform the necessary checks.
It's late so I'm probably not thinking straight but I thought to ask on here to see if anyone has any other implementations, better or worse I'd be interested to know.
