Self-regulating Network

From #openttdcoop wiki

Revision as of 18:40, 17 February 2009 by ODM (Talk | contribs) (New page: ==Idea== Self-regulating Networks, or SRNW for short, are a type of networks invented by the #Openttdcoop community. The idea behind it is that trains on a network share orders, so there...)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search


Self-regulating Networks, or SRNW for short, are a type of networks invented by the #Openttdcoop

community. The idea behind it is that trains on a network share orders, so there is a group of trains

per network and not per station. In theory, this should reduce the overhead of making sure all

stations have the right amount of trains. In practice, even though the network will still be divided,

this proves to be the case. However, it does introduce other issues.


A typical SRNW line will consist of

  • a drop station, possibly shared with other line. In this case lines are split with waypoints.
  • an entrance track.
  • an exit track.
  • an overflow track.
  • an injection system.
  • one or more SRNW-type stations.

A model of an SRNW line is shown below. Srnwlayout.png For the line to work, there are a few basic but important rules:

  • Trains can only get to the drop through a pickup station.
  • A train should only enter a pickup station when there is enough cargo to pickup.
  • Trains that can not enter a station overflow back to the start.
  • New trains should be introduced intermittently.


All trains on a line share the same orders. On a standard line, this is just one go-to to the drop

station. Caution: this order can not be non-stop. When lines share a drop station, every group should get an entry and exit waypoint at the start and

end of the non-shared line.


The stations of the SRNW are one of its biggest drawbacks. To prevent trains from clogging the first

station and driving around empty, stations should only let trains enter when there is a full load

waiting. To solve this problem, all trains have a waiting bay. This ensures that when there is a full

load, there is a train to transport it. Furthermore, all stations have a dummy train. This dummy

full-loads, blocking the waiting train. Only when it is full and moves away to unload can a train

enter the station and pickup the cargo. Even though this works, it does prove to be quite a hassle,

especially for larger stations. This is an example of a simple SRNW station with one platform. Srnwstation.png A special note on the pathfinding trap: sometimes trains refuse to enter the station. This

construction fools the pathfinder into thinking it can reach the drop station by driving through

there. Can be required on lines with a roro station or a non-reversing overflow (aka continuous

track). Also, when the production grows, so should the station. This can lead to huge constructions, as

demonstrated below by Mark. Srnwstationbig.png


Injection is the system of re-introducing trains to the network. Trains from a depot, and therefore

from the overflow track, are sent back onto the entry track. The easiest way to do this is to release

a train every X days by using a loop, a station and a little train. Srnwsimpleinjection.png This idea can be extended by

  • not releasing a new train when one has just overflown. (ODM)
  • not releasing a new train when all waiting bays are full. (Osai)
  • resetting the train release timer when a train overflows. (Mark)

Srnwtimerinjection.png Above Mark's 18.6 day injectiontimer, combining NOT-gates with actual memory.


  • A well structured network by design.
  • High efficiency.
  • Keeping the amount of trains right just by checking the depot stock.


  • Bigger stations are hard to build.
  • Takes up quite some space.
  • Only transports a few cargotypes.
Powered by MediaWiki