#openttdcoop wiki - User contributions [en]

New Player Pointers

2016-08-12T20:15:38Z

Maqifrnswa: /* TREES */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits
* SAFEST: After split, leave one train length of no signals to guarantee that no train will block the split. If trains do back up, you can place a signal at the back of the last train after the split to let another train fit after it
* FASTEST: More accurately, you need to leave an integer number of train lengths worth of signals immediately before the next place a train can stop (i.e., the next split). The number of signals should then be a multiple of
TL_in_signals = ceil(TL/SD)
TL =train length
SD = signal distance
So a TL = 7 and SD of 2 needs ceil(7/2) = 4 signals for one train length. (you always start with a signal, then each train starts with a no signal square and ends on a signal square, the last signal is removed = 1+ ceil(TL/SD-1)
** So drop a signal, auto-complete it backwards, cound number of signals - and make sure it is a multiple of TL_in_signals
** or put a signal at the last square of the last train that can fit while waiting

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave a signal gap as described above
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. Start counting at the exit pre-signal. This gap should not slow down the network since you split, and there is a second line! Basically, you are using the gap itself as a signaling mechanism. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, two philosophies: do not signal versus normal signal.
** Do not signal between combos: this way trains don't get stuck if combo goes red. ATM, I lean this way
** Do signal: this sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal. Subtle difference - PBS splits start counting after the PBS signal, while pre-signals start counting at the location of the exit pre-signal.
* don't mix PBS and pre-signals in same tree

New Player Pointers

2016-08-12T15:33:43Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits
* SAFEST: After split, leave one train length of no signals to guarantee that no train will block the split. If trains do back up, you can place a signal at the back of the last train after the split to let another train fit after it
* FASTEST: More accurately, you need to leave an integer number of train lengths worth of signals immediately before the next place a train can stop (i.e., the next split). The number of signals should then be a multiple of
TL_in_signals = ceil(TL/SD)
TL =train length
SD = signal distance
So a TL = 7 and SD of 2 needs ceil(7/2) = 4 signals for one train length. (you always start with a signal, then each train starts with a no signal square and ends on a signal square, the last signal is removed = 1+ ceil(TL/SD-1)
** So drop a signal, auto-complete it backwards, cound number of signals - and make sure it is a multiple of TL_in_signals
** or put a signal at the last square of the last train that can fit while waiting

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave a signal gap as described above
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. Start counting at the exit pre-signal. This gap should not slow down the network since you split, and there is a second line! Basically, you are using the gap itself as a signaling mechanism. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal. Subtle difference - PBS splits start counting after the PBS signal, while pre-signals start counting at the location of the exit pre-signal.
* don't mix PBS and pre-signals in same tree

New Player Pointers

2016-08-12T15:05:24Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits
* SAFEST: After split, leave one train length of no signals to guarantee that no train will block the split.
* FASTEST: More accurately, you need to leave an integer number of train lengths worth of signals immediately before the next place a train can stop (i.e., the next split). The number of signals should then be a multiple of
TL_in_signals = ceil(TL/SD)
TL =train length
SD = signal distance
So a TL = 7 and SD of 2 needs ceil(7/2) = 4 signals for one train length. (you always start with a signal, then each train starts with a no signal square and ends on a signal square, the last signal is removed = 1+ ceil(TL/SD-1)
** So drop a signal, auto-complete it backwards, cound number of signals - and make sure it is a multiple of TL_in_signals
** or put a signal at the last square of the last train that can fit while waiting

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave a signal gap as described above
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. Start counting at the exit pre-signal. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal. Subtle difference - PBS splits start counting after the PBS signal, while pre-signals start counting at the location of the exit pre-signal.
* don't mix PBS and pre-signals in same tree

New Player Pointers

2016-08-12T15:04:54Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits
* SAFEST: After split, leave one train length of no signals to guarantee that no train will block the split.
* FASTEST: More accurately, you need to leave an integer number of train lengths worth of signals immediately before the next place a train can stop (i.e., the next split). The number of signals should then be a multiple of
TL_in_signals = ceil(TL/SD)
TL =train length
SD = signal distance
So a TL = 7 and SD of 2 needs ceil(7/2) = 4 signals for one train length. (you always start with a signal, then each train starts with a no signal square and ends on a signal square, the last signal is removed = 1+ ceil(TL/SD-1)
** So drop a signal, auto-complete it backwards, cound number of signals - and make sure it is a multiple of TL_in_signals
** or put a signal at the last safe place a train can stop

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave a signal gap as described above
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. Start counting at the exit pre-signal. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal. Subtle difference - PBS splits start counting after the PBS signal, while pre-signals start counting at the location of the exit pre-signal.
* don't mix PBS and pre-signals in same tree

New Player Pointers

2016-08-12T14:53:08Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits
* SAFEST: After split, leave one train length of no signals to guarantee that no train will block the split.
* FASTEST: More accurately, you need to leave an integer number of train lengths worth of signals immediately before the next place a train can stop (i.e., the next split). The number of signals should then be a multiple of
TL_in_signals = ceil(TL/SD)
TL =train length
SD = signal distance
So a TL = 7 and SD of 2 needs ceil(7/2) = 4 signals for one train length. (you always start with a signal, then each train starts with a no signal square and ends on a signal square, the last signal is removed = 1+ ceil(TL/SD-1)
** So drop a signal, auto-complete it backwards, cound number of signals - and make sure it is a multiple of TL_in_signals

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave a signal gap as described above
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. Start counting at the exit pre-signal. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal. Subtle difference - PBS splits start counting after the PBS signal, while pre-signals start counting at the location of the exit pre-signal.
* don't mix PBS and pre-signals in same tree

New Player Pointers

2016-08-12T14:33:23Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits
* SAFEST: After split, leave one train length of no signals to guarantee that no train will block the split.
* FASTEST: More accurately, you need to leave an integer number of train lengths worth of signals immediately before the next place a train can stop (i.e., the next split). The number of signals should then be a multiple of
TL_in_signals = floor(TL/SD)+1
TL =train length
SD = signal distance
So a TL = 7 and SD of 2 needs floor(7/2)+1 = 3+1 = 4 signals for one train length.
** So drop a signal, auto-complete it backwards, cound number of signals - and make sure it is a multiple of TL_in_signals

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave a signal gap as described above
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. Start counting at the exit pre-signal. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal. Subtle difference - PBS splits start counting after the PBS signal, while pre-signals start counting at the location of the exit pre-signal.
* don't mix PBS and pre-signals in same tree

New Player Pointers

2016-08-12T13:57:56Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits
* After split, leave one train length of no signals to guarantee that no train will block the split.

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave one train length before starting signaling again (see reasoning in TREES below)
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. Start counting at the exit pre-signal. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal. Subtle difference - PBS splits start counting after the PBS signal, while pre-signals start counting at the location of the exit pre-signal.
* don't mix PBS and pre-signals in same tree

New Player Pointers

2016-08-10T14:13:45Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave one train length before starting signaling again (see reasoning in TREES below)
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal
* don't mix PBS and pre-signals in same tree

New Player Pointers

2016-08-10T13:57:04Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave one train length before starting signaling again (see reasoning in TREES below)
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both tracks of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit a train length - it is similar to the combo signal in pre-signaling. If using a PBS, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signal

New Player Pointers

2016-08-10T13:46:57Z

Maqifrnswa: /* TREES */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave one train length before starting signaling again (see reasoning in TREES below)
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both trackes of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* in between two consecutive combos, fill with normal gap combos. This sends a stronger signal to pathfinder about what's going on

==== PBS TREES ====
* using a pbs to split, USE TWO WAY SIGNALS at output of split
* pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit it, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signals (remember, two-way!)

New Player Pointers

2016-08-10T13:40:44Z

Maqifrnswa: /* JAM PROOF Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before and after split at the entrance -- and immediately before and after join. Entrance: entry pre-sig -> exit presig. Exit: normal -> normal.
* After the exit presignal on the entrance of the doubled bridge, leave one train length before starting signaling again (see reasoning in TREES below)
** "You should never have a signal between the exit signal and the bridge as this breaks the entire workings of the pre-signals and the bridges may break horribly" https://blog.openttdcoop.org/2010/07/27/building-101-double-bridges-and-you/
* You really need three signals at start and end. If you're missing one, it won't work some times. Use PBS on entrance side if limited on space, but you must have both trackes of the output end signaled, otherwise both bridges will will be on the same block

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* after split, use two way signals to indicate "end of line - do not come this way if red!"

==== PBS TREES ====
* using a pbs to split, USE TWO WAY SIGNALS at output of split
* pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit it, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signals (remember, two-way!)

New Player Pointers

2016-08-10T13:21:18Z

Maqifrnswa: /* TREES */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before, after split -- and immediately before and after join. Normal ctrl+drag spacing of signals after that.
Don't follow tree rules below, everything is already in sync, so can just use normal signals as long as you signal immediately before and after splits/joins. It's important that you make sure the two bridges are NOT in the same block (i.e., use back to back signals after split into bridges) -- or use PBS.

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.
* after split, use two way signals to indicate "end of line - do not come this way if red!"

==== PBS TREES ====
* using a pbs to split, USE TWO WAY SIGNALS at output of split
* pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit it, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signals (remember, two-way!)

New Player Pointers

2016-08-10T13:19:15Z

Maqifrnswa: /* synced splits (bridge tunnel) */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before, after split -- and immediately before and after join. Normal ctrl+drag spacing of signals after that.
Don't follow tree rules below, everything is already in sync, so can just use normal signals as long as you signal immediately before and after splits/joins. It's important that you make sure the two bridges are NOT in the same block (i.e., use back to back signals after split into bridges) -- or use PBS.

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.

==== PBS TREES ====
* using a pbs to split, USE TWO WAY SIGNALS at output of split
* pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit it, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signals (remember, two-way!)

New Player Pointers

2016-08-10T13:14:22Z

Maqifrnswa: /* synced splits (bridge tunnel) */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before, after split -- and immediately before and after join. Don't follow tree rules below, everything is already in sync, so can just use normal signals as long as you signal immediately before and after splits/joins. It's important that you make sure the two bridges are NOT in the same block (i.e., use back to back signals after split into bridges) -- or use PBS.

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.

==== PBS TREES ====
* using a pbs to split, USE TWO WAY SIGNALS at output of split
* pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit it, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signals (remember, two-way!)

New Player Pointers

2016-08-09T17:34:43Z

Maqifrnswa: /* Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== JAM PROOF Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before, after split -- and immediately before and after join. Don't follow tree rules below, everything is already in sync, so can just use normal signals as long as you signal immediately before and after splits/joins

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.

==== PBS TREES ====
* using a pbs to split, USE TWO WAY SIGNALS at output of split
* pretend like the output is an exit signal in the normal presignal tree: leave one train length before next signal. If you can't fit it, DON'T PUT ANY SIGNALS between the first entry PBS and wherever you can put the exit signals (remember, two-way!)

New Player Pointers

2016-08-09T17:13:24Z

Maqifrnswa: /* Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* signal right before and after splits

=== synced splits (bridge tunnel) ===
* signal immediately before, after split -- and immediately before and after join. Don't follow tree rules below, everything is already in sync, so can just use normal signals as long as you signal immediately before and after splits/joins

=== TREES ===
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.

New Player Pointers

2016-08-09T16:58:41Z

Maqifrnswa: /* Signals */

As a new player, here are some tips I figured out that were pulled from several different locations:

== General ==

First, read/go through the openttdcoop tutorial save files. These are some tips in addition to, or repeats of those files.

Look at the map: find the mainline (ML), sidelines (SL), and sideline hubs (SLH) that connect the two. Look at some stations that are connected to the sideline. If there are lots of extra tracks, signals, and a depot that doesn't make sense, go read the articles on overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue.

== Your First Station ==

A good thing to start with is a simple station serving one pick-up (i.e., just coal, just wheat, just livestock, just steel, etc.). You can read the tutorials on stations, but essentially you have to worry about 4 things:
* Where will the platforms go?
** The number of platforms determines the maximum loading rate, which is almost always faster than the industry production. Therefore, in theory, you really only "need" one (or two) platforms for pick-up stations. Extra platforms really just serves as waiting bays for extra trains.
* How do trains get in?
** Simply connect to the sideline, and run a line to your station. If you have more than one platform, use signaling (see below).
* Where will the waiting trains go?
** Pick up stations can have trains waiting for resources to be made. There needs to be somewhere for these trains to wait and not block the sideline traffic. Simplest: just get a long piece of track where trains can queue. What you're more likely to see are overflows. Again, read about overflows at https://wiki.openttdcoop.org/Advanced_Building_Revue. Trains entering a station with an overflow usually follow this logic flow:

# Is a platform free?
## Yes: Go to a platform
## No: Enter the overflow. The overflow will have a reverser that will change the train direction. The reverser is just one train-length worth of track that forks in to at least two directions at the end (looks like a chicken's foot or an arrow). It just tricks the pathfinder in to thinking there is a path, then the train hits the end of line and reverses. Why is there a reverser? It hides the depot, which is after the reverser from all trains except those that have gone through the reverser. You can read about it in https://wiki.openttdcoop.org/Advanced_Building_Revue.
# After the reverser, there will be a depot and then a stretch of track where a train can wait for a free platform, called a waiting bay. Is a train waiting in the waiting bay?
## Yes: Go to Depot
## No: Go to waiting bay
# If you are in a depot, you will wait until (A) the waiting bay is empty AND (B) there is no train in the reverser/on the track in front of the depot. This is checked by placing a two-way exit pre-signal in front of the depot facing the reverser. Depots have a built in entry pre-signal, so a red exit pre-signal will keep trains in the depot.
# If you are in the waiting bay, wait until (A) a platform is free AND (B) no other train is coming towards the station from the sideline. This is done using priority checks (see below).
* How do trains get out?
** In the end, this is easier - simply join the tracks together - priority doesn't matter, and re-join the sideline.

== Signaling and controlling CHOICE/PRIORITY ==

You want to control which tracks trains use and which tracks should never slow down. This is done using signaling.

Read about pre-signals and PBS. That will give you basic signaling.

Fine tuning requires a little more understanding about how the pathfinder works (i.e., how the computer chooses where trains go).

Basically, trains will take the shortest route. However, trains "penalize" routes - and controlling these penalties are a useful trick.
https://wiki.openttdcoop.org/Penalties

# Big penalty for seeing the back of a PBS signal (see the article on shifted main lines/shifters).
# The pathfinder works best when using pre-signals at splits. If a track splits and both splits are going to the same place (i.e., bridge over another track), use a entry and exit presignals.
## If you don't have space for an entry and exit presignal, then use a path based signal (PBS). After the PBS, put a two way (i.e., points in both direction) normal signal, because a red two-way signal is seen as the end-of-line (EOL), so the PBS won't send a train down that path. Otherwise, it would - even if it is red, causing jams

=== Priority ===
Lots of good articles on this site on priority. Basically: use "dummy" track and pre-signals to relay information about the presence of a train on one track over to another location. This way trains can wait until track clears up. Some rules:

* Mainline always has priority and should never slow down
* full trains leaving stations have priority over empty trains
* Other than that, use your judgement

Other "checks"

* Overflows use multiple checks (free platform? incoming train? train in reverser?)
* Shifted mainlines use checks (Is it safe to merge to the other line?)

== Merging (Load Balancing) ==

All over the internet, I read about the importance of "load balancing" and "load balancers" -- but couldn't actually find someone saying what that means! The reason: "load balancers" are obsolete because of the approach of "balanced" merges and how the pathfinder works.

There's a good article on merging on this site, but to make the connection between load balancing and merging is needed to clear up some confusion: as long as you make sure traffic can easily make a choice to whatever line it wants at intersections, the traffic load will be balanced. So if there is a mainline with two tracks in each direction, and you have a sideline with one track in each direction - as long as any train on either mainline track can exit, and a train on the sideline can enter any of the mainline tracks, the system will be balanced. Sometimes you can take shortcuts and find ways to share the possible choices (see the merging article) - but it all comes down to answering the question, "Can a train on any track get on or off of any other track at this hub/intersection?"

== Signals ==
* Keep signals every 2 squares (that is, signal-blank-signal).
* after a presignal tree (entry->zero or more combo->exit), leave exactly one train space of no signals after last exit before next signal to prevent blocking of the split. If you can't fit one train length, it means you need to use a combo signal and move the exit after the next split!! With a train length of 5, if you have
Entry-> split - >SIGNAL 1 -> X number of spaces -> SIGNAL 2 -> split-> SIGNAL 3
That means if X< train length, SIGNAL 1 should be a combo, SIGNAL 2 should be a combo (or NOTHING), SIGNAL 3 should be exit. If X >= train length, SIGNAL 1 should be an exit, SIGNAL 2 should be entry, and SIGNAL 3 should be determined by what follows using the same logic. There should be normal signals (with normal spacing) between any exit and the next entry signal.

New Player Pointers

2016-08-09T16:52:51Z

Maqifrnswa:

User:Maqifrnswa

2016-08-09T01:00:32Z

Maqifrnswa:

See my [[New Player Pointers]]

= game mechanics =

Formulas:
(un)loaded per tick = (load_amount / 40)*(num_cars_loading)
maximum primary produced per tick = default_level/32
line carry capacity per tick per track = TC * velocity_tile_per_tck / (TL+gap)
TC = train cargo
TL = train length
100 kmh = 3.6 tile/day = 3.6/74 tile_per_tick
velocity_tile_per_tick = 2056 * velocity_in_kmh
line carry capacity per tick per track = TC * 2056 * velocity_in_kmh / (TL+gap)

Conclusions:
Max station num cars = default_prod_level/load_amount* 1.25
Max MAIN station num cars = TC * velocity_in_kmh/ load amount / (TL+gap)/51

420*(10)*133/6/51
note that it is cars, not tiles.

== cargo delivery to stations ==
Every day is 74 ticks. every 256 ticks cargo is delivered to stations (8 or 9 times a month, every 3.5 days). The default amount of cargo produced is in src/table/build_industry.h. The amount delivered can be 1/8, 1/4, 1/2, 1x, 2x, 4x, or 8x of the default value, depending on level of production.

Coal 15, Wood 13, Oil rig 15, oil well 12, livestock 10, Grain 10, copper 10, bank 6, gold 7, diamond 7, iron 10, water 12, maize 11.

So the max an industry can produce is ~1100/month (coal). More precisely, 0.46875 per tick = 18.75 per 40 ticks (one train load cycle). Assuming 100% delivery (which never happens...) and the default 5 cargo loaded on to one train car per 40 ticks, 4 loading train cars (2 tiles) are needed to keep up with production. Those 2 tiles need to be constantly occupied, so parallel tracks are needed. Therefore, a station of 2 tracks for a train length of 3 should keep up with demand (although require a constant stream of trains!). To burn down excess supply at a station, more tracks (and/or longer trains) would be needed.

== vehicle loading rates ==
When a vehicle is loading, cargo is loaded every: 40 ticks for trains, 20 ticks for planes/road vehicles, or 10 ticks for ships. Each individual train car adds cargo every loading event, so longer trains load more per tick than short trains. The default amount of cargo loaded is seen below:

{| class="wikitable"
|+Default Vehicle Loading Rates
|-
!Type
!Ticks per Load
!Units Cargo Loaded Per Load
|-
|Train
|40
|5
|-
|Road
|20
|5
|-
|Ship
|10
|10
|-
|Air
|20
|20 for all except mail (5 for mail)
|}
From: (src/economy.cpp "const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 }", order is enumerated in src/vehicle_type.h)
src/tables/engines.h. NewGRFs define the loading_speed property which is not visible in the client (maybe it should be?). It is in the item "property" or "graphics" setting. for example, brickwalker in NUTS has a loading_speed=2.

Air Mail is funky, according to src/economy.cpp

/* The default loadamount for mail is 1/4 of the load amount for passengers */
bool air_mail = v->type == VEH_AIRCRAFT && !Aircraft::From(v)->IsNormalAircraft();
if (air_mail) load_amount = CeilDiv(load_amount, 4);

From (src/aircraft_cmd.cpp), mail is carried by the airplane's shadow! that's why you need to check if it is not a normal aircraft (but its shadow!)

1 unit of cargo is defined in the default OpenGRF as:
{| class="wikitable"
! Cargo !! Multiplier !! Meaning
|-
| PASS || 4 || A vehicle carrying 1 ton of coal, can carry 4 passengers.
|-
| MAIL || 2 || A vehicle carrying 1 ton of coal, can carry 2 bags of mail.
|-
| GOOD, SWET || 2 || A vehicle carrying 1 ton of coal, can carry 2 crates of goods/sweets.
|-
| (everything else) || 1 || All other slots default to 1, i.e. 1 unit of cargo equals 1 ton of coal.
|}
source: https://newgrf-specs.tt-wiki.net/wiki/Action0Cargos and src/table/cargo_const.h

= notes =

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* when at steady state (i.e., multiple round trips of trains generated on demand) delete excess trains in overflow from furthest station. this station now generates trains on demand. Excess trains mean the total trains servicing the station should be round trip time times industry generation rate. At steady state, a train is returning to station as often as it is being generated, so any train in overflow is excess!
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

File:ROTATING-BBH-INGAME.png

2016-08-07T05:02:44Z

Maqifrnswa:

Pivot BBH

2016-08-07T05:02:23Z

Maqifrnswa: /* Additional Examples */

== Intro ==
In an attempt to reduce the number of bridges and crossings in a [[Backbone Hub]], you can try something like a Pivot BBH where the traffic rotates around a central pivot point. For example, in the figure below, a LL_RR 3-way BBH is built using this concept.
[[File:COMPACT-ROTATING-BBH.png|800px|thumb|none|An example compact Pivot BBH]]

== Key Features/How to Build ==
As you can see above, the traffic rotates around the central area in a counter-clockwise fashion. Every input will first cross over one set of tracks, and then be crossed over by another set of tracks. During the first cross over, the input splits to send trains to both outputs.
* First, pick where the pivot will be, that is the center of the hub
* Then, choose any input. You will lay track from this input to the output of the hub TO THE LEFT of the input you choose. Lay the track so it passes to the right of your pivot point, then turn the track so it heads to the desired exit.
* Remember - all traffic must go counter-clockwise around the pivot!

== Additional Examples ==
Rather than having the tracks split and re-koim after crossing another line, you can keep them split and use the already split lines for a balanced merge. In the example below, the top exists are merged all-to-alll while the bottom and left exists are Inner Mix merges for the sake of demonstration.
[[File:ROTATING-BBH-FULL.png|800px|thumb|none|Example of a Pivot BBH without rejoining]]

Here is the first built example of a Pivot BBH from PSG 317
[[File:ROTATING-BBH-INGAME.png|800px|thumb|none|Example of a Pivot BBH]]

File:ROTATING-BBH-FULL.png

2016-08-07T04:59:50Z

Maqifrnswa:

Pivot BBH

2016-08-07T04:59:08Z

Maqifrnswa: Created page with "== Intro == In an attempt to reduce the number of bridges and crossings in a Backbone Hub, you can try something like a Pivot BBH where the traffic rotates around a centra..."

== Intro ==
In an attempt to reduce the number of bridges and crossings in a [[Backbone Hub]], you can try something like a Pivot BBH where the traffic rotates around a central pivot point. For example, in the figure below, a LL_RR 3-way BBH is built using this concept.
[[File:COMPACT-ROTATING-BBH.png|800px|thumb|none|An example compact Pivot BBH]]

== Key Features/How to Build ==
As you can see above, the traffic rotates around the central area in a counter-clockwise fashion. Every input will first cross over one set of tracks, and then be crossed over by another set of tracks. During the first cross over, the input splits to send trains to both outputs.
* First, pick where the pivot will be, that is the center of the hub
* Then, choose any input. You will lay track from this input to the output of the hub TO THE LEFT of the input you choose. Lay the track so it passes to the right of your pivot point, then turn the track so it heads to the desired exit.
* Remember - all traffic must go counter-clockwise around the pivot!

== Additional Examples ==
Rather than having the tracks split and re-koim after crossing another line, you can keep them split and use the already split lines for a balanced merge.
[[File:ROTATING-BBH-FULL.png|800px|thumb|none|Example of a Pivot BBH without rejoining]]

Here is the first built example of a Pivot BBH from PSG 317
[[File:ROTATING-BBH-INGAME.png|800px|thumb|none|Example of a Pivot BBH]]

Backbone Hub

2016-08-07T04:37:41Z

Maqifrnswa: /* Additional BBH Building Guides */

[[Image:BBH.png|thumb|right|An example Backbone Hub]]
A backbone hub (BBH) is the largest type of [[Guides:Glossary:Hub|Hub]] that is built in #OpenTTDCoop. It usually consists of at least 3 cardinal directions of [[Basic_Networking#Mainline (ML)|mainline]] Track, and is also usually [[Balancing|balanced]] as well.

Recommended blog post: [http://blog.openttdcoop.org/2010/07/10/advanced-building-revue-06-hubs/ Advanced building revue 06 - Hubs]

== Function ==

A BBH connects [[Basic_Networking#Mainline (ML)|mainline]] segments to each other, most often in [[Junctionary_-_BBHs_-_4way|4-way]] or [[Junctionary_-_BBHs_-_3-way|3-way]] junction patterns.

== Requirements ==

A BBH must be:
* [[Balancing|Balanced]] - ie: each lane entering the BBH should be able to choose any lane leaving the BBH
* Efficient - Trains should not have to slow down
* Properly sized for the highest [[User:Tim/Tilelength|length]] trains in use

== Backbone Hub Building ==

Backbone hubs are complex structures and can be quite overwhelming at first. In this article I'll try to break down backbone hub construction in pieces in an attempt to make it easier to understand and give an idea on how to start. Note that this article does expect at least basic knowledge about pre-signalling and knows the #openttdcoop building standards, including doubled bridges, non-slowing down curves and balancing.

The BBH we're going to build here will be an LL5RR to LL5RR 3-way one. These are quite common and relatively easy to build. Below you can see the mainlines that are already in place, waiting for the BBH to be built.

[[File:BBH_building_1.PNG|400px|thumb|none|Unconnected mainlines waiting for the BBH we're going to build]]

A typical 3-way can be broken down into pieces; one ML crossing, one crossover, 3 exits and 3 joins. You'll want to start with the ML crossing, this is where the ML crosses an other ML. It is a common mistake to start with an exit or a join; don't do this. The ML crossing will be in the center of the hub, making it hard to add later.
The crossover is the point where the joining mainline cross each other, you will one or more of these in every BBH because they are needed to allow traffic to go to the other direction. In the image below the ML crossing and crossover are built. Also the locations for the joins and exits are signed, giving a general idea about the layout we'll have in the end. The first exit obviously was built together with the crossover.

[[File:BBH_building_2.PNG|400px|thumb|none|The first parts of our BBH are done]]

Now let's make the other 2 exits, this should be pretty straightforward as exits don't require balancing.

[[File:BBH_building_3.PNG|400px|thumb|none|The other exits are in place]]

Up next are the joins; these are harder than exits because they require balancing. At this point you can already see we won't have to worry about space limitations because we started building outwards from the center. Below shows our BBH with full-balanced non-blocking all-to-all joining.

[[File:BBH_building_4.PNG|400px|thumb|none|Balanced joins are added]]

The only thing left to do is finishing the signaling and adding priorities to our balancers. Note that you can hack in priorities in any place, so you don't have to worry about reserving space for them.

[[File:BBH_building_5.PNG|400px|thumb|none|Signals and prios are added, completing our BBH]]

=== Additional BBH Building Guides ===
BBH come is all shapes and sizes, depending on the map and intention of the design. Alternatives including a [[Pivot BBH]] where traffic rotates around a pivot with entrances and exists.
[[File:COMPACT-ROTATING-BBH.png|400px|thumb|none|An example compact Pivot BBH]]

[[Category:Guides]]
[[Category:Basic networking]]
[[Category:Advanced Networking]]

File:COMPACT-ROTATING-BBH.png

2016-08-07T04:36:50Z

Maqifrnswa: Example of a compact BBH based on traffic rotating around a pivot point. For example, see PSG 317 BBHs by maqifrnswa

Example of a compact BBH based on traffic rotating around a pivot point. For example, see PSG 317 BBHs by maqifrnswa

Backbone Hub

2016-08-07T04:34:03Z

Maqifrnswa:

[[Image:BBH.png|thumb|right|An example Backbone Hub]]
A backbone hub (BBH) is the largest type of [[Guides:Glossary:Hub|Hub]] that is built in #OpenTTDCoop. It usually consists of at least 3 cardinal directions of [[Basic_Networking#Mainline (ML)|mainline]] Track, and is also usually [[Balancing|balanced]] as well.

Recommended blog post: [http://blog.openttdcoop.org/2010/07/10/advanced-building-revue-06-hubs/ Advanced building revue 06 - Hubs]

== Function ==

A BBH connects [[Basic_Networking#Mainline (ML)|mainline]] segments to each other, most often in [[Junctionary_-_BBHs_-_4way|4-way]] or [[Junctionary_-_BBHs_-_3-way|3-way]] junction patterns.

== Requirements ==

A BBH must be:
* [[Balancing|Balanced]] - ie: each lane entering the BBH should be able to choose any lane leaving the BBH
* Efficient - Trains should not have to slow down
* Properly sized for the highest [[User:Tim/Tilelength|length]] trains in use

== Backbone Hub Building ==

Backbone hubs are complex structures and can be quite overwhelming at first. In this article I'll try to break down backbone hub construction in pieces in an attempt to make it easier to understand and give an idea on how to start. Note that this article does expect at least basic knowledge about pre-signalling and knows the #openttdcoop building standards, including doubled bridges, non-slowing down curves and balancing.

The BBH we're going to build here will be an LL5RR to LL5RR 3-way one. These are quite common and relatively easy to build. Below you can see the mainlines that are already in place, waiting for the BBH to be built.

[[File:BBH_building_1.PNG|400px|thumb|none|Unconnected mainlines waiting for the BBH we're going to build]]

A typical 3-way can be broken down into pieces; one ML crossing, one crossover, 3 exits and 3 joins. You'll want to start with the ML crossing, this is where the ML crosses an other ML. It is a common mistake to start with an exit or a join; don't do this. The ML crossing will be in the center of the hub, making it hard to add later.
The crossover is the point where the joining mainline cross each other, you will one or more of these in every BBH because they are needed to allow traffic to go to the other direction. In the image below the ML crossing and crossover are built. Also the locations for the joins and exits are signed, giving a general idea about the layout we'll have in the end. The first exit obviously was built together with the crossover.

[[File:BBH_building_2.PNG|400px|thumb|none|The first parts of our BBH are done]]

Now let's make the other 2 exits, this should be pretty straightforward as exits don't require balancing.

[[File:BBH_building_3.PNG|400px|thumb|none|The other exits are in place]]

Up next are the joins; these are harder than exits because they require balancing. At this point you can already see we won't have to worry about space limitations because we started building outwards from the center. Below shows our BBH with full-balanced non-blocking all-to-all joining.

[[File:BBH_building_4.PNG|400px|thumb|none|Balanced joins are added]]

The only thing left to do is finishing the signaling and adding priorities to our balancers. Note that you can hack in priorities in any place, so you don't have to worry about reserving space for them.

[[File:BBH_building_5.PNG|400px|thumb|none|Signals and prios are added, completing our BBH]]

=== Additional BBH Building Guides ===
BBH come is all shapes and sizes, depending on the map and intention of the design. Alternatives including a [[Pivot BBH]] where traffic rotates around a pivot with entrances and exists.
[[File:COMPACT-ROTATING-BBH|400px|thumb|none|An example compact Pivot BBH]]

[[Category:Guides]]
[[Category:Basic networking]]
[[Category:Advanced Networking]]

User:Maqifrnswa

2016-07-30T09:50:51Z

Maqifrnswa: /* cargo delivery to stations */

See my [[New Player Pointers]]

= game mechanics =
== cargo delivery to stations ==
Every day is 74 ticks. every 256 ticks cargo is delivered to stations (8 or 9 times a month, every 3.5 days). The default amount of cargo produced is in src/table/build_industry.h. The amount delivered can be 1/8, 1/4, 1/2, 1x, 2x, 4x, or 8x of the default value, depending on level of production.

Coal 15, Wood 13, Oil rig 15, oil well 12, livestock 10, Grain 10, copper 10, bank 6, gold 7, diamond 7, iron 10, water 12, maize 11.

So the max an industry can produce is ~1100/month (coal). More precisely, 0.46875 per tick = 18.75 per 40 ticks (one train load cycle). Assuming 100% delivery (which never happens...) and the default 5 cargo loaded on to one train car per 40 ticks, 4 loading train cars (2 tiles) are needed to keep up with production. Those 2 tiles need to be constantly occupied, so parallel tracks are needed. Therefore, a station of 2 tracks for a train length of 3 should keep up with demand (although require a constant stream of trains!). To burn down excess supply at a station, more tracks (and/or longer trains) would be needed.

== vehicle loading rates ==
When a vehicle is loading, cargo is loaded every: 40 ticks for trains, 20 ticks for planes/road vehicles, or 10 ticks for ships. Each individual train car adds cargo every loading event, so longer trains load more per tick than short trains. The default amount of cargo loaded is seen below:

{| class="wikitable"
|+Default Vehicle Loading Rates
|-
!Type
!Ticks per Load
!Units Cargo Loaded Per Load
|-
|Train
|40
|5
|-
|Road
|20
|5
|-
|Ship
|10
|10
|-
|Air
|20
|20 for all except mail (5 for mail)
|}
From: (src/economy.cpp "const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 }", order is enumerated in src/vehicle_type.h)
src/tables/engines.h. NewGRFs define the loading_speed property which is not visible in the client (maybe it should be?). It is in the item "property" or "graphics" setting. for example, brickwalker in NUTS has a loading_speed=2.

Air Mail is funky, according to src/economy.cpp

/* The default loadamount for mail is 1/4 of the load amount for passengers */
bool air_mail = v->type == VEH_AIRCRAFT && !Aircraft::From(v)->IsNormalAircraft();
if (air_mail) load_amount = CeilDiv(load_amount, 4);

From (src/aircraft_cmd.cpp), mail is carried by the airplane's shadow! that's why you need to check if it is not a normal aircraft (but its shadow!)

1 unit of cargo is defined in the default OpenGRF as:
{| class="wikitable"
! Cargo !! Multiplier !! Meaning
|-
| PASS || 4 || A vehicle carrying 1 ton of coal, can carry 4 passengers.
|-
| MAIL || 2 || A vehicle carrying 1 ton of coal, can carry 2 bags of mail.
|-
| GOOD, SWET || 2 || A vehicle carrying 1 ton of coal, can carry 2 crates of goods/sweets.
|-
| (everything else) || 1 || All other slots default to 1, i.e. 1 unit of cargo equals 1 ton of coal.
|}
source: https://newgrf-specs.tt-wiki.net/wiki/Action0Cargos and src/table/cargo_const.h

= notes =

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* when at steady state (i.e., multiple round trips of trains generated on demand) delete excess trains in overflow from furthest station. this station now generates trains on demand. Excess trains mean the total trains servicing the station should be round trip time times industry generation rate. At steady state, a train is returning to station as often as it is being generated, so any train in overflow is excess!
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

User:Maqifrnswa

2016-07-30T09:45:55Z

Maqifrnswa: /* cargo delivery to stations */

See my [[New Player Pointers]]

= game mechanics =
== cargo delivery to stations ==
Every day is 74 ticks. every 256 ticks cargo is delivered to stations (8 or 9 times a month, every 3.5 days). The default amount of cargo produced is in src/table/build_industry.h. The amount delivered can be 1/8, 1/4, 1/2, 1x, 2x, 4x, or 8x of the default value, depending on level of production.

Coal 15, Wood 13, Oil rig 15, oil well 12, livestock 10, Grain 10, copper 10, bank 6, gold 7, diamond 7, iron 10, water 12, maize 11.

So the max an industry can produce is ~1100/month (coal). More precisely, 0.46875 per tick = 18.75 per 40 ticks (one train load cycle). With 5 cargo loaded on to one train car per 40 ticks, 4 loading train cars (2 tiles) are needed to keep up with production. Those 2 tiles need to be constantly occupied, so parallel tracks are needed. Therefore, a station of 2 tracks for a train length of 3 should keep up with demand (although require a constant stream of trains!). To burn down demand, more tracks (or longer trains) would be needed.

== vehicle loading rates ==
When a vehicle is loading, cargo is loaded every: 40 ticks for trains, 20 ticks for planes/road vehicles, or 10 ticks for ships. Each individual train car adds cargo every loading event, so longer trains load more per tick than short trains. The default amount of cargo loaded is seen below:

{| class="wikitable"
|+Default Vehicle Loading Rates
|-
!Type
!Ticks per Load
!Units Cargo Loaded Per Load
|-
|Train
|40
|5
|-
|Road
|20
|5
|-
|Ship
|10
|10
|-
|Air
|20
|20 for all except mail (5 for mail)
|}
From: (src/economy.cpp "const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 }", order is enumerated in src/vehicle_type.h)
src/tables/engines.h. NewGRFs define the loading_speed property which is not visible in the client (maybe it should be?). It is in the item "property" or "graphics" setting. for example, brickwalker in NUTS has a loading_speed=2.

Air Mail is funky, according to src/economy.cpp

/* The default loadamount for mail is 1/4 of the load amount for passengers */
bool air_mail = v->type == VEH_AIRCRAFT && !Aircraft::From(v)->IsNormalAircraft();
if (air_mail) load_amount = CeilDiv(load_amount, 4);

From (src/aircraft_cmd.cpp), mail is carried by the airplane's shadow! that's why you need to check if it is not a normal aircraft (but its shadow!)

1 unit of cargo is defined in the default OpenGRF as:
{| class="wikitable"
! Cargo !! Multiplier !! Meaning
|-
| PASS || 4 || A vehicle carrying 1 ton of coal, can carry 4 passengers.
|-
| MAIL || 2 || A vehicle carrying 1 ton of coal, can carry 2 bags of mail.
|-
| GOOD, SWET || 2 || A vehicle carrying 1 ton of coal, can carry 2 crates of goods/sweets.
|-
| (everything else) || 1 || All other slots default to 1, i.e. 1 unit of cargo equals 1 ton of coal.
|}
source: https://newgrf-specs.tt-wiki.net/wiki/Action0Cargos and src/table/cargo_const.h

= notes =

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* when at steady state (i.e., multiple round trips of trains generated on demand) delete excess trains in overflow from furthest station. this station now generates trains on demand. Excess trains mean the total trains servicing the station should be round trip time times industry generation rate. At steady state, a train is returning to station as often as it is being generated, so any train in overflow is excess!
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

User:Maqifrnswa

2016-07-30T09:12:18Z

Maqifrnswa: /* vehicle loading rates */

See my [[New Player Pointers]]

= game mechanics =
== cargo delivery to stations ==
Every day is 74 ticks. every 256 ticks cargo is delivered to stations (8 or 9 times a month, every 3.5 days).

== vehicle loading rates ==
When a vehicle is loading, cargo is loaded every: 40 ticks for trains, 20 ticks for planes/road vehicles, or 10 ticks for ships. Each individual train car adds cargo every loading event, so longer trains load more per tick than short trains. The default amount of cargo loaded is seen below:

{| class="wikitable"
|+Default Vehicle Loading Rates
|-
!Type
!Ticks per Load
!Units Cargo Loaded Per Load
|-
|Train
|40
|5
|-
|Road
|20
|5
|-
|Ship
|10
|10
|-
|Air
|20
|20 for all except mail (5 for mail)
|}
From: (src/economy.cpp "const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 }", order is enumerated in src/vehicle_type.h)
src/tables/engines.h. NewGRFs define the loading_speed property which is not visible in the client (maybe it should be?). It is in the item "property" or "graphics" setting. for example, brickwalker in NUTS has a loading_speed=2.

Air Mail is funky, according to src/economy.cpp

/* The default loadamount for mail is 1/4 of the load amount for passengers */
bool air_mail = v->type == VEH_AIRCRAFT && !Aircraft::From(v)->IsNormalAircraft();
if (air_mail) load_amount = CeilDiv(load_amount, 4);

From (src/aircraft_cmd.cpp), mail is carried by the airplane's shadow! that's why you need to check if it is not a normal aircraft (but its shadow!)

1 unit of cargo is defined in the default OpenGRF as:
{| class="wikitable"
! Cargo !! Multiplier !! Meaning
|-
| PASS || 4 || A vehicle carrying 1 ton of coal, can carry 4 passengers.
|-
| MAIL || 2 || A vehicle carrying 1 ton of coal, can carry 2 bags of mail.
|-
| GOOD, SWET || 2 || A vehicle carrying 1 ton of coal, can carry 2 crates of goods/sweets.
|-
| (everything else) || 1 || All other slots default to 1, i.e. 1 unit of cargo equals 1 ton of coal.
|}
source: https://newgrf-specs.tt-wiki.net/wiki/Action0Cargos and src/table/cargo_const.h

= notes =

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* when at steady state (i.e., multiple round trips of trains generated on demand) delete excess trains in overflow from furthest station. this station now generates trains on demand. Excess trains mean the total trains servicing the station should be round trip time times industry generation rate. At steady state, a train is returning to station as often as it is being generated, so any train in overflow is excess!
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

User:Maqifrnswa

2016-07-30T09:10:39Z

Maqifrnswa:

See my [[New Player Pointers]]

= game mechanics =
== cargo delivery to stations ==
Every day is 74 ticks. every 256 ticks cargo is delivered to stations (8 or 9 times a month, every 3.5 days).

== vehicle loading rates ==
When a vehicle is loading, cargo is loaded every: 40 ticks for trains, 20 ticks for planes/road vehicles, or 10 ticks for ships. Each individual train car adds cargo every loading event, so longer trains load more per tick than short trains. The default amount of cargo loaded is seen below:

{| class="wikitable"
|+Default Vehicle Loading Rates
|-
!Type
!Ticks per Load
!Units Cargo Loaded Per Tick
|-
|Train
|40
|5
|-
|Road
|20
|5
|-
|Ship
|10
|10
|-
|Air
|20
|20 for all except mail (5 for mail)
|}
From: (src/economy.cpp "const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 }", order is enumerated in src/vehicle_type.h)
src/tables/engines.h. NewGRFs define the loading_speed property which is not visible in the client (maybe it should be?). It is in the item "property" or "graphics" setting. for example, brickwalker in NUTS has a loading_speed=2.

Air Mail is funky, according to src/economy.cpp

/* The default loadamount for mail is 1/4 of the load amount for passengers */
bool air_mail = v->type == VEH_AIRCRAFT && !Aircraft::From(v)->IsNormalAircraft();
if (air_mail) load_amount = CeilDiv(load_amount, 4);

From (src/aircraft_cmd.cpp), mail is carried by the airplane's shadow! that's why you need to check if it is not a normal aircraft (but its shadow!)

1 unit of cargo is defined in the default OpenGRF as:
{| class="wikitable"
! Cargo !! Multiplier !! Meaning
|-
| PASS || 4 || A vehicle carrying 1 ton of coal, can carry 4 passengers.
|-
| MAIL || 2 || A vehicle carrying 1 ton of coal, can carry 2 bags of mail.
|-
| GOOD, SWET || 2 || A vehicle carrying 1 ton of coal, can carry 2 crates of goods/sweets.
|-
| (everything else) || 1 || All other slots default to 1, i.e. 1 unit of cargo equals 1 ton of coal.
|}
source: https://newgrf-specs.tt-wiki.net/wiki/Action0Cargos and src/table/cargo_const.h

= notes =

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* when at steady state (i.e., multiple round trips of trains generated on demand) delete excess trains in overflow from furthest station. this station now generates trains on demand. Excess trains mean the total trains servicing the station should be round trip time times industry generation rate. At steady state, a train is returning to station as often as it is being generated, so any train in overflow is excess!
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

User:Maqifrnswa

2016-07-30T08:25:55Z

Maqifrnswa:

See my [[New Player Pointers]]

= game mechanics =
== cargo delivery to stations ==
Every day is 74 ticks. every 256 ticks cargo is delivered to stations (8 or 9 times a month, every 3.5 days).

== vehicle loading rates ==
When a vehicle is loading, cargo is loaded every: 40 ticks for trains, 20 ticks for planes/road vehicles, or 10 ticks for ships (src/economy.cpp "const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 }", order is enumerated in src/vehicle_type.h). Using default rules, 5 units of cargo are loaded per vehicle per tick ()

{| class="wikitable"
|+Default Vehicle Loading Rates
|-
!Type
!Ticks per Load
!Units Cargo Loaded Per Tick
|-
|Train
|40
|5
|-
|Road
|20
|5
|-
|Ship
|10
|10
|-
|Air
|20
|20
|}
From: (src/economy.cpp "const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 }", order is enumerated in src/vehicle_type.h)
src/tables/engines.h

1 unit of cargo is defined in the default OpenGRF as:
{| class="wikitable"
! Cargo slot !! Default cargo in this slot !! Property 1D !! Meaning
|-
| 00 || PASS || 0x400 || A vehicle carrying 1 ton of coal, can carry 4 passengers.
|-
| 02 || MAIL || 0x200 || A vehicle carrying 1 ton of coal, can carry 2 bags of mail.
|-
| 05 || GOOD, SWET || 0x200 || A vehicle carrying 1 ton of coal, can carry 2 crates of goods/sweets.
|-
| xx || (everything else) || 0x100 || All other slots default to 0x100, i.e. 1 unit of cargo equals 1 ton of coal.
|}
https://newgrf-specs.tt-wiki.net/wiki/Action0Cargos

= notes =

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* when at steady state (i.e., multiple round trips of trains generated on demand) delete excess trains in overflow from furthest station. this station now generates trains on demand. Excess trains mean the total trains servicing the station should be round trip time times industry generation rate. At steady state, a train is returning to station as often as it is being generated, so any train in overflow is excess!
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

User:Maqifrnswa

2016-07-28T18:52:02Z

Maqifrnswa:

See my [[New Player Pointers]]

research:
* 2 ticks per day
* 12 kL oil per tick

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* when at steady state (i.e., multiple round trips of trains generated on demand) delete excess trains in overflow from furthest station. this station now generates trains on demand. Excess trains mean the total trains servicing the station should be round trip time times industry generation rate. At steady state, a train is returning to station as often as it is being generated, so any train in overflow is excess!
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

User:Maqifrnswa

2016-07-28T18:50:36Z

Maqifrnswa:

See my [[New Player Pointers]]

research:
* 2 ticks per day
* 12 kL oil per tick

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* when at steady state (i.e., multiple round trips of trains generated on demand) delete excess trains in overflow from furthest station. this station now generates trains on demand. Excess trains mean the total trains servicing the station should be round trip time times industry generation rate
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

User:Maqifrnswa

2016-07-28T18:43:31Z

Maqifrnswa:

See my [[New Player Pointers]]

research:
* 2 ticks per day
* 12 kL oil per tick

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** min number of stations tracks determined by number of input tracks (make unload capacity = loading capacity)

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* delete excess trains in overflow from furthest station. this station now generates trains on demand.
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

User:Maqifrnswa

2016-07-28T18:42:07Z

Maqifrnswa:

See my [[New Player Pointers]]

research:
* 2 ticks per day
* 12 kL oil per tick

rate equiations

pick up station
* generation rate
* loading rate * station size
* what limits: track capacity, loading rate or generation rate?
** ideal, limit by generation rate. Generation rate determines min number of station tracks, and number of station tracks determines sideline size

Drop off station size
* limited by input capacity, which is = number of input tracks * max track capacity
** number of

clearing sideline jams:
* start with furthest station, make all other stations merge with sideline with priority given to furthest station
* optimize flow from furthest station (overload with trains such that waiting cargo goes to 0, and overflow is full. wait for steady state
* delete excess trains in overflow from furthest station. this station now generates trains on demand.
* move to next closest station, repeat.
* at end, each station will generate trains on demand. If, in steady state, on track never moves (because it has worst priority) - that means you need a second sideline. Start it from there, and all later stations merge with this new one.
* repeat
* if you added sideline out, will also need to add a new sideline in

Community:Members

2016-07-27T17:31:10Z

Maqifrnswa: /* The usual suspects around the Public Server (add yourself) */

__NOTOC__
==Active Members of #openttdcoop [19]==
*{{User|Ammler|ch}}, the one who dances with the newgrfs '''*'''
*{{User|dwarf|us}}, big brainmelt comes in small packages!
*{{User|Hylje|fi}}, the silent guy always and never around.
*{{User|Jam35|uk}}, who?
*{{User|KenjiE20|uk}}, the master of puppets, pulling your strings '''*'''
*{{User|LoPo|nl}}, the guy who does random shit.
*{{User|Maraxus|dk}}
*{{User|Mark|nl}}, occasional world traveler
*{{User|Mazur|nl}}, the senile one, who know nothing, no-thing! '''*'''
*{{User|mfb|de}}, always wants to try something new
*{{User|planetmaker|de}}, Make(file), newgrfs and patches '''*'''
*{{User|^Spike^|nl}}, the last Dutchy '''*'''
*{{User|StarLite|nl}} master of the magic roundabout that everybody fears ;-)
*{{User|Sylf|us}}, the oblivious, always getting into troubles
*{{User|Taede|uk}}, the Dutchy that decided to live in Scotland '''*'''
*{{User|tneo|nl}}, the spelling angel '''*'''
*{{User|V453000|cz}}, are you NUTS?
*{{User|Vinnie|nl}}, still needing a proper description here
*{{User|XeryusTC|nl}}, Rebellous doing-stuff-differently-from-convention type of guy '''*'''
''Note: '''*''' Admins have shell access to our servers, all others have rcon access''

==Honorary Members of #openttdcoop [3]==
*{{User|Brianetta|uk}} (our amiable host who is responsible for making #openttdcoop to such a vital community it is today) '''*'''
*{{User|Phoenix the II|nl}} (our host for the most busy [http://www.openttdcoop.org/blog/public-server/ PublicServer], thanks to him, we don't need to finish a game, because of the server limits.)
*{{User|TrueLight|nl}} (for being a bugfixer over ... a long time ;-) )

==Currently Inactive Members of #openttdcoop [20]==
*{{User|Adm.Spock|nl}} still too busy with other things in life, but "I'll be back"!
*{{User|Combuster|nl}} joins and parts the whole day '''*'''
*{{User|dihedral|de}}
*{{User|dp|de}}
*{{User|e1ko|cz}}
*{{User|Guru3|se}}
*{{User|Kommer|nl}}, we lost his exclusive love to openttd
*{{User|Mucht|at}}, the oldie who controlls our community from background.'''*'''
*{{User|ODM|nl}}, the innocent ''black'' lamb of #openttdcoop '''*'''
*{{User|Osai|de}}, doctor of the web and autopilot, who can hit back, if needed '''*'''
*{{User|ottd-king|uk}}
*{{User|Phazorx|iru}}, what does a communist in the tycoon world?
*{{User|Piratejerk|ca}}
*{{User|Progman|de}}, builds bigger networks on his Pentium2 at home, than 20 members on publicserver. '''*'''
*{{User|SmatZ|cz}}, pest-controller on all levels of OpenTTD(coop) '''*'''
*{{User|thgergo|hu}}, the one who builds bridges
*{{User|Thraxian|us}}, makes some little members
*{{User|uliko|se}}, omnipresent
*{{User|valhallasw|nl}}, BOFH, Wiki-god and mainly werkloos '''*'''
*{{User|xahodo|nl}}

==The usual suspects around the Public Server (add yourself) ==

{|
|-
| valign="top" |

*{{User|AlphaSC|de}}
*{{User|Absolutis|fi}}
*{{User|Benny|no}}
*{{User|britboy3456|uk}}
*{{User|Chris booth|uk}}
*{{User|Damalix|fr}}
*{{User|Clockworker|br}}
*{{User|Djanxy}}

|                  
|valign="top" |

*{{User|Dom|at}}
*{{User|Glevans2|us}}
*{{User|James|uk}}
*{{User|lol|uk}}
*{{User|mitooo|fr}}
*{{User|Maqifrnswa|us}}
*{{User|Maxtimbo|us}}
*{{User|Mmtunligit|us}}

|                  
|valign="top" |

*{{User|MrD2DG|uk}}
*{{User|Plonka|uk}}
*{{User|Ramsvs|uk}}
*{{User|Sian|dk}}
*{{User|Sistabossen|se}}
*{{User|scshunt}}
*{{User|solitaire|uk}}
*{{User|ZxBiohazardZx|nl}}

|                  
|valign="top" |

|}
''And of course all the others above!''

== Exsuspects & retired members ==
If you are on the ex-suspects list and you start playing again, please move yourself up to the suspects list !
If you are still active and on the ex-suspects list, sorry for the moving :) we sometimes cannot find an IRC log of you while you are still active

{|
|-
| valign="top" |

*{{User|A3aan|nl}}
*{{User|Addi|ch}}
*{{User|Alanin|de}}
*{{User|Alendo|no}}
*{{User|AlexanderB|nl}}
*{{User|Andyp|us}}
*{{User|AntB|uk}}
*{{User|Avdg|be}}
*{{User|Bob27|us}}
*{{User|Barbaar|nl}}
*{{User|ChrisM|de}}
*{{User|Cipri|nl}}
*{{User|Clifs|us}}
*{{User|csuke|uk}}
*{{User|Dark_Link|se}}
*{{User|Davil|at}}
*{{User|DCritic|us}}
*{{User|DJNekkid|no}}
*{{User|Doke|de}}
*{{User|Dopefish|de}}
*{{User|draconnier|lu}}
*{{User|einKarl|de}}
*{{User|eJoJ|no}}
*{{User|Elske|nl}}
*{{User|EmiT|cz}}
*{{User|F223|us}}
*{{User|Farden|fr}}
*{{User|Floffe|se}}
*{{User|fmauNeko|fr}}
*{{User|Franco|hu}}
*{{User|Fuco|sk}}
*{{User|Gamer|nl}}
*{{User|Giles|uk}}
*{{User|Gleeb|uk}}
*{{User|Godde|no}}
*{{User|Green-devil|dk}}
*{{User|Hans|nl}}
*{{User|hdp|us}}

|                  
|valign="top" |

*{{User|h3rzb1ut|de}}
*{{User|HanziQ|cz}}
*{{User|hzzzln|de}}
*{{User|Ichi|nl}}
*{{User|Ihmemies|fi}}
*{{User|Intexon|cz}}
*{{User|itsnotvalid|hk}}
*{{User|Jinx|be}}
*{{User|John|sk}}
*{{User|jondisti|fi}}
*{{User|Juustro|fi}}
*{{User|Kejhic|cz}}
*{{User|Kirov|ar}}
*{{User|Kolbur|de}}
*{{User|Kolo|pl}}
*{{User|Kul|nl}}
*{{User|Levi|de}}
*{{User|LittleMikey|au}}
*{{User|Logix|us}}
*{{User|LordAzamath|ee}}
*{{User|Macha|ie}}
*{{User|MDGrein|se}}
*{{User|mensi|ch}}
*{{User|Microshit|nl}}
*{{User|mixrin|ru}}
*{{User|MooUK|uk}}
*{{User|mrruben5|nl}}
*{{User|N101|au}}
*{{User|narc|ro}}
*{{User|Nazirro|pl}}
*{{User|Nickman|be}}
*{{User|Nitehawk|us}}
*{{User|OwenS|uk}}
*{{User|Petert|us}}
*{{User|Pikita|uk}}
*{{User|Phil|uk}}
*{{User|pugi|de}}
*{{User|RaWt|no}}

|                  
|valign="top" |

*{{User|Red|us}}
*{{User|RichK|uk}}
*{{User|RMJ|dk}}
*{{User|Rob|us}}
*{{User|Satyap|in}}
*{{User|sbn|be}}
*{{User|Sedontane|uk}}
*{{User|SerriaRomeo|us}}
*{{User|Shader|pl}}
*{{User|Skasi|at}}
*{{User|Skidd13|de}}
*{{User|S m w|de}}
*{{User|Spectre100|us}}
*{{User|Stoffe|se}}
*{{User|strstrep|us}}
*{{User|Talonius|uk}}
*{{User|Tautrimas|lt}}
*{{User|Teddy|no}}
*{{User|Thijs|nl}}
*{{User|thomashauk|uk}}
*{{User|Tim|de}}
*{{User|Torben Paw|dk}}
*{{User|Tussengas|nl}}
*{{User|UnderBuilder|ar}}
*{{User|Vinni3|uk}}
*{{User|Vitus|cz}}
*{{User|Volny|cz}}
*{{User|Walle|be}}
*{{User|welterde|de}}
*{{User|Wouterr|be}}
*{{User|Yso|ch}}
*{{User|Zakjan|cz}}
*{{User|ZarenorDarkstalker|us}}
*{{User|Zavior|fi}}
*{{User|Zerpa|dk}}
*{{User|Zuu|se}}

|}

Community:Members

2016-07-27T17:30:45Z

Maqifrnswa: /* The usual suspects around the Public Server (add yourself) */

__NOTOC__
==Active Members of #openttdcoop [19]==
*{{User|Ammler|ch}}, the one who dances with the newgrfs '''*'''
*{{User|dwarf|us}}, big brainmelt comes in small packages!
*{{User|Hylje|fi}}, the silent guy always and never around.
*{{User|Jam35|uk}}, who?
*{{User|KenjiE20|uk}}, the master of puppets, pulling your strings '''*'''
*{{User|LoPo|nl}}, the guy who does random shit.
*{{User|Maraxus|dk}}
*{{User|Mark|nl}}, occasional world traveler
*{{User|Mazur|nl}}, the senile one, who know nothing, no-thing! '''*'''
*{{User|mfb|de}}, always wants to try something new
*{{User|planetmaker|de}}, Make(file), newgrfs and patches '''*'''
*{{User|^Spike^|nl}}, the last Dutchy '''*'''
*{{User|StarLite|nl}} master of the magic roundabout that everybody fears ;-)
*{{User|Sylf|us}}, the oblivious, always getting into troubles
*{{User|Taede|uk}}, the Dutchy that decided to live in Scotland '''*'''
*{{User|tneo|nl}}, the spelling angel '''*'''
*{{User|V453000|cz}}, are you NUTS?
*{{User|Vinnie|nl}}, still needing a proper description here
*{{User|XeryusTC|nl}}, Rebellous doing-stuff-differently-from-convention type of guy '''*'''
''Note: '''*''' Admins have shell access to our servers, all others have rcon access''

==Honorary Members of #openttdcoop [3]==
*{{User|Brianetta|uk}} (our amiable host who is responsible for making #openttdcoop to such a vital community it is today) '''*'''
*{{User|Phoenix the II|nl}} (our host for the most busy [http://www.openttdcoop.org/blog/public-server/ PublicServer], thanks to him, we don't need to finish a game, because of the server limits.)
*{{User|TrueLight|nl}} (for being a bugfixer over ... a long time ;-) )

==Currently Inactive Members of #openttdcoop [20]==
*{{User|Adm.Spock|nl}} still too busy with other things in life, but "I'll be back"!
*{{User|Combuster|nl}} joins and parts the whole day '''*'''
*{{User|dihedral|de}}
*{{User|dp|de}}
*{{User|e1ko|cz}}
*{{User|Guru3|se}}
*{{User|Kommer|nl}}, we lost his exclusive love to openttd
*{{User|Mucht|at}}, the oldie who controlls our community from background.'''*'''
*{{User|ODM|nl}}, the innocent ''black'' lamb of #openttdcoop '''*'''
*{{User|Osai|de}}, doctor of the web and autopilot, who can hit back, if needed '''*'''
*{{User|ottd-king|uk}}
*{{User|Phazorx|iru}}, what does a communist in the tycoon world?
*{{User|Piratejerk|ca}}
*{{User|Progman|de}}, builds bigger networks on his Pentium2 at home, than 20 members on publicserver. '''*'''
*{{User|SmatZ|cz}}, pest-controller on all levels of OpenTTD(coop) '''*'''
*{{User|thgergo|hu}}, the one who builds bridges
*{{User|Thraxian|us}}, makes some little members
*{{User|uliko|se}}, omnipresent
*{{User|valhallasw|nl}}, BOFH, Wiki-god and mainly werkloos '''*'''
*{{User|xahodo|nl}}

==The usual suspects around the Public Server (add yourself) ==

{|
|-
| valign="top" |

*{{User|AlphaSC|de}}
*{{User|Absolutis|fi}}
*{{User|Benny|no}}
*{{User|britboy3456|uk}}
*{{User|Chris booth|uk}}
*{{User|Damalix|fr}}
*{{User|Clockworker|br}}
*{{User|Djanxy}}

|                  
|valign="top" |

*{{User|Dom|at}}
*{{User|Glevans2|us}}
*{{User|James|uk}}
*{{User|lol|uk}}
*{{User|mitooo|fr}}
*{{User|Maqifrnswa|us}}
*{{User|Maxtimbo|us}}
*{{User|Mmtunligit|us}}
*{{User|MrD2DG|uk}}

|                  
|valign="top" |

*{{User|Plonka|uk}}
*{{User|Ramsvs|uk}}
*{{User|Sian|dk}}
*{{User|Sistabossen|se}}
*{{User|scshunt}}
*{{User|solitaire|uk}}
*{{User|ZxBiohazardZx|nl}}

|                  
|valign="top" |

|}
''And of course all the others above!''

== Exsuspects & retired members ==
If you are on the ex-suspects list and you start playing again, please move yourself up to the suspects list !
If you are still active and on the ex-suspects list, sorry for the moving :) we sometimes cannot find an IRC log of you while you are still active

{|
|-
| valign="top" |

*{{User|A3aan|nl}}
*{{User|Addi|ch}}
*{{User|Alanin|de}}
*{{User|Alendo|no}}
*{{User|AlexanderB|nl}}
*{{User|Andyp|us}}
*{{User|AntB|uk}}
*{{User|Avdg|be}}
*{{User|Bob27|us}}
*{{User|Barbaar|nl}}
*{{User|ChrisM|de}}
*{{User|Cipri|nl}}
*{{User|Clifs|us}}
*{{User|csuke|uk}}
*{{User|Dark_Link|se}}
*{{User|Davil|at}}
*{{User|DCritic|us}}
*{{User|DJNekkid|no}}
*{{User|Doke|de}}
*{{User|Dopefish|de}}
*{{User|draconnier|lu}}
*{{User|einKarl|de}}
*{{User|eJoJ|no}}
*{{User|Elske|nl}}
*{{User|EmiT|cz}}
*{{User|F223|us}}
*{{User|Farden|fr}}
*{{User|Floffe|se}}
*{{User|fmauNeko|fr}}
*{{User|Franco|hu}}
*{{User|Fuco|sk}}
*{{User|Gamer|nl}}
*{{User|Giles|uk}}
*{{User|Gleeb|uk}}
*{{User|Godde|no}}
*{{User|Green-devil|dk}}
*{{User|Hans|nl}}
*{{User|hdp|us}}

|                  
|valign="top" |

*{{User|h3rzb1ut|de}}
*{{User|HanziQ|cz}}
*{{User|hzzzln|de}}
*{{User|Ichi|nl}}
*{{User|Ihmemies|fi}}
*{{User|Intexon|cz}}
*{{User|itsnotvalid|hk}}
*{{User|Jinx|be}}
*{{User|John|sk}}
*{{User|jondisti|fi}}
*{{User|Juustro|fi}}
*{{User|Kejhic|cz}}
*{{User|Kirov|ar}}
*{{User|Kolbur|de}}
*{{User|Kolo|pl}}
*{{User|Kul|nl}}
*{{User|Levi|de}}
*{{User|LittleMikey|au}}
*{{User|Logix|us}}
*{{User|LordAzamath|ee}}
*{{User|Macha|ie}}
*{{User|MDGrein|se}}
*{{User|mensi|ch}}
*{{User|Microshit|nl}}
*{{User|mixrin|ru}}
*{{User|MooUK|uk}}
*{{User|mrruben5|nl}}
*{{User|N101|au}}
*{{User|narc|ro}}
*{{User|Nazirro|pl}}
*{{User|Nickman|be}}
*{{User|Nitehawk|us}}
*{{User|OwenS|uk}}
*{{User|Petert|us}}
*{{User|Pikita|uk}}
*{{User|Phil|uk}}
*{{User|pugi|de}}
*{{User|RaWt|no}}

|                  
|valign="top" |

*{{User|Red|us}}
*{{User|RichK|uk}}
*{{User|RMJ|dk}}
*{{User|Rob|us}}
*{{User|Satyap|in}}
*{{User|sbn|be}}
*{{User|Sedontane|uk}}
*{{User|SerriaRomeo|us}}
*{{User|Shader|pl}}
*{{User|Skasi|at}}
*{{User|Skidd13|de}}
*{{User|S m w|de}}
*{{User|Spectre100|us}}
*{{User|Stoffe|se}}
*{{User|strstrep|us}}
*{{User|Talonius|uk}}
*{{User|Tautrimas|lt}}
*{{User|Teddy|no}}
*{{User|Thijs|nl}}
*{{User|thomashauk|uk}}
*{{User|Tim|de}}
*{{User|Torben Paw|dk}}
*{{User|Tussengas|nl}}
*{{User|UnderBuilder|ar}}
*{{User|Vinni3|uk}}
*{{User|Vitus|cz}}
*{{User|Volny|cz}}
*{{User|Walle|be}}
*{{User|welterde|de}}
*{{User|Wouterr|be}}
*{{User|Yso|ch}}
*{{User|Zakjan|cz}}
*{{User|ZarenorDarkstalker|us}}
*{{User|Zavior|fi}}
*{{User|Zerpa|dk}}
*{{User|Zuu|se}}

|}

User:Maqifrnswa

2016-07-27T17:30:02Z

Maqifrnswa: Created page with "See my New Player Pointers"

See my [[New Player Pointers]]

New Player Pointers

2016-07-27T17:28:30Z

Maqifrnswa: /* Merging (Load Balancing) */

New Player Pointers

2016-07-27T17:18:57Z

Maqifrnswa:

New Player Pointers

2016-07-27T16:50:40Z

Maqifrnswa: first draft