openttd-ottdgrfs: comparison src/rail

equal deleted inserted replaced

-:0b8b245a2391
+:1ac8aac92385
 	SIGTYPE_ENTRY   = 1, ///< presignal block entry
 	SIGTYPE_EXIT    = 2, ///< presignal block exit
 	SIGTYPE_COMBO   = 3  ///< presignal inter-block
 };
-static inline SignalType GetSignalType(TileIndex t)
+static inline SignalType GetSignalType(TileIndex t, Track track)
 {
 	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
-	return (SignalType)GB(_m[t].m2, 0, 2);
+	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
-}
+	return (SignalType)GB(_m[t].m2, pos, 2);
+}
-static inline void SetSignalType(TileIndex t, SignalType s)
+static inline void SetSignalType(TileIndex t, Track track, SignalType s)
 {
 	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
-	SB(_m[t].m2, 0, 2, s);
+	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 IsPresignalEntry(TileIndex t)
+}
-{
-	return GetSignalType(t) == SIGTYPE_ENTRY || GetSignalType(t) == SIGTYPE_COMBO;
+static inline bool IsPresignalEntry(TileIndex t, Track track)
-}
+{
+	return GetSignalType(t, track) == SIGTYPE_ENTRY || GetSignalType(t, track) == SIGTYPE_COMBO;
-static inline bool IsPresignalExit(TileIndex t)
+}
-{
-	return GetSignalType(t) == SIGTYPE_EXIT || GetSignalType(t) == 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;
+	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 6;
-	if (track == TRACK_LOWER || track == TRACK_RIGHT) pos = 4;
 	sig = GB(_m[t].m3, pos, 2);
 	if (--sig == 0) sig = 3;
 	SB(_m[t].m3, pos, 2, sig);
 }
 enum SignalVariant {
 	SIG_ELECTRIC  = 0, ///< Light signal
 	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);
+{
-}
+	byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 6 : 2;
+	SB(_m[t].m2, pos, 1, v);
-static inline bool IsSignalPresent(TileIndex t, byte signalbit)
+	if (track == INVALID_TRACK) SB(_m[t].m2, 6, 1, v);
-{
-	return HASBIT(_m[t].m3, signalbit + 4);
 }
 /** These are states in which a signal can be. Currently these are only two, so
 * simple boolean logic will do. But do try to compare to this enum instead of
 * normal boolean evaluation, since that will make future additions easier.
 enum SignalState {
 	SIGNAL_STATE_RED   = 0, ///< The signal is red
 	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
 * given rail tile.
 */
 static inline bool HasSignalOnTrack(TileIndex tile, Track track)
 {
 	assert(IsValidTrack(track));
 	return
 		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
-		(_m[tile].m3 & SignalOnTrack(track)) != 0;
+		(GetPresentSignals(tile) & SignalOnTrack(track)) != 0;
 }
 /**
 * Checks for the presence of signals along the given trackdir on the given
 * rail tile.
 static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)
 {
 	assert (IsValidTrackdir(trackdir));
 	return
 		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
-		_m[tile].m3 & SignalAlongTrackdir(trackdir);
+		GetPresentSignals(tile) & SignalAlongTrackdir(trackdir);
 }
 /**
 * Gets the state of the signal along the given trackdir.
 *
 */
 static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)
 {
 	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;
 }
 /**

branch	gamebalance
changeset 9912	1ac8aac92385
parent 9911	0b8b245a2391
child 9694	e72987579514