rail_map.h

Go to the documentation of this file.
00001 /* $Id: rail_map.h 17579 2009-09-19 15:17:47Z rubidium $ */
00002 
00003 /*
00004  * This file is part of OpenTTD.
00005  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
00006  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
00008  */
00009 
00012 #ifndef RAIL_MAP_H
00013 #define RAIL_MAP_H
00014 
00015 #include "rail_type.h"
00016 #include "depot_type.h"
00017 #include "signal_func.h"
00018 #include "direction_func.h"
00019 #include "track_func.h"
00020 #include "tile_map.h"
00021 #include "signal_type.h"
00022 
00023 
00025 enum RailTileType {
00026   RAIL_TILE_NORMAL   = 0, 
00027   RAIL_TILE_SIGNALS  = 1, 
00028   RAIL_TILE_DEPOT    = 3, 
00029 };
00030 
00038 static inline RailTileType GetRailTileType(TileIndex t)
00039 {
00040   assert(IsTileType(t, MP_RAILWAY));
00041   return (RailTileType)GB(_m[t].m5, 6, 2);
00042 }
00043 
00051 static inline bool IsPlainRail(TileIndex t)
00052 {
00053   RailTileType rtt = GetRailTileType(t);
00054   return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_SIGNALS;
00055 }
00056 
00062 static inline bool IsPlainRailTile(TileIndex t)
00063 {
00064   return IsTileType(t, MP_RAILWAY) && IsPlainRail(t);
00065 }
00066 
00067 
00074 static inline bool HasSignals(TileIndex t)
00075 {
00076   return GetRailTileType(t) == RAIL_TILE_SIGNALS;
00077 }
00078 
00085 static inline void SetHasSignals(TileIndex tile, bool signals)
00086 {
00087   assert(IsPlainRailTile(tile));
00088   SB(_m[tile].m5, 6, 1, signals);
00089 }
00090 
00097 static inline bool IsRailDepot(TileIndex t)
00098 {
00099   return GetRailTileType(t) == RAIL_TILE_DEPOT;
00100 }
00101 
00107 static inline bool IsRailDepotTile(TileIndex t)
00108 {
00109   return IsTileType(t, MP_RAILWAY) && IsRailDepot(t);
00110 }
00111 
00117 static inline RailType GetRailType(TileIndex t)
00118 {
00119   return (RailType)GB(_m[t].m3, 0, 4);
00120 }
00121 
00127 static inline void SetRailType(TileIndex t, RailType r)
00128 {
00129   SB(_m[t].m3, 0, 4, r);
00130 }
00131 
00132 
00138 static inline TrackBits GetTrackBits(TileIndex tile)
00139 {
00140   assert(IsPlainRailTile(tile));
00141   return (TrackBits)GB(_m[tile].m5, 0, 6);
00142 }
00143 
00149 static inline void SetTrackBits(TileIndex t, TrackBits b)
00150 {
00151   assert(IsPlainRailTile(t));
00152   SB(_m[t].m5, 0, 6, b);
00153 }
00154 
00162 static inline bool HasTrack(TileIndex tile, Track track)
00163 {
00164   return HasBit(GetTrackBits(tile), track);
00165 }
00166 
00173 static inline DiagDirection GetRailDepotDirection(TileIndex t)
00174 {
00175   return (DiagDirection)GB(_m[t].m5, 0, 2);
00176 }
00177 
00184 static inline Track GetRailDepotTrack(TileIndex t)
00185 {
00186   return DiagDirToDiagTrack(GetRailDepotDirection(t));
00187 }
00188 
00189 
00196 static inline TrackBits GetRailReservationTrackBits(TileIndex t)
00197 {
00198   assert(IsPlainRailTile(t));
00199   byte track_b = GB(_m[t].m2, 8, 3);
00200   Track track = (Track)(track_b - 1);    // map array saves Track+1
00201   if (track_b == 0) return TRACK_BIT_NONE;
00202   return (TrackBits)(TrackToTrackBits(track) | (HasBit(_m[t].m2, 11) ? TrackToTrackBits(TrackToOppositeTrack(track)) : 0));
00203 }
00204 
00211 static inline void SetTrackReservation(TileIndex t, TrackBits b)
00212 {
00213   assert(IsPlainRailTile(t));
00214   assert(b != INVALID_TRACK_BIT);
00215   assert(!TracksOverlap(b));
00216   Track track = RemoveFirstTrack(&b);
00217   SB(_m[t].m2, 8, 3, track == INVALID_TRACK ? 0 : track+1);
00218   SB(_m[t].m2, 11, 1, (byte)(b != TRACK_BIT_NONE));
00219 }
00220 
00228 static inline bool TryReserveTrack(TileIndex tile, Track t)
00229 {
00230   assert(HasTrack(tile, t));
00231   TrackBits bits = TrackToTrackBits(t);
00232   TrackBits res = GetRailReservationTrackBits(tile);
00233   if ((res & bits) != TRACK_BIT_NONE) return false;  // already reserved
00234   res |= bits;
00235   if (TracksOverlap(res)) return false;  // crossing reservation present
00236   SetTrackReservation(tile, res);
00237   return true;
00238 }
00239 
00246 static inline void UnreserveTrack(TileIndex tile, Track t)
00247 {
00248   assert(HasTrack(tile, t));
00249   TrackBits res = GetRailReservationTrackBits(tile);
00250   res &= ~TrackToTrackBits(t);
00251   SetTrackReservation(tile, res);
00252 }
00253 
00260 static inline bool HasDepotReservation(TileIndex t)
00261 {
00262   assert(IsRailDepot(t));
00263   return HasBit(_m[t].m5, 4);
00264 }
00265 
00272 static inline void SetDepotReservation(TileIndex t, bool b)
00273 {
00274   assert(IsRailDepot(t));
00275   SB(_m[t].m5, 4, 1, (byte)b);
00276 }
00277 
00284 static inline TrackBits GetDepotReservationTrackBits(TileIndex t)
00285 {
00286   return HasDepotReservation(t) ? TrackToTrackBits(GetRailDepotTrack(t)) : TRACK_BIT_NONE;
00287 }
00288 
00289 
00290 static inline bool IsPbsSignal(SignalType s)
00291 {
00292   return s == SIGTYPE_PBS || s == SIGTYPE_PBS_ONEWAY;
00293 }
00294 
00295 static inline SignalType GetSignalType(TileIndex t, Track track)
00296 {
00297   assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
00298   byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
00299   return (SignalType)GB(_m[t].m2, pos, 3);
00300 }
00301 
00302 static inline void SetSignalType(TileIndex t, Track track, SignalType s)
00303 {
00304   assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
00305   byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 0;
00306   SB(_m[t].m2, pos, 3, s);
00307   if (track == INVALID_TRACK) SB(_m[t].m2, 4, 3, s);
00308 }
00309 
00310 static inline bool IsPresignalEntry(TileIndex t, Track track)
00311 {
00312   return GetSignalType(t, track) == SIGTYPE_ENTRY || GetSignalType(t, track) == SIGTYPE_COMBO;
00313 }
00314 
00315 static inline bool IsPresignalExit(TileIndex t, Track track)
00316 {
00317   return GetSignalType(t, track) == SIGTYPE_EXIT || GetSignalType(t, track) == SIGTYPE_COMBO;
00318 }
00319 
00321 static inline bool IsOnewaySignal(TileIndex t, Track track)
00322 {
00323   return GetSignalType(t, track) != SIGTYPE_PBS;
00324 }
00325 
00326 static inline void CycleSignalSide(TileIndex t, Track track)
00327 {
00328   byte sig;
00329   byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 4 : 6;
00330 
00331   sig = GB(_m[t].m3, pos, 2);
00332   if (--sig == 0) sig = IsPbsSignal(GetSignalType(t, track)) ? 2 : 3;
00333   SB(_m[t].m3, pos, 2, sig);
00334 }
00335 
00336 static inline SignalVariant GetSignalVariant(TileIndex t, Track track)
00337 {
00338   byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;
00339   return (SignalVariant)GB(_m[t].m2, pos, 1);
00340 }
00341 
00342 static inline void SetSignalVariant(TileIndex t, Track track, SignalVariant v)
00343 {
00344   byte pos = (track == TRACK_LOWER || track == TRACK_RIGHT) ? 7 : 3;
00345   SB(_m[t].m2, pos, 1, v);
00346   if (track == INVALID_TRACK) SB(_m[t].m2, 7, 1, v);
00347 }
00348 
00353 enum SignalState {
00354   SIGNAL_STATE_RED   = 0, 
00355   SIGNAL_STATE_GREEN = 1, 
00356 };
00357 
00363 static inline void SetSignalStates(TileIndex tile, uint state)
00364 {
00365   SB(_m[tile].m4, 4, 4, state);
00366 }
00367 
00373 static inline uint GetSignalStates(TileIndex tile)
00374 {
00375   return GB(_m[tile].m4, 4, 4);
00376 }
00377 
00384 static inline SignalState GetSingleSignalState(TileIndex t, byte signalbit)
00385 {
00386   return (SignalState)HasBit(GetSignalStates(t), signalbit);
00387 }
00388 
00394 static inline void SetPresentSignals(TileIndex tile, uint signals)
00395 {
00396   SB(_m[tile].m3, 4, 4, signals);
00397 }
00398 
00404 static inline uint GetPresentSignals(TileIndex tile)
00405 {
00406   return GB(_m[tile].m3, 4, 4);
00407 }
00408 
00415 static inline bool IsSignalPresent(TileIndex t, byte signalbit)
00416 {
00417   return HasBit(GetPresentSignals(t), signalbit);
00418 }
00419 
00424 static inline bool HasSignalOnTrack(TileIndex tile, Track track)
00425 {
00426   assert(IsValidTrack(track));
00427   return
00428     GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
00429     (GetPresentSignals(tile) & SignalOnTrack(track)) != 0;
00430 }
00431 
00439 static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)
00440 {
00441   assert (IsValidTrackdir(trackdir));
00442   return
00443     GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
00444     GetPresentSignals(tile) & SignalAlongTrackdir(trackdir);
00445 }
00446 
00453 static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)
00454 {
00455   assert(IsValidTrackdir(trackdir));
00456   assert(HasSignalOnTrack(tile, TrackdirToTrack(trackdir)));
00457   return GetSignalStates(tile) & SignalAlongTrackdir(trackdir) ?
00458     SIGNAL_STATE_GREEN : SIGNAL_STATE_RED;
00459 }
00460 
00464 static inline void SetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir, SignalState state)
00465 {
00466   if (state == SIGNAL_STATE_GREEN) { // set 1
00467     SetSignalStates(tile, GetSignalStates(tile) | SignalAlongTrackdir(trackdir));
00468   } else {
00469     SetSignalStates(tile, GetSignalStates(tile) & ~SignalAlongTrackdir(trackdir));
00470   }
00471 }
00472 
00478 static inline bool HasPbsSignalOnTrackdir(TileIndex tile, Trackdir td)
00479 {
00480   return
00481     IsTileType(tile, MP_RAILWAY) &&
00482     HasSignalOnTrackdir(tile, td) &&
00483     IsPbsSignal(GetSignalType(tile, TrackdirToTrack(td)));
00484 }
00485 
00492 static inline bool HasOnewaySignalBlockingTrackdir(TileIndex tile, Trackdir td)
00493 {
00494   return
00495     IsTileType(tile, MP_RAILWAY) &&
00496     HasSignalOnTrackdir(tile, ReverseTrackdir(td)) &&
00497     !HasSignalOnTrackdir(tile, td) &&
00498     IsOnewaySignal(tile, TrackdirToTrack(td));
00499 }
00500 
00501 
00505 RailType GetTileRailType(TileIndex tile);
00506 
00508 enum RailGroundType {
00509   RAIL_GROUND_BARREN       =  0, 
00510   RAIL_GROUND_GRASS        =  1, 
00511   RAIL_GROUND_FENCE_NW     =  2, 
00512   RAIL_GROUND_FENCE_SE     =  3, 
00513   RAIL_GROUND_FENCE_SENW   =  4, 
00514   RAIL_GROUND_FENCE_NE     =  5, 
00515   RAIL_GROUND_FENCE_SW     =  6, 
00516   RAIL_GROUND_FENCE_NESW   =  7, 
00517   RAIL_GROUND_FENCE_VERT1  =  8, 
00518   RAIL_GROUND_FENCE_VERT2  =  9, 
00519   RAIL_GROUND_FENCE_HORIZ1 = 10, 
00520   RAIL_GROUND_FENCE_HORIZ2 = 11, 
00521   RAIL_GROUND_ICE_DESERT   = 12, 
00522   RAIL_GROUND_WATER        = 13, 
00523   RAIL_GROUND_HALF_SNOW    = 14, 
00524 };
00525 
00526 static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)
00527 {
00528   SB(_m[t].m4, 0, 4, rgt);
00529 }
00530 
00531 static inline RailGroundType GetRailGroundType(TileIndex t)
00532 {
00533   return (RailGroundType)GB(_m[t].m4, 0, 4);
00534 }
00535 
00536 static inline bool IsSnowRailGround(TileIndex t)
00537 {
00538   return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;
00539 }
00540 
00541 
00542 static inline void MakeRailNormal(TileIndex t, Owner o, TrackBits b, RailType r)
00543 {
00544   SetTileType(t, MP_RAILWAY);
00545   SetTileOwner(t, o);
00546   _m[t].m2 = 0;
00547   _m[t].m3 = r;
00548   _m[t].m4 = 0;
00549   _m[t].m5 = RAIL_TILE_NORMAL << 6 | b;
00550   SB(_m[t].m6, 2, 4, 0);
00551   _me[t].m7 = 0;
00552 }
00553 
00554 
00555 static inline void MakeRailDepot(TileIndex t, Owner o, DepotID did, DiagDirection d, RailType r)
00556 {
00557   SetTileType(t, MP_RAILWAY);
00558   SetTileOwner(t, o);
00559   _m[t].m2 = did;
00560   _m[t].m3 = r;
00561   _m[t].m4 = 0;
00562   _m[t].m5 = RAIL_TILE_DEPOT << 6 | d;
00563   SB(_m[t].m6, 2, 4, 0);
00564   _me[t].m7 = 0;
00565 }
00566 
00567 #endif /* RAIL_MAP_H */

Generated on Wed Dec 23 23:27:53 2009 for OpenTTD by  doxygen 1.5.6