#openttdcoop wiki - User contributions [en]

File:CompacKerLogic.sav

2010-05-12T14:50:39Z

Scobos:

File:CompacKer3.sav

2010-05-12T14:40:10Z

Scobos:

User:Scobos

2010-05-11T20:46:50Z

Scobos: Created page with ''''Date of Birth:''' June 8, 1981 '''Location:''' New York, NY '''Started playing TT:''' May, 2010 '''Joined OpenTTDCoop:''' May, 2010 '''Strengths:''' Drinking '''Weakness:…'

'''Date of Birth:''' June 8, 1981

'''Location:''' New York, NY

'''Started playing TT:''' May, 2010

'''Joined OpenTTDCoop:''' May, 2010

'''Strengths:''' Drinking

'''Weakness:''' Drinking

'''Likes:''' Drinking

'''Dislikes:''' Running out of bourbon

Yield Line

2010-05-11T20:40:28Z

Scobos: /* The Construct */

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== Development ==
Any help is welcome on the idea or the write-up. There is a sample save game of both Fail Safe and non-Fail Safe varieties: [[File:Yield_FS.sav]] or [[File:Yield non-FS.sav]]

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|Yield Line Concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line Logic]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1" cellspacing="20"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
! X || Train Following || No Train Following
|-
! B || Train on ML Ahead || No Train on ML Ahead
|-
! C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

X: If there is a train behind us, we might be slow and should consider yielding.
If there is no train behind us, we probably aren't slow and can continue.

B: If there is a train right in front of us (who didn't yield), we probably aren't slow.
If there is no train right in front of us, we might be slow and should consider yielding.

C: If there is a train on the YL, he might be slow and we should try to pass! (Continue on ML)
If there is no train on the YL... well, this by itself doesn't really tell us much!
Also note that if we don't check for trains on the YL, as soon as the first train Yields, the ML becomes clear... which could result in every train taking the YL.

So the logic, first in words, then formula, is that we want:
(Train Will Yield) if (Train is Behind) and (No Train on ML) and (No Train on YL)
Q = X NAND B NAND C

which is the same as saying:
(Train Will Yield) if (Train is Behind) and [No Train on ML or YL]
Q = X AND (B NOR C)

Truth Table:
A = (No Train on ML or YL) = B NOR C
{| align="center" border="1" cellspacing="20"
! X !! A !! Q
|-
| 0 || 0 || 0
|-
| 0 || 1 || 0
|-
| 1 || 0 || 0
|-
| 1 || 1 || 1
|}

== The Construct ==
[[Image:YieldLineConstruct.png|thumb|right|200px|Yield Line in Action]]
Using the Logic Train newGRF and Osai's NOT and OR Gates, I was able to construct a sample Yield Line.

X should be placed more then 1 TL and less than 2 TL from Q. B and C can test as far down as you'd like (I used 2 TL). Don't forget a Penalty on the YL.

Currently, there are two main flaws, and two areas I haven't started work on. First flaw: the lead train in a group of all fast trains will yield to the other fast trains, and if using a simple prio to rejoin, will get passed by every train in the line. Unfortunately, this is a core design flaw. Second flaw: like most logic gates, this needs a Fail Safe, but it is fairly in-elegant to place it so close to "X," as I was forced to do to get the prototype working. Someone with a better idea for a FS (or a better way to check for X) might fix this. The area I haven't worked on yet is the re-join down the line. In the save-game, I put in a simple prio, but this is in-elegant. There should be a precise gap in the prio to allow for the situation (Flaw 1) of a fast train needing the re-join the head of the line and not yield priority. Second new area - it should be possible to queue slow trains in the Yield Line by using a more elegant check for C and having a better re-entry system. Even further, you could use this as a sorter to segregate fast and slow trains on different lines, if a method was developed to allow the fast trains in Flaw 1 back onto the correct track.

'''Pros:'''

Catches slow trains that are jamming the ML

Allows overtaking

'''Cons:'''

Low/Medium Traffic: Lead trains always yield

== Progress on Yield Line==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T20:37:30Z

Scobos: /* The Construct */

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== Development ==
Any help is welcome on the idea or the write-up. There is a sample save game of both Fail Safe and non-Fail Safe varieties: [[File:Yield_FS.sav]] or [[File:Yield non-FS.sav]]

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|Yield Line Concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line Logic]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1" cellspacing="20"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
! X || Train Following || No Train Following
|-
! B || Train on ML Ahead || No Train on ML Ahead
|-
! C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

X: If there is a train behind us, we might be slow and should consider yielding.
If there is no train behind us, we probably aren't slow and can continue.

B: If there is a train right in front of us (who didn't yield), we probably aren't slow.
If there is no train right in front of us, we might be slow and should consider yielding.

C: If there is a train on the YL, he might be slow and we should try to pass! (Continue on ML)
If there is no train on the YL... well, this by itself doesn't really tell us much!
Also note that if we don't check for trains on the YL, as soon as the first train Yields, the ML becomes clear... which could result in every train taking the YL.

So the logic, first in words, then formula, is that we want:
(Train Will Yield) if (Train is Behind) and (No Train on ML) and (No Train on YL)
Q = X NAND B NAND C

which is the same as saying:
(Train Will Yield) if (Train is Behind) and [No Train on ML or YL]
Q = X AND (B NOR C)

Truth Table:
A = (No Train on ML or YL) = B NOR C
{| align="center" border="1" cellspacing="20"
! X !! A !! Q
|-
| 0 || 0 || 0
|-
| 0 || 1 || 0
|-
| 1 || 0 || 0
|-
| 1 || 1 || 1
|}

== The Construct ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line in Action]]
Using the Logic Train newGRF and Osai's NOT and OR Gates, I was able to construct a sample Yield Line.

X should be placed more then 1 TL and less than 2 TL from Q. B and C can test as far down as you'd like (I used 2 TL). Don't forget a Penalty on the YL.

Currently, there are two main flaws, and two areas I haven't started work on. First flaw: the lead train in a group of all fast trains will yield to the other fast trains, and if using a simple prio to rejoin, will get passed by every train in the line. Unfortunately, this is a core design flaw. Second flaw: like most logic gates, this needs a Fail Safe, but it is fairly in-elegant to place it so close to "X," as I was forced to do to get the prototype working. Someone with a better idea for a FS (or a better way to check for X) might fix this. The area I haven't worked on yet is the re-join down the line. In the save-game, I put in a simple prio, but this is in-elegant. There should be a precise gap in the prio to allow for the situation (Flaw 1) of a fast train needing the re-join the head of the line and not yield priority. Second new area - it should be possible to queue slow trains in the Yield Line by using a more elegant check for C and having a better re-entry system. Even further, you could use this as a sorter to segregate fast and slow trains on different lines, if a method was developed to allow the fast trains in Flaw 1 back onto the correct track.

'''Pros:'''

Catches slow trains that are jamming the ML

Allows overtaking

'''Cons:'''

Low/Medium Traffic: Lead trains always yield

== Progress on Yield Line==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T20:37:04Z

Scobos: /* The Construct */

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== Development ==
Any help is welcome on the idea or the write-up. There is a sample save game of both Fail Safe and non-Fail Safe varieties: [[File:Yield_FS.sav]] or [[File:Yield non-FS.sav]]

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|Yield Line Concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line Logic]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1" cellspacing="20"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
! X || Train Following || No Train Following
|-
! B || Train on ML Ahead || No Train on ML Ahead
|-
! C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

X: If there is a train behind us, we might be slow and should consider yielding.
If there is no train behind us, we probably aren't slow and can continue.

B: If there is a train right in front of us (who didn't yield), we probably aren't slow.
If there is no train right in front of us, we might be slow and should consider yielding.

C: If there is a train on the YL, he might be slow and we should try to pass! (Continue on ML)
If there is no train on the YL... well, this by itself doesn't really tell us much!
Also note that if we don't check for trains on the YL, as soon as the first train Yields, the ML becomes clear... which could result in every train taking the YL.

So the logic, first in words, then formula, is that we want:
(Train Will Yield) if (Train is Behind) and (No Train on ML) and (No Train on YL)
Q = X NAND B NAND C

which is the same as saying:
(Train Will Yield) if (Train is Behind) and [No Train on ML or YL]
Q = X AND (B NOR C)

Truth Table:
A = (No Train on ML or YL) = B NOR C
{| align="center" border="1" cellspacing="20"
! X !! A !! Q
|-
| 0 || 0 || 0
|-
| 0 || 1 || 0
|-
| 1 || 0 || 0
|-
| 1 || 1 || 1
|}

== The Construct ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line in Action]]
Using the Logic Train newGRF and Osai's NOT and OR Gates, I was able to construct a sample Yield Line.

X should be placed more then 1 TL and less than 2 TL from Q. B and C can test as far down as you'd like (I used 2 TL). Don't forget a Penalty on the YL.

Currently, there are two main flaws, and two areas I haven't started work on. First flaw: the lead train in a group of all fast trains will yield to the other fast trains, and if using a simple prio to rejoin, will get passed by every train in the line. Unfortunately, this is a core design flaw. Second flaw: like most logic gates, this needs a Fail Safe, but it is fairly in-elegant to place it so close to "X," as I was forced to do to get the prototype working. Someone with a better idea for a FS (or a better way to check for X) might fix this. The area I haven't worked on yet is the re-join down the line. In the save-game, I put in a simple prio, but this is in-elegant. There should be a precise gap in the prio to allow for the situation (Flaw 1) of a fast train needing the re-join the head of the line and not yield priority. Second new area - it should be possible to queue slow trains in the Yield Line by using a more elegant check for C and having a better re-entry system. Even further, you could use this as a sorter to segregate fast and slow trains on different lines, if a method was developed to allow the fast trains in Flaw 1 back onto the correct track.

'''Pros:'''

Catches slow trains that are jamming the ML

Allows overtaking

'''Cons:'''
Low/Medium Traffic: Lead trains always yield

== Progress on Yield Line==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T20:35:57Z

Scobos:

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== Development ==
Any help is welcome on the idea or the write-up. There is a sample save game of both Fail Safe and non-Fail Safe varieties: [[File:Yield_FS.sav]] or [[File:Yield non-FS.sav]]

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|Yield Line Concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line Logic]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1" cellspacing="20"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
! X || Train Following || No Train Following
|-
! B || Train on ML Ahead || No Train on ML Ahead
|-
! C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

X: If there is a train behind us, we might be slow and should consider yielding.
If there is no train behind us, we probably aren't slow and can continue.

B: If there is a train right in front of us (who didn't yield), we probably aren't slow.
If there is no train right in front of us, we might be slow and should consider yielding.

C: If there is a train on the YL, he might be slow and we should try to pass! (Continue on ML)
If there is no train on the YL... well, this by itself doesn't really tell us much!
Also note that if we don't check for trains on the YL, as soon as the first train Yields, the ML becomes clear... which could result in every train taking the YL.

So the logic, first in words, then formula, is that we want:
(Train Will Yield) if (Train is Behind) and (No Train on ML) and (No Train on YL)
Q = X NAND B NAND C

which is the same as saying:
(Train Will Yield) if (Train is Behind) and [No Train on ML or YL]
Q = X AND (B NOR C)

Truth Table:
A = (No Train on ML or YL) = B NOR C
{| align="center" border="1" cellspacing="20"
! X !! A !! Q
|-
| 0 || 0 || 0
|-
| 0 || 1 || 0
|-
| 1 || 0 || 0
|-
| 1 || 1 || 1
|}

== The Construct ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line in Action]]
Using the Logic Train newGRF and Osai's NOT and OR Gates, I was able to construct a sample Yield Line.

X should be placed more then 1 TL and less than 2 TL from Q. B and C can test as far down as you'd like (I used 2 TL). Don't forget a Penalty on the YL.

Currently, there are two main flaws, and two areas I haven't started work on. First flaw: the lead train in a group of all fast trains will yield to the other fast trains, and if using a simple prio to rejoin, will get passed by every train in the line. Unfortunately, this is a core design flaw. Second flaw: like most logic gates, this needs a Fail Safe, but it is fairly in-elegant to place it so close to "X," as I was forced to do to get the prototype working. Someone with a better idea for a FS (or a better way to check for X) might fix this. The area I haven't worked on yet is the re-join down the line. In the save-game, I put in a simple prio, but this is in-elegant. There should be a precise gap in the prio to allow for the situation (Flaw 1) of a fast train needing the re-join the head of the line and not yield priority. Second new area - it should be possible to queue slow trains in the Yield Line by using a more elegant check for C and having a better re-entry system. Even further, you could use this as a sorter to segregate fast and slow trains on different lines, if a method was developed to allow the fast trains in Flaw 1 back onto the correct track.

'''Pros:'''
Catches slow trains that are jamming the ML
Allows overtaking

'''Cons:'''
Low/Medium Traffic: Lead trains always yield

== Progress on Yield Line==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

File:Yield non-FS.sav

2010-05-11T20:32:16Z

Scobos:

File:Yield FS.sav

2010-05-11T20:31:53Z

Scobos:

Yield Line

2010-05-11T20:31:03Z

Scobos:

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|Yield Line Concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line Logic]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1" cellspacing="20"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
! X || Train Following || No Train Following
|-
! B || Train on ML Ahead || No Train on ML Ahead
|-
! C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

X: If there is a train behind us, we might be slow and should consider yielding.
If there is no train behind us, we probably aren't slow and can continue.

B: If there is a train right in front of us (who didn't yield), we probably aren't slow.
If there is no train right in front of us, we might be slow and should consider yielding.

C: If there is a train on the YL, he might be slow and we should try to pass! (Continue on ML)
If there is no train on the YL... well, this by itself doesn't really tell us much!
Also note that if we don't check for trains on the YL, as soon as the first train Yields, the ML becomes clear... which could result in every train taking the YL.

So the logic, first in words, then formula, is that we want:
(Train Will Yield) if (Train is Behind) and (No Train on ML) and (No Train on YL)
Q = X NAND B NAND C

which is the same as saying:
(Train Will Yield) if (Train is Behind) and [No Train on ML or YL]
Q = X AND (B NOR C)

Truth Table:
A = (No Train on ML or YL) = B NOR C
{| align="center" border="1" cellspacing="20"
! X !! A !! Q
|-
| 0 || 0 || 0
|-
| 0 || 1 || 0
|-
| 1 || 0 || 0
|-
| 1 || 1 || 1
|}

== The Construct ==
[[Image:YieldLineLogic.png|thumb|right|200px|Yield Line in Action]]
Using the Logic Train newGRF and Osai's NOT and OR Gates, I was able to construct a sample Yield Line.

X should be placed more then 1 TL and less than 2 TL from Q. B and C can test as far down as you'd like (I used 2 TL). Don't forget a Penalty on the YL.

Currently, there are two main flaws, and two areas I haven't started work on. First flaw: the lead train in a group of all fast trains will yield to the other fast trains, and if using a simple prio to rejoin, will get passed by every train in the line. Unfortunately, this is a core design flaw. Second flaw: like most logic gates, this needs a Fail Safe, but it is fairly in-elegant to place it so close to "X," as I was forced to do to get the prototype working. Someone with a better idea for a FS (or a better way to check for X) might fix this. The area I haven't worked on yet is the re-join down the line. In the save-game, I put in a simple prio, but this is in-elegant. There should be a precise gap in the prio to allow for the situation (Flaw 1) of a fast train needing the re-join the head of the line and not yield priority. Second new area - it should be possible to queue slow trains in the Yield Line by using a more elegant check for C and having a better re-entry system. Even further, you could use this as a sorter to segregate fast and slow trains on different lines, if a method was developed to allow the fast trains in Flaw 1 back onto the correct track.

'''Pros:'''
Catches slow trains that are jamming the ML
Allows overtaking

'''Cons:'''
Low/Medium Traffic: Lead trains always yield

== Progress on Yield Line==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

File:YieldLineConstruct.png

2010-05-11T20:16:52Z

Scobos:

Yield Line

2010-05-11T20:15:23Z

Scobos: /* The Logic */

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|The joiner concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|The joiner concept]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1" cellspacing="20"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
! X || Train Following || No Train Following
|-
! B || Train on ML Ahead || No Train on ML Ahead
|-
! C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

X: If there is a train behind us, we might be slow and should consider yielding.
If there is no train behind us, we probably aren't slow and can continue.

B: If there is a train right in front of us (who didn't yield), we probably aren't slow.
If there is no train right in front of us, we might be slow and should consider yielding.

C: If there is a train on the YL, he might be slow and we should try to pass! (Continue on ML)
If there is no train on the YL... well, this by itself doesn't really tell us much!

So the logic, first in words, then formula, is that we want:
(Train Will Yield) if (Train is Behind) and (No Train on ML) and (No Train on YL)
Q = X NAND B NAND C

which is the same as saying:
(Train Will Yield) if (Train is Behind) and [No Train on ML or YL]
Q = X AND (B NOR C)

Truth Table:
A = (No Train on ML or YL) = B NOR C
{| align="center" border="1" cellspacing="20"
! X !! A !! Q
|-
| 0 || 0 || 0
|-
| 0 || 1 || 0
|-
| 1 || 0 || 0
|-
| 1 || 1 || 1
|}

'''Pros:'''

'''Cons:'''

== Progress on joiners ==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T20:13:45Z

Scobos: /* The Logic */

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|The joiner concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|The joiner concept]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
| X || Train Following || No Train Following
|-
| B || Train on ML Ahead || No Train on ML Ahead
|-
| C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

X: If there is a train behind us, we might be slow and should consider yielding.
If there is no train behind us, we probably aren't slow and can continue.

B: If there is a train right in front of us (who didn't yield), we probably aren't slow.
If there is no train right in front of us, we might be slow and should consider yielding.

C: If there is a train on the YL, he might be slow and we should try to pass! (Continue on ML)
If there is no train on the YL... well, this by itself doesn't really tell us much!

So the logic, first in words, then formula, is that we want:
(Train Will Yield) if (Train is Behind) and (No Train on ML) and (No Train on YL)
Q = X NAND B NAND C

which is the same as saying:
(Train Will Yield) if (Train is Behind) and [No Train on ML or YL]
Q = X AND (B NOR C)

Truth Table:
A = (No Train on ML or YL) = B NOR C
{| align="center" border="1" celpadding="40"
! X !! A !! Q
|-
| 0 || 0 || 0
|-
| 0 || 1 || 0
|-
| 1 || 0 || 0
|-
| 1 || 1 || 1
|}

'''Pros:'''

'''Cons:'''

== Progress on joiners ==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T19:59:18Z

Scobos: /* The Logic */

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|The joiner concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|The joiner concept]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
| X || Train Following || No Train Following
|-
| B || Train on ML Ahead || No Train on ML Ahead
|-
| C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

'''Pros:'''

'''Cons:'''

== Progress on joiners ==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T19:55:50Z

Scobos: /* The Logic */

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|The joiner concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|The joiner concept]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| align="center" border="1"
! !! 1 !! 0
|-
! Q || Will Yield || Will Not Yield
|-
! X || Train Following || No Train Following
|-
! B || Train on ML Ahead || No Train on ML Ahead
|-
! C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

'''Pros:'''

'''Cons:'''

== Progress on joiners ==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T19:52:44Z

Scobos: /* The Logic */

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|The joiner concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|The joiner concept]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| border="1"
! !! 1 !! 0
|-
| Q || Will Yield || Will Not Yield
| X || Train Following || No Train Following
| B || Train on ML Ahead || No Train on ML Ahead
| C || Train on YL || No Train on YL
|}

'''Why These Inputs Matter'''

'''Pros:'''

'''Cons:'''

== Progress on joiners ==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T19:50:41Z

Scobos:

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|The joiner concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==
[[Image:YieldLineLogic.png|thumb|right|200px|The joiner concept]]
Q is the Entry Combo Signal that determines whether a train can continue on the ML or must go to the Yield Line (YL). Note the penalty on the YL.

Using Osai's definition of 0 for Green and 1 for Red:
{| border="1"
! &nbsp !! 1 !! 0
|-
! Q
| Will Yield || Will Not Yield
|-
! X
| Train Following || No Train Following
! B
| Train on ML Ahead || No Train on ML Ahead
! C
| Train on YL || No Train on YL
|}

'''Bold text'''Why These Inputs Matter

'''Pros:'''

'''Cons:'''

== Progress on joiners ==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

File:YieldLineLogic.png

2010-05-11T19:29:33Z

Scobos:

Yield Line

2010-05-11T19:27:26Z

Scobos:

''by [[User:scobos|scobos]]

== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|The joiner concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==

'''Pros:'''

'''Cons:'''

== Progress on joiners ==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

Yield Line

2010-05-11T19:26:33Z

Scobos: Created page with '''by scobos --~~~~ == Overview == Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side a…'

''by [[User:scobos|scobos]]
--[[User:Scobos|Scobos]] 19:26, 11 May 2010 (UTC)
== Overview ==
Yield Lines are temporary extra tracks than run parallel to a ML or SL. The idea is force slow(er) trains to move to the side and allow fast(er) trains to pass.

== The Concept ==

[[Image:YieldLineConcept.png|thumb|right|200px|The joiner concept]]
Often a ML or SL can become slightly jammed by the presence of slower trains. This can happen when trains are out of date and haven't replaced yet, or simply when they are carrying full loads back to a drop on the same line as empty trains. Ideally, we would be able to separate trains to different tracks based on speed. Since currently this is not possible, a theoretical work-around is to separate trains based on Gap Distance.

As a slower train continue down a ML or SL, traffic builds up behind them, but a Gap opens in front of them (as faster trains move ahead). Therefore, we can assume that if there is a large Gap in front of a train, and no Gap behind it, it is probably a slow train. Now the only question is how to sort it.

== The Logic ==

'''Pros:'''

'''Cons:'''

== Progress on joiners ==
{{R&D_header|R&D Overview}}
{{R&D_content|Yield Line|[[User:scobos|scobos]]|wip|Currently Editing|unclaimed||unclaimed|| | }}
{{R&D_footer}}
[[Category:Research]]

File:YieldLineConcept.png

2010-05-11T19:15:43Z

Scobos:

Presignal Basics

2010-05-10T23:28:57Z

Scobos: Typo - "five type of signals" when six are listed

=<center>Presignal Basics</center>=
The Presignal Basics is explained here: how they work, how they behave, and how does work a terminal station, and whats the use of the combo presignal.

==Part 1: Identify the signals==
There are six types of signals in OTTD. If you click on a normal signal with CTRL is held, these signals will appear:

'''Normal Signal''': It does not have any special alibity, it turns to red if the next signal block is blocked by any train.

'''Entry Presignal''': It works like a normal signal, plus it turns to red if all exit presignals, or combo presignals are red after it.

'''Exit Presignal''': It works same as normal signal, but it signs for the entry, or combo signals, if self is red.

'''Combo Presignal''': It has both Entry and Exit presignal alibities: It turns to red if all Exit/Combo are red after it, and it signs for the Entry/Combo Presignals, if the self is red.

'''PBS Signal ''': Not a Presignal, it enables more trains in one signal block, since PBS means Path Based Signaling. This type of signal is not explained here.

'''One-Way PBS Signal ''': It works like a PBS Signal, however, it prohibits passing through from the back side. This type of signal is not explained here.

[[Image:Signals_revised.png|thumb|center|388px|Different signal types]]

==Part 2: The Station Problem==
Stations without any presignals have a big problem: just have a look on the Image to the below. Signal A should be red...[[Image:Terminal1.png|270px|center|thumb|Problem at stations without Presignals]]
If you let one more train to enter into the station, it will block the exit, because A signal is green. This problem is solvable with presignals: Just turn A into Entry presignal, and turn B and C signals to exit signals. [[Image:Terminal2.png|276px|center|thumb|Station with Presignals]] How does it work? If Exit Presignals B, C are both red, then Entry Presignal A is red too. Then a third train cannot pass trough Signal A.

==Part 3: An Effective RoRo station==
Combo Presignals are mostly placed between Entry, and Exit presignals, because the Combo Presignals transmits the Exit presignal signs for the Entry Presignals. Combo presignals behave as an entry presignal and an exit presignal both.[[Image:RORO1.png|center|thumb|526px|RORO station]] In the Image above, signal A is Entry Presignal, signals B, C, D, E are Combo ones, and F-K are Exit Presignals.

If F and G Platforms are used, then Combo signal B uses its Entry Presignal alibity, and it will turn to red, because F, and G Exit Presignals are both red. But the Entry Presignal A is remains green. Exit presignals H-K are green, then Combo Presignals D, E is green, then Signal C is green too. With this Combo Presignal B is red and C is green, then the Entry Presignal A is remains green.[[Image:RORO2.png|center|thumb|526px|The Entry remains green]]

The Entry Presignal A will be red only, if all Platforms are used, Exit Presignals F-K are red. If F-K are red, then all Combo Presignals B-E are red too, then the Entry A will be red.[[Image:RORO3.png|center|thumb|520px|All Platforms red]]

== ==
[[Guides|<< Back to Index ]] | [[Oneway_or_Twoway_Presignals| Part 2: Oneway or Twoway Presignals >>]]
[[Category:Guides]]