--- a/src/rail_map.h	Fri May 25 00:25:08 2007 +0000
+++ b/src/rail_map.h	Fri Jun 01 20:54:09 2007 +0000
@@ -207,33 +207,35 @@
 	SIGTYPE_COMBO   = 3  ///< presignal inter-block
 };
 
-static inline SignalType GetSignalType(TileIndex t)
-{
-	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
-	return (SignalType)GB(_m[t].m2, 0, 2);
-}
-
-static inline void SetSignalType(TileIndex t, SignalType s)
+static inline SignalType GetSignalType(TileIndex t, Track track)
 {
 	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
-	SB(_m[t].m2, 0, 2, s);
+	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
+	return (SignalType)GB(_m[t].m2, pos, 2);
 }
 
-static inline bool IsPresignalEntry(TileIndex t)
+static inline void SetSignalType(TileIndex t, Track track, SignalType s)
 {
-	return GetSignalType(t) == SIGTYPE_ENTRY || GetSignalType(t) == SIGTYPE_COMBO;
+	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
+	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
+	SB(_m[t].m2, pos, 2, s);
+	if (track == INVALID_TRACK) SB(_m[t].m2, 4, 2, s);
 }
 
-static inline bool IsPresignalExit(TileIndex t)
+static inline bool IsPresignalEntry(TileIndex t, Track track)
 {
-	return GetSignalType(t) == SIGTYPE_EXIT || GetSignalType(t) == SIGTYPE_COMBO;
+	return GetSignalType(t, track) == SIGTYPE_ENTRY || GetSignalType(t, track) == SIGTYPE_COMBO;
+}
+
+static inline bool IsPresignalExit(TileIndex t, Track track)
+{
+	return GetSignalType(t, track) == SIGTYPE_EXIT || GetSignalType(t, track) == SIGTYPE_COMBO;
 }
 
 static inline void CycleSignalSide(TileIndex t, Track track)
 {
 	byte sig;
-	byte pos = 6;
-	if (track == TRACK_LOWER || track == TRACK_RIGHT) pos = 4;
+	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 6;
 
 	sig = GB(_m[t].m3, pos, 2);
 	if (--sig == 0) sig = 3;
@@ -246,19 +248,17 @@
 	SIG_SEMAPHORE = 1  ///< Old-fashioned semaphore signal
 };
 
-static inline SignalVariant GetSignalVariant(TileIndex t)
+static inline SignalVariant GetSignalVariant(TileIndex t, Track track)
 {
-	return (SignalVariant)GB(_m[t].m2, 2, 1);
+	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 6 : 2;
+	return (SignalVariant)GB(_m[t].m2, pos, 1);
 }
 
-static inline void SetSignalVariant(TileIndex t, SignalVariant v)
+static inline void SetSignalVariant(TileIndex t, Track track, SignalVariant v)
 {
-	SB(_m[t].m2, 2, 1, v);
-}
-
-static inline bool IsSignalPresent(TileIndex t, byte signalbit)
-{
-	return HASBIT(_m[t].m3, signalbit + 4);
+	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 6 : 2;
+	SB(_m[t].m2, pos, 1, v);
+	if (track == INVALID_TRACK) SB(_m[t].m2, 6, 1, v);
 }
 
 /** These are states in which a signal can be. Currently these are only two, so
@@ -270,11 +270,67 @@
 	SIGNAL_STATE_GREEN = 1, ///< The signal is green
 };
 
+/**
+ * Set the states of the signals (Along/AgainstTrackDir)
+ * @param tile  the tile to set the states for
+ * @param state the new state
+ */
+static inline void SetSignalStates(TileIndex tile, uint state)
+{
+	SB(_m[tile].m4, 4, 4, state);
+}
+
+/**
+ * Set the states of the signals (Along/AgainstTrackDir)
+ * @param tile  the tile to set the states for
+ * @param state the new state
+ */
+static inline uint GetSignalStates(TileIndex tile)
+{
+	return GB(_m[tile].m4, 4, 4);
+}
+
+/**
+ * Get the state of a single signal
+ * @param t         the tile to get the signal state for
+ * @param signalbit the signal
+ * @return the state of the signal
+ */
 static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)
 {
-	return (SignalState)HASBIT(_m[t].m2, signalbit + 4);
+	return (SignalState)HASBIT(GetSignalStates(t), signalbit);
 }
 
+/**
+ * Set whether the given signals are present (Along/AgainstTrackDir)
+ * @param tile    the tile to set the present signals for
+ * @param signals the signals that have to be present
+ */
+static inline void SetPresentSignals(TileIndex tile, uint signals)
+{
+	SB(_m[tile].m3, 4, 4, signals);
+}
+
+/**
+ * Get whether the given signals are present (Along/AgainstTrackDir)
+ * @param tile the tile to get the present signals for
+ * @return the signals that are present
+ */
+static inline uint GetPresentSignals(TileIndex tile)
+{
+	return GB(_m[tile].m3, 4, 4);
+}
+
+/**
+ * Checks whether the given signals is present
+ * @param t         the tile to check on
+ * @param signalbit the signal
+ * @return true if and only if the signal is present
+ */
+static inline bool IsSignalPresent(TileIndex t, byte signalbit)
+{
+	return HASBIT(GetPresentSignals(t), signalbit);
+}
 
 /**
  * Checks for the presence of signals (either way) on the given track on the
@@ -285,7 +341,7 @@
 	assert(IsValidTrack(track));
 	return
 		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
-		(_m[tile].m3 & SignalOnTrack(track)) != 0;
+		(GetPresentSignals(tile) & SignalOnTrack(track)) != 0;
 }
 
 /**
@@ -300,7 +356,7 @@
 	assert (IsValidTrackdir(trackdir));
 	return
 		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
-		_m[tile].m3 & SignalAlongTrackdir(trackdir);
+		GetPresentSignals(tile) & SignalAlongTrackdir(trackdir);
 }
 
 /**
@@ -313,7 +369,7 @@
 {
 	assert(IsValidTrackdir(trackdir));
 	assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));
-	return _m[tile].m2 & SignalAlongTrackdir(trackdir) ?
+	return GetSignalStates(tile) & SignalAlongTrackdir(trackdir) ?
 		SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;
 }