src/road_map.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file road_map.h Map accessors for roads. */
   9
  10 #ifndef ROAD_MAP_H
  11 #define ROAD_MAP_H
  12
  13 #include "track_func.h"
  14 #include "depot_type.h"
  15 #include "rail_type.h"
  16 #include "road_func.h"
  17 #include "tile_map.h"
  18
  19
  20 /** The different types of road tiles. */
  21 enum RoadTileType {
  22         ROAD_TILE_NORMAL,   ///< Normal road
  23         ROAD_TILE_CROSSING, ///< Level crossing
  24         ROAD_TILE_DEPOT,    ///< Depot (one entrance)
  25 };
  26
  27 /**
  28  * Test whether a tile can have road/tram types.
  29  * @param t Tile to query.
  30  * @return true if tile can be queried about road/tram types.
  31  */
  32 static inline bool MayHaveRoad(TileIndex t)
  33 {
  34         switch (GetTileType(t)) {
  35                 case MP_ROAD:
  36                 case MP_STATION:
  37                 case MP_TUNNELBRIDGE:
  38                         return true;
  39
  40                 default:
  41                         return false;
  42         }
  43 }
  44
  45 /**
  46  * Get the type of the road tile.
  47  * @param t Tile to query.
  48  * @pre IsTileType(t, MP_ROAD)
  49  * @return The road tile type.
  50  */
  51 static inline RoadTileType GetRoadTileType(TileIndex t)
  52 {
  53         assert(IsTileType(t, MP_ROAD));
  54         return (RoadTileType)GB(_m[t].m5, 6, 2);
  55 }
  56
  57 /**
  58  * Return whether a tile is a normal road.
  59  * @param t Tile to query.
  60  * @pre IsTileType(t, MP_ROAD)
  61  * @return True if normal road.
  62  */
  63 static inline bool IsNormalRoad(TileIndex t)
  64 {
  65         return GetRoadTileType(t) == ROAD_TILE_NORMAL;
  66 }
  67
  68 /**
  69  * Return whether a tile is a normal road tile.
  70  * @param t Tile to query.
  71  * @return True if normal road tile.
  72  */
  73 static inline bool IsNormalRoadTile(TileIndex t)
  74 {
  75         return IsTileType(t, MP_ROAD) && IsNormalRoad(t);
  76 }
  77
  78 /**
  79  * Return whether a tile is a level crossing.
  80  * @param t Tile to query.
  81  * @pre IsTileType(t, MP_ROAD)
  82  * @return True if level crossing.
  83  */
  84 static inline bool IsLevelCrossing(TileIndex t)
  85 {
  86         return GetRoadTileType(t) == ROAD_TILE_CROSSING;
  87 }
  88
  89 /**
  90  * Return whether a tile is a level crossing tile.
  91  * @param t Tile to query.
  92  * @return True if level crossing tile.
  93  */
  94 static inline bool IsLevelCrossingTile(TileIndex t)
  95 {
  96         return IsTileType(t, MP_ROAD) && IsLevelCrossing(t);
  97 }
  98
  99 /**
 100  * Return whether a tile is a road depot.
 101  * @param t Tile to query.
 102  * @pre IsTileType(t, MP_ROAD)
 103  * @return True if road depot.
 104  */
 105 static inline bool IsRoadDepot(TileIndex t)
 106 {
 107         return GetRoadTileType(t) == ROAD_TILE_DEPOT;
 108 }
 109
 110 /**
 111  * Return whether a tile is a road depot tile.
 112  * @param t Tile to query.
 113  * @return True if road depot tile.
 114  */
 115 static inline bool IsRoadDepotTile(TileIndex t)
 116 {
 117         return IsTileType(t, MP_ROAD) && IsRoadDepot(t);
 118 }
 119
 120 /**
 121  * Get the present road bits for a specific road type.
 122  * @param t  The tile to query.
 123  * @param rt Road type.
 124  * @pre IsNormalRoad(t)
 125  * @return The present road bits for the road type.
 126  */
 127 static inline RoadBits GetRoadBits(TileIndex t, RoadTramType rtt)
 128 {
 129         assert(IsNormalRoad(t));
 130         if (rtt == RTT_TRAM) return (RoadBits)GB(_m[t].m3, 0, 4);
 131         return (RoadBits)GB(_m[t].m5, 0, 4);
 132 }
 133
 134 /**
 135  * Get all set RoadBits on the given tile
 136  *
 137  * @param tile The tile from which we want to get the RoadBits
 138  * @return all set RoadBits of the tile
 139  */
 140 static inline RoadBits GetAllRoadBits(TileIndex tile)
 141 {
 142         return GetRoadBits(tile, RTT_ROAD) | GetRoadBits(tile, RTT_TRAM);
 143 }
 144
 145 /**
 146  * Set the present road bits for a specific road type.
 147  * @param t  The tile to change.
 148  * @param r  The new road bits.
 149  * @param rt Road type.
 150  * @pre IsNormalRoad(t)
 151  */
 152 static inline void SetRoadBits(TileIndex t, RoadBits r, RoadTramType rtt)
 153 {
 154         assert(IsNormalRoad(t)); // XXX incomplete
 155         if (rtt == RTT_TRAM) {
 156                 SB(_m[t].m3, 0, 4, r);
 157         } else {
 158                 SB(_m[t].m5, 0, 4, r);
 159         }
 160 }
 161
 162 static inline RoadType GetRoadTypeRoad(TileIndex t)
 163 {
 164         assert(MayHaveRoad(t));
 165         return (RoadType)GB(_m[t].m4, 0, 6);
 166 }
 167
 168 static inline RoadType GetRoadTypeTram(TileIndex t)
 169 {
 170         assert(MayHaveRoad(t));
 171         return (RoadType)GB(_me[t].m8, 6, 6);
 172 }
 173
 174 static inline RoadType GetRoadType(TileIndex t, RoadTramType rtt)
 175 {
 176         return (rtt == RTT_TRAM) ? GetRoadTypeTram(t) : GetRoadTypeRoad(t);
 177 }
 178
 179 /**
 180  * Get the present road types of a tile.
 181  * @param t The tile to query.
 182  * @return Present road types.
 183  */
 184 static inline RoadTypes GetPresentRoadTypes(TileIndex t)
 185 {
 186         RoadTypes result = ROADTYPES_NONE;
 187         if (MayHaveRoad(t)) {
 188                 if (GetRoadTypeRoad(t) != INVALID_ROADTYPE) SetBit(result, GetRoadTypeRoad(t));
 189                 if (GetRoadTypeTram(t) != INVALID_ROADTYPE) SetBit(result, GetRoadTypeTram(t));
 190         }
 191         return result;
 192 }
 193
 194 static inline bool HasRoadTypeRoad(TileIndex t)
 195 {
 196         return GetRoadTypeRoad(t) != INVALID_ROADTYPE;
 197 }
 198
 199 static inline bool HasRoadTypeTram(TileIndex t)
 200 {
 201         return GetRoadTypeTram(t) != INVALID_ROADTYPE;
 202 }
 203
 204 /**
 205  * Check if a tile has a road or a tram road type.
 206  * @param t  The tile to check.
 207  * @param tram True to check tram, false to check road.
 208  * @return True if the tile has the specified road type.
 209  */
 210 static inline bool HasTileRoadType(TileIndex t, RoadTramType rtt)
 211 {
 212         return GetRoadType(t, rtt) != INVALID_ROADTYPE;
 213 }
 214
 215 /**
 216  * Check if a tile has one of the specified road types.
 217  * @param t  The tile to check.
 218  * @param rts Allowed road types.
 219  * @return True if the tile has one of the specified road types.
 220  */
 221 static inline bool HasTileAnyRoadType(TileIndex t, RoadTypes rts)
 222 {
 223         if (!MayHaveRoad(t)) return false;
 224         return (GetPresentRoadTypes(t) & rts);
 225 }
 226
 227 /**
 228  * Get the owner of a specific road type.
 229  * @param t  The tile to query.
 230  * @param rtt RoadTramType.
 231  * @return Owner of the given road type.
 232  */
 233 static inline Owner GetRoadOwner(TileIndex t, RoadTramType rtt)
 234 {
 235         assert(MayHaveRoad(t));
 236         if (rtt == RTT_ROAD) return (Owner)GB(IsNormalRoadTile(t) ? _m[t].m1 : _me[t].m7, 0, 5);
 237
 238         /* Trams don't need OWNER_TOWN, and remapping OWNER_NONE
 239          * to OWNER_TOWN makes it use one bit less */
 240         Owner o = (Owner)GB(_m[t].m3, 4, 4);
 241         return o == OWNER_TOWN ? OWNER_NONE : o;
 242 }
 243
 244 /**
 245  * Set the owner of a specific road type.
 246  * @param t  The tile to change.
 247  * @param rtt RoadTramType.
 248  * @param o  New owner of the given road type.
 249  */
 250 static inline void SetRoadOwner(TileIndex t, RoadTramType rtt, Owner o)
 251 {
 252         if (rtt == RTT_ROAD) {
 253                 SB(IsNormalRoadTile(t) ? _m[t].m1 : _me[t].m7, 0, 5, o);
 254         } else {
 255                 SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o);
 256         }
 257 }
 258
 259 /**
 260  * Check if a specific road type is owned by an owner.
 261  * @param t  The tile to query.
 262  * @param tram True to check tram, false to check road.
 263  * @param o  Owner to compare with.
 264  * @pre HasTileRoadType(t, rt)
 265  * @return True if the road type is owned by the given owner.
 266  */
 267 static inline bool IsRoadOwner(TileIndex t, RoadTramType rtt, Owner o)
 268 {
 269         assert(HasTileRoadType(t, rtt));
 270         return (GetRoadOwner(t, rtt) == o);
 271 }
 272
 273 /**
 274  * Checks if given tile has town owned road
 275  * @param t tile to check
 276  * @pre IsTileType(t, MP_ROAD)
 277  * @return true iff tile has road and the road is owned by a town
 278  */
 279 static inline bool HasTownOwnedRoad(TileIndex t)
 280 {
 281         return HasTileRoadType(t, RTT_ROAD) && IsRoadOwner(t, RTT_ROAD, OWNER_TOWN);
 282 }
 283
 284 /** Which directions are disallowed ? */
 285 enum DisallowedRoadDirections {
 286         DRD_NONE,       ///< None of the directions are disallowed
 287         DRD_SOUTHBOUND, ///< All southbound traffic is disallowed
 288         DRD_NORTHBOUND, ///< All northbound traffic is disallowed
 289         DRD_BOTH,       ///< All directions are disallowed
 290         DRD_END,        ///< Sentinel
 291 };
 292 DECLARE_ENUM_AS_BIT_SET(DisallowedRoadDirections)
 293 /** Helper information for extract tool. */
 294 template <> struct EnumPropsT<DisallowedRoadDirections> : MakeEnumPropsT<DisallowedRoadDirections, byte, DRD_NONE, DRD_END, DRD_END, 2> {};
 295
 296 /**
 297  * Gets the disallowed directions
 298  * @param t the tile to get the directions from
 299  * @return the disallowed directions
 300  */
 301 static inline DisallowedRoadDirections GetDisallowedRoadDirections(TileIndex t)
 302 {
 303         assert(IsNormalRoad(t));
 304         return (DisallowedRoadDirections)GB(_m[t].m5, 4, 2);
 305 }
 306
 307 /**
 308  * Sets the disallowed directions
 309  * @param t   the tile to set the directions for
 310  * @param drd the disallowed directions
 311  */
 312 static inline void SetDisallowedRoadDirections(TileIndex t, DisallowedRoadDirections drd)
 313 {
 314         assert(IsNormalRoad(t));
 315         assert(drd < DRD_END);
 316         SB(_m[t].m5, 4, 2, drd);
 317 }
 318
 319 /**
 320  * Get the road axis of a level crossing.
 321  * @param t The tile to query.
 322  * @pre IsLevelCrossing(t)
 323  * @return The axis of the road.
 324  */
 325 static inline Axis GetCrossingRoadAxis(TileIndex t)
 326 {
 327         assert(IsLevelCrossing(t));
 328         return (Axis)GB(_m[t].m5, 0, 1);
 329 }
 330
 331 /**
 332  * Get the rail axis of a level crossing.
 333  * @param t The tile to query.
 334  * @pre IsLevelCrossing(t)
 335  * @return The axis of the rail.
 336  */
 337 static inline Axis GetCrossingRailAxis(TileIndex t)
 338 {
 339         assert(IsLevelCrossing(t));
 340         return OtherAxis((Axis)GetCrossingRoadAxis(t));
 341 }
 342
 343 /**
 344  * Get the road bits of a level crossing.
 345  * @param tile The tile to query.
 346  * @return The present road bits.
 347  */
 348 static inline RoadBits GetCrossingRoadBits(TileIndex tile)
 349 {
 350         return GetCrossingRoadAxis(tile) == AXIS_X ? ROAD_X : ROAD_Y;
 351 }
 352
 353 /**
 354  * Get the rail track of a level crossing.
 355  * @param tile The tile to query.
 356  * @return The rail track.
 357  */
 358 static inline Track GetCrossingRailTrack(TileIndex tile)
 359 {
 360         return AxisToTrack(GetCrossingRailAxis(tile));
 361 }
 362
 363 /**
 364  * Get the rail track bits of a level crossing.
 365  * @param tile The tile to query.
 366  * @return The rail track bits.
 367  */
 368 static inline TrackBits GetCrossingRailBits(TileIndex tile)
 369 {
 370         return AxisToTrackBits(GetCrossingRailAxis(tile));
 371 }
 372
 373
 374 /**
 375  * Get the reservation state of the rail crossing
 376  * @param t the crossing tile
 377  * @return reservation state
 378  * @pre IsLevelCrossingTile(t)
 379  */
 380 static inline bool HasCrossingReservation(TileIndex t)
 381 {
 382         assert(IsLevelCrossingTile(t));
 383         return HasBit(_m[t].m5, 4);
 384 }
 385
 386 /**
 387  * Set the reservation state of the rail crossing
 388  * @note Works for both waypoints and rail depots
 389  * @param t the crossing tile
 390  * @param b the reservation state
 391  * @pre IsLevelCrossingTile(t)
 392  */
 393 static inline void SetCrossingReservation(TileIndex t, bool b)
 394 {
 395         assert(IsLevelCrossingTile(t));
 396         SB(_m[t].m5, 4, 1, b ? 1 : 0);
 397 }
 398
 399 /**
 400  * Get the reserved track bits for a rail crossing
 401  * @param t the tile
 402  * @pre IsLevelCrossingTile(t)
 403  * @return reserved track bits
 404  */
 405 static inline TrackBits GetCrossingReservationTrackBits(TileIndex t)
 406 {
 407         return HasCrossingReservation(t) ? GetCrossingRailBits(t) : TRACK_BIT_NONE;
 408 }
 409
 410 /**
 411  * Check if the level crossing is barred.
 412  * @param t The tile to query.
 413  * @pre IsLevelCrossing(t)
 414  * @return True if the level crossing is barred.
 415  */
 416 static inline bool IsCrossingBarred(TileIndex t)
 417 {
 418         assert(IsLevelCrossing(t));
 419         return HasBit(_m[t].m5, 5);
 420 }
 421
 422 /**
 423  * Set the bar state of a level crossing.
 424  * @param t The tile to modify.
 425  * @param barred True if the crossing should be barred, false otherwise.
 426  * @pre IsLevelCrossing(t)
 427  */
 428 static inline void SetCrossingBarred(TileIndex t, bool barred)
 429 {
 430         assert(IsLevelCrossing(t));
 431         SB(_m[t].m5, 5, 1, barred ? 1 : 0);
 432 }
 433
 434 /**
 435  * Unbar a level crossing.
 436  * @param t The tile to change.
 437  */
 438 static inline void UnbarCrossing(TileIndex t)
 439 {
 440         SetCrossingBarred(t, false);
 441 }
 442
 443 /**
 444  * Bar a level crossing.
 445  * @param t The tile to change.
 446  */
 447 static inline void BarCrossing(TileIndex t)
 448 {
 449         SetCrossingBarred(t, true);
 450 }
 451
 452 /** Check if a road tile has snow/desert. */
 453 #define IsOnDesert IsOnSnow
 454 /**
 455  * Check if a road tile has snow/desert.
 456  * @param t The tile to query.
 457  * @return True if the tile has snow/desert.
 458  */
 459 static inline bool IsOnSnow(TileIndex t)
 460 {
 461         return HasBit(_me[t].m7, 5);
 462 }
 463
 464 /** Toggle the snow/desert state of a road tile. */
 465 #define ToggleDesert ToggleSnow
 466 /**
 467  * Toggle the snow/desert state of a road tile.
 468  * @param t The tile to change.
 469  */
 470 static inline void ToggleSnow(TileIndex t)
 471 {
 472         ToggleBit(_me[t].m7, 5);
 473 }
 474
 475
 476 /** The possible road side decorations. */
 477 enum Roadside {
 478         ROADSIDE_BARREN           = 0, ///< Road on barren land
 479         ROADSIDE_GRASS            = 1, ///< Road on grass
 480         ROADSIDE_PAVED            = 2, ///< Road with paved sidewalks
 481         ROADSIDE_STREET_LIGHTS    = 3, ///< Road with street lights on paved sidewalks
 482         // 4 is unused for historical reasons
 483         ROADSIDE_TREES            = 5, ///< Road with trees on paved sidewalks
 484         ROADSIDE_GRASS_ROAD_WORKS = 6, ///< Road on grass with road works
 485         ROADSIDE_PAVED_ROAD_WORKS = 7, ///< Road with sidewalks and road works
 486 };
 487
 488 /**
 489  * Get the decorations of a road.
 490  * @param tile The tile to query.
 491  * @return The road decoration of the tile.
 492  */
 493 static inline Roadside GetRoadside(TileIndex tile)
 494 {
 495         return (Roadside)GB(_me[tile].m6, 3, 3);
 496 }
 497
 498 /**
 499  * Set the decorations of a road.
 500  * @param tile The tile to change.
 501  * @param s    The new road decoration of the tile.
 502  */
 503 static inline void SetRoadside(TileIndex tile, Roadside s)
 504 {
 505         SB(_me[tile].m6, 3, 3, s);
 506 }
 507
 508 /**
 509  * Check if a tile has road works.
 510  * @param t The tile to check.
 511  * @return True if the tile has road works in progress.
 512  */
 513 static inline bool HasRoadWorks(TileIndex t)
 514 {
 515         return GetRoadside(t) >= ROADSIDE_GRASS_ROAD_WORKS;
 516 }
 517
 518 /**
 519  * Increase the progress counter of road works.
 520  * @param t The tile to modify.
 521  * @return True if the road works are in the last stage.
 522  */
 523 static inline bool IncreaseRoadWorksCounter(TileIndex t)
 524 {
 525         AB(_me[t].m7, 0, 4, 1);
 526
 527         return GB(_me[t].m7, 0, 4) == 15;
 528 }
 529
 530 /**
 531  * Start road works on a tile.
 532  * @param t The tile to start the work on.
 533  * @pre !HasRoadWorks(t)
 534  */
 535 static inline void StartRoadWorks(TileIndex t)
 536 {
 537         assert(!HasRoadWorks(t));
 538         /* Remove any trees or lamps in case or roadwork */
 539         switch (GetRoadside(t)) {
 540                 case ROADSIDE_BARREN:
 541                 case ROADSIDE_GRASS:  SetRoadside(t, ROADSIDE_GRASS_ROAD_WORKS); break;
 542                 default:              SetRoadside(t, ROADSIDE_PAVED_ROAD_WORKS); break;
 543         }
 544 }
 545
 546 /**
 547  * Terminate road works on a tile.
 548  * @param t Tile to stop the road works on.
 549  * @pre HasRoadWorks(t)
 550  */
 551 static inline void TerminateRoadWorks(TileIndex t)
 552 {
 553         assert(HasRoadWorks(t));
 554         SetRoadside(t, (Roadside)(GetRoadside(t) - ROADSIDE_GRASS_ROAD_WORKS + ROADSIDE_GRASS));
 555         /* Stop the counter */
 556         SB(_me[t].m7, 0, 4, 0);
 557 }
 558
 559
 560 /**
 561  * Get the direction of the exit of a road depot.
 562  * @param t The tile to query.
 563  * @return Diagonal direction of the depot exit.
 564  */
 565 static inline DiagDirection GetRoadDepotDirection(TileIndex t)
 566 {
 567         assert(IsRoadDepot(t));
 568         return (DiagDirection)GB(_m[t].m5, 0, 2);
 569 }
 570
 571
 572 RoadBits GetAnyRoadBits(TileIndex tile, RoadTramType rtt, bool straight_tunnel_bridge_entrance = false);
 573
 574 /**
 575  * Set the road road type of a tile.
 576  * @param t The tile to change.
 577  * @param rt The road type to set.
 578  */
 579 static inline void SetRoadTypeRoad(TileIndex t, RoadType rt)
 580 {
 581         assert(MayHaveRoad(t));
 582         assert(rt == INVALID_ROADTYPE || RoadTypeIsRoad(rt));
 583         SB(_m[t].m4, 0, 6, rt);
 584 }
 585
 586 /**
 587  * Set the tram road type of a tile.
 588  * @param t The tile to change.
 589  * @param rt The road type to set.
 590  */
 591 static inline void SetRoadTypeTram(TileIndex t, RoadType rt)
 592 {
 593         assert(MayHaveRoad(t));
 594         assert(rt == INVALID_ROADTYPE || RoadTypeIsTram(rt));
 595         SB(_me[t].m8, 6, 6, rt);
 596 }
 597
 598 /**
 599  * Set the road type of a tile.
 600  * @param t The tile to change.
 601  * @param rtt Set road or tram type.
 602  * @param rt The road type to set.
 603  */
 604 static inline void SetRoadType(TileIndex t, RoadTramType rtt, RoadType rt)
 605 {
 606         if (rtt == RTT_TRAM) {
 607                 SetRoadTypeTram(t, rt);
 608         } else {
 609                 SetRoadTypeRoad(t, rt);
 610         }
 611 }
 612
 613 /**
 614  * Set the present road types of a tile.
 615  * @param t  The tile to change.
 616  * @param road_rt The road roadtype to set for the tile.
 617  * @param tram_rt The tram roadtype to set for the tile.
 618  */
 619 static inline void SetRoadTypes(TileIndex t, RoadType road_rt, RoadType tram_rt)
 620 {
 621         SetRoadTypeRoad(t, road_rt);
 622         SetRoadTypeTram(t, tram_rt);
 623 }
 624
 625 /**
 626  * Make a normal road tile.
 627  * @param t       Tile to make a normal road.
 628  * @param bits    Road bits to set for all present road types.
 629  * @param road_rt The road roadtype to set for the tile.
 630  * @param tram_rt The tram roadtype to set for the tile.
 631  * @param town    Town ID if the road is a town-owned road.
 632  * @param road    New owner of road.
 633  * @param tram    New owner of tram tracks.
 634  */
 635 static inline void MakeRoadNormal(TileIndex t, RoadBits bits, RoadType road_rt, RoadType tram_rt, TownID town, Owner road, Owner tram)
 636 {
 637         SetTileType(t, MP_ROAD);
 638         SetTileOwner(t, road);
 639         _m[t].m2 = town;
 640         _m[t].m3 = (tram_rt != INVALID_ROADTYPE ? bits : 0);
 641         _m[t].m5 = (road_rt != INVALID_ROADTYPE ? bits : 0) | ROAD_TILE_NORMAL << 6;
 642         SB(_me[t].m6, 2, 4, 0);
 643         _me[t].m7 = 0;
 644         SetRoadTypes(t, road_rt, tram_rt);
 645         SetRoadOwner(t, RTT_TRAM, tram);
 646 }
 647
 648 /**
 649  * Make a level crossing.
 650  * @param t       Tile to make a level crossing.
 651  * @param road    New owner of road.
 652  * @param tram    New owner of tram tracks.
 653  * @param rail    New owner of the rail track.
 654  * @param roaddir Axis of the road.
 655  * @param rat     New rail type.
 656  * @param road_rt The road roadtype to set for the tile.
 657  * @param tram_rt The tram roadtype to set for the tile.
 658  * @param town    Town ID if the road is a town-owned road.
 659  */
 660 static inline void MakeRoadCrossing(TileIndex t, Owner road, Owner tram, Owner rail, Axis roaddir, RailType rat, RoadType road_rt, RoadType tram_rt, uint town)
 661 {
 662         SetTileType(t, MP_ROAD);
 663         SetTileOwner(t, rail);
 664         _m[t].m2 = town;
 665         _m[t].m3 = 0;
 666         _m[t].m4 = INVALID_ROADTYPE;
 667         _m[t].m5 = ROAD_TILE_CROSSING << 6 | roaddir;
 668         SB(_me[t].m6, 2, 4, 0);
 669         _me[t].m7 = road;
 670         _me[t].m8 = INVALID_ROADTYPE << 6 | rat;
 671         SetRoadTypes(t, road_rt, tram_rt);
 672         SetRoadOwner(t, RTT_TRAM, tram);
 673 }
 674
 675 /**
 676  * Make a road depot.
 677  * @param t     Tile to make a level crossing.
 678  * @param owner New owner of the depot.
 679  * @param did   New depot ID.
 680  * @param dir   Direction of the depot exit.*
 681  * @param rt    Road type of the depot.
 682  */
 683 static inline void MakeRoadDepot(TileIndex t, Owner owner, DepotID did, DiagDirection dir, RoadType rt)
 684 {
 685         SetTileType(t, MP_ROAD);
 686         SetTileOwner(t, owner);
 687         _m[t].m2 = did;
 688         _m[t].m3 = 0;
 689         _m[t].m4 = INVALID_ROADTYPE;
 690         _m[t].m5 = ROAD_TILE_DEPOT << 6 | dir;
 691         SB(_me[t].m6, 2, 4, 0);
 692         _me[t].m7 = owner;
 693         _me[t].m8 = INVALID_ROADTYPE << 6;
 694         SetRoadType(t, GetRoadTramType(rt), rt);
 695         SetRoadOwner(t, RTT_TRAM, owner);
 696 }
 697
 698 #endif /* ROAD_MAP_H */