src/station_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 station_map.h Maps accessors for stations. */
   9
  10 #ifndef STATION_MAP_H
  11 #define STATION_MAP_H
  12
  13 #include "rail_map.h"
  14 #include "road_map.h"
  15 #include "water_map.h"
  16 #include "station_func.h"
  17 #include "rail.h"
  18 #include "road.h"
  19
  20 typedef uint8_t StationGfx; ///< Index of station graphics. @see _station_display_datas
  21
  22 /**
  23  * Get StationID from a tile
  24  * @param t Tile to query station ID from
  25  * @pre IsTileType(t, MP_STATION)
  26  * @return Station ID of the station at \a t
  27  */
  28 inline StationID GetStationIndex(Tile t)
  29 {
  30         assert(IsTileType(t, MP_STATION));
  31         return (StationID)t.m2();
  32 }
  33
  34
  35 static const int GFX_DOCK_BASE_WATER_PART          =  4; ///< The offset for the water parts.
  36 static const int GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET =  4; ///< The offset for the drive through parts.
  37
  38 /**
  39  * Get the station type of this tile
  40  * @param t the tile to query
  41  * @pre IsTileType(t, MP_STATION)
  42  * @return the station type
  43  */
  44 inline StationType GetStationType(Tile t)
  45 {
  46         assert(IsTileType(t, MP_STATION));
  47         return (StationType)GB(t.m6(), 3, 4);
  48 }
  49
  50 /**
  51  * Get the road stop type of this tile
  52  * @param t the tile to query
  53  * @pre GetStationType(t) == STATION_TRUCK || GetStationType(t) == STATION_BUS
  54  * @return the road stop type
  55  */
  56 inline RoadStopType GetRoadStopType(Tile t)
  57 {
  58         assert(GetStationType(t) == STATION_TRUCK || GetStationType(t) == STATION_BUS);
  59         return GetStationType(t) == STATION_TRUCK ? ROADSTOP_TRUCK : ROADSTOP_BUS;
  60 }
  61
  62 /**
  63  * Get the station graphics of this tile
  64  * @param t the tile to query
  65  * @pre IsTileType(t, MP_STATION)
  66  * @return the station graphics
  67  */
  68 inline StationGfx GetStationGfx(Tile t)
  69 {
  70         assert(IsTileType(t, MP_STATION));
  71         return t.m5();
  72 }
  73
  74 /**
  75  * Set the station graphics of this tile
  76  * @param t the tile to update
  77  * @param gfx the new graphics
  78  * @pre IsTileType(t, MP_STATION)
  79  */
  80 inline void SetStationGfx(Tile t, StationGfx gfx)
  81 {
  82         assert(IsTileType(t, MP_STATION));
  83         t.m5() = gfx;
  84 }
  85
  86 /**
  87  * Is this station tile a rail station?
  88  * @param t the tile to get the information from
  89  * @pre IsTileType(t, MP_STATION)
  90  * @return true if and only if the tile is a rail station
  91  */
  92 inline bool IsRailStation(Tile t)
  93 {
  94         return GetStationType(t) == STATION_RAIL;
  95 }
  96
  97 /**
  98  * Is this tile a station tile and a rail station?
  99  * @param t the tile to get the information from
 100  * @return true if and only if the tile is a rail station
 101  */
 102 inline bool IsRailStationTile(Tile t)
 103 {
 104         return IsTileType(t, MP_STATION) && IsRailStation(t);
 105 }
 106
 107 /**
 108  * Is this station tile a rail waypoint?
 109  * @param t the tile to get the information from
 110  * @pre IsTileType(t, MP_STATION)
 111  * @return true if and only if the tile is a rail waypoint
 112  */
 113 inline bool IsRailWaypoint(Tile t)
 114 {
 115         return GetStationType(t) == STATION_WAYPOINT;
 116 }
 117
 118 /**
 119  * Is this tile a station tile and a rail waypoint?
 120  * @param t the tile to get the information from
 121  * @return true if and only if the tile is a rail waypoint
 122  */
 123 inline bool IsRailWaypointTile(Tile t)
 124 {
 125         return IsTileType(t, MP_STATION) && IsRailWaypoint(t);
 126 }
 127
 128 /**
 129  * Has this station tile a rail? In other words, is this station
 130  * tile a rail station or rail waypoint?
 131  * @param t the tile to check
 132  * @pre IsTileType(t, MP_STATION)
 133  * @return true if and only if the tile has rail
 134  */
 135 inline bool HasStationRail(Tile t)
 136 {
 137         return IsRailStation(t) || IsRailWaypoint(t);
 138 }
 139
 140 /**
 141  * Has this station tile a rail? In other words, is this station
 142  * tile a rail station or rail waypoint?
 143  * @param t the tile to check
 144  * @return true if and only if the tile is a station tile and has rail
 145  */
 146 inline bool HasStationTileRail(Tile t)
 147 {
 148         return IsTileType(t, MP_STATION) && HasStationRail(t);
 149 }
 150
 151 /**
 152  * Is this station tile an airport?
 153  * @param t the tile to get the information from
 154  * @pre IsTileType(t, MP_STATION)
 155  * @return true if and only if the tile is an airport
 156  */
 157 inline bool IsAirport(Tile t)
 158 {
 159         return GetStationType(t) == STATION_AIRPORT;
 160 }
 161
 162 /**
 163  * Is this tile a station tile and an airport tile?
 164  * @param t the tile to get the information from
 165  * @return true if and only if the tile is an airport
 166  */
 167 inline bool IsAirportTile(Tile t)
 168 {
 169         return IsTileType(t, MP_STATION) && IsAirport(t);
 170 }
 171
 172 bool IsHangar(Tile t);
 173
 174 /**
 175  * Is the station at \a t a truck stop?
 176  * @param t Tile to check
 177  * @pre IsTileType(t, MP_STATION)
 178  * @return \c true if station is a truck stop, \c false otherwise
 179  */
 180 inline bool IsTruckStop(Tile t)
 181 {
 182         return GetStationType(t) == STATION_TRUCK;
 183 }
 184
 185 /**
 186  * Is the station at \a t a bus stop?
 187  * @param t Tile to check
 188  * @pre IsTileType(t, MP_STATION)
 189  * @return \c true if station is a bus stop, \c false otherwise
 190  */
 191 inline bool IsBusStop(Tile t)
 192 {
 193         return GetStationType(t) == STATION_BUS;
 194 }
 195
 196 /**
 197  * Is the station at \a t a road waypoint?
 198  * @param t Tile to check
 199  * @pre IsTileType(t, MP_STATION)
 200  * @return \c true if station is a road waypoint, \c false otherwise
 201  */
 202 inline bool IsRoadWaypoint(Tile t)
 203 {
 204         return GetStationType(t) == STATION_ROADWAYPOINT;
 205 }
 206
 207 /**
 208  * Is this tile a station tile and a road waypoint?
 209  * @param t the tile to get the information from
 210  * @return true if and only if the tile is a road waypoint
 211  */
 212 inline bool IsRoadWaypointTile(Tile t)
 213 {
 214         return IsTileType(t, MP_STATION) && IsRoadWaypoint(t);
 215 }
 216
 217 /**
 218  * Is the station at \a t a road station?
 219  * @param t Tile to check
 220  * @pre IsTileType(t, MP_STATION)
 221  * @return \c true if station at the tile is a bus stop or a truck stop, \c false otherwise
 222  */
 223 inline bool IsStationRoadStop(Tile t)
 224 {
 225         assert(IsTileType(t, MP_STATION));
 226         return IsTruckStop(t) || IsBusStop(t);
 227 }
 228
 229 /**
 230  * Is tile \a t a road stop station?
 231  * @param t Tile to check
 232  * @return \c true if the tile is a station tile and a station road stop
 233  */
 234 inline bool IsStationRoadStopTile(Tile t)
 235 {
 236         return IsTileType(t, MP_STATION) && IsStationRoadStop(t);
 237 }
 238
 239 /**
 240  * Is the station at \a t a road station?
 241  * @param t Tile to check
 242  * @pre IsTileType(t, MP_STATION)
 243  * @return \c true if station at the tile is a bus stop, truck stop or road waypoint, \c false otherwise
 244  */
 245 inline bool IsAnyRoadStop(Tile t)
 246 {
 247         assert(IsTileType(t, MP_STATION));
 248         return IsTruckStop(t) || IsBusStop(t) || IsRoadWaypoint(t);
 249 }
 250
 251 /**
 252  * Is tile \a t a road stop station?
 253  * @param t Tile to check
 254  * @return \c true if the tile is a station tile and any road stop type (bus stop, truck stop or road waypoint)
 255  */
 256 inline bool IsAnyRoadStopTile(Tile t)
 257 {
 258         return IsTileType(t, MP_STATION) && IsAnyRoadStop(t);
 259 }
 260
 261 /**
 262  * Is tile \a t a bay (non-drive through) road stop station?
 263  * @param t Tile to check
 264  * @return \c true if the tile is a station tile and a bay road stop
 265  */
 266 inline bool IsBayRoadStopTile(Tile t)
 267 {
 268         return IsStationRoadStopTile(t) && GetStationGfx(t) < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET;
 269 }
 270
 271 /**
 272  * Is tile \a t a drive through road stop station or waypoint?
 273  * @param t Tile to check
 274  * @return \c true if the tile is a station tile and a drive through road stop or road waypoint
 275  */
 276 inline bool IsDriveThroughStopTile(Tile t)
 277 {
 278         return IsAnyRoadStopTile(t) && GetStationGfx(t) >= GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET;
 279 }
 280
 281 StationGfx GetTranslatedAirportTileID(StationGfx gfx);
 282
 283 /**
 284  * Get the decorations of a road waypoint.
 285  * @param tile The tile to query.
 286  * @return The road decoration of the tile.
 287  */
 288 static inline Roadside GetRoadWaypointRoadside(Tile tile)
 289 {
 290         assert(IsRoadWaypointTile(tile));
 291         return (Roadside)GB(tile.m3(), 2, 2);
 292 }
 293
 294 /**
 295  * Set the decorations of a road waypoint.
 296  * @param tile The tile to change.
 297  * @param s    The new road decoration of the tile.
 298  */
 299 static inline void SetRoadWaypointRoadside(Tile tile, Roadside s)
 300 {
 301         assert(IsRoadWaypointTile(tile));
 302         SB(tile.m3(), 2, 2, s);
 303 }
 304
 305 /**
 306  * Check if a road waypoint tile has snow/desert.
 307  * @param t The tile to query.
 308  * @return True if the tile has snow/desert.
 309  */
 310 static inline bool IsRoadWaypointOnSnowOrDesert(Tile t)
 311 {
 312         assert(IsRoadWaypointTile(t));
 313         return HasBit(t.m8(), 15);
 314 }
 315
 316 /**
 317  * Toggle the snow/desert state of a road waypoint tile.
 318  * @param t The tile to change.
 319  */
 320 static inline void ToggleRoadWaypointOnSnowOrDesert(Tile t)
 321 {
 322         assert(IsRoadWaypointTile(t));
 323         ToggleBit(t.m8(), 15);
 324 }
 325
 326 /**
 327  * Get the station graphics of this airport tile
 328  * @param t the tile to query
 329  * @pre IsAirport(t)
 330  * @return the station graphics
 331  */
 332 inline StationGfx GetAirportGfx(Tile t)
 333 {
 334         assert(IsAirport(t));
 335         return GetTranslatedAirportTileID(GetStationGfx(t));
 336 }
 337
 338 /**
 339  * Gets the direction the road stop entrance points towards.
 340  * @param t the tile of the road stop
 341  * @pre IsAnyRoadStopTile(t)
 342  * @return the direction of the entrance
 343  */
 344 inline DiagDirection GetRoadStopDir(Tile t)
 345 {
 346         StationGfx gfx = GetStationGfx(t);
 347         assert(IsAnyRoadStopTile(t));
 348         if (gfx < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET) {
 349                 return (DiagDirection)(gfx);
 350         } else {
 351                 return (DiagDirection)(gfx - GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);
 352         }
 353 }
 354
 355 /**
 356  * Is tile \a t part of an oilrig?
 357  * @param t Tile to check
 358  * @pre IsTileType(t, MP_STATION)
 359  * @return \c true if the tile is an oilrig tile
 360  */
 361 inline bool IsOilRig(Tile t)
 362 {
 363         return GetStationType(t) == STATION_OILRIG;
 364 }
 365
 366 /**
 367  * Is tile \a t a dock tile?
 368  * @param t Tile to check
 369  * @pre IsTileType(t, MP_STATION)
 370  * @return \c true if the tile is a dock
 371  */
 372 inline bool IsDock(Tile t)
 373 {
 374         return GetStationType(t) == STATION_DOCK;
 375 }
 376
 377 /**
 378  * Is tile \a t a dock tile?
 379  * @param t Tile to check
 380  * @return \c true if the tile is a dock
 381  */
 382 inline bool IsDockTile(Tile t)
 383 {
 384         return IsTileType(t, MP_STATION) && GetStationType(t) == STATION_DOCK;
 385 }
 386
 387 /**
 388  * Is tile \a t a buoy tile?
 389  * @param t Tile to check
 390  * @pre IsTileType(t, MP_STATION)
 391  * @return \c true if the tile is a buoy
 392  */
 393 inline bool IsBuoy(Tile t)
 394 {
 395         return GetStationType(t) == STATION_BUOY;
 396 }
 397
 398 /**
 399  * Is tile \a t a buoy tile?
 400  * @param t Tile to check
 401  * @return \c true if the tile is a buoy
 402  */
 403 inline bool IsBuoyTile(Tile t)
 404 {
 405         return IsTileType(t, MP_STATION) && IsBuoy(t);
 406 }
 407
 408 /**
 409  * Is tile \a t an hangar tile?
 410  * @param t Tile to check
 411  * @return \c true if the tile is an hangar
 412  */
 413 inline bool IsHangarTile(Tile t)
 414 {
 415         return IsTileType(t, MP_STATION) && IsHangar(t);
 416 }
 417
 418 /**
 419  * Is tile \a t a blocked tile?
 420  * @pre HasStationRail(t)
 421  * @param t Tile to check
 422  * @return \c true if the tile is blocked
 423  */
 424 inline bool IsStationTileBlocked(Tile t)
 425 {
 426         assert(HasStationRail(t));
 427         return HasBit(t.m6(), 0);
 428 }
 429
 430 /**
 431  * Set the blocked state of the rail station
 432  * @pre HasStationRail(t)
 433  * @param t the station tile
 434  * @param b the blocked state
 435  */
 436 inline void SetStationTileBlocked(Tile t, bool b)
 437 {
 438         assert(HasStationRail(t));
 439         AssignBit(t.m6(), 0, b);
 440 }
 441
 442 /**
 443  * Can tile \a t have catenary wires?
 444  * @pre HasStationRail(t)
 445  * @param t Tile to check
 446  * @return \c true if the tile can have catenary wires
 447  */
 448 inline bool CanStationTileHaveWires(Tile t)
 449 {
 450         assert(HasStationRail(t));
 451         return HasBit(t.m6(), 1);
 452 }
 453
 454 /**
 455  * Set the catenary wires state of the rail station
 456  * @pre HasStationRail(t)
 457  * @param t the station tile
 458  * @param b the catenary wires state
 459  */
 460 inline void SetStationTileHaveWires(Tile t, bool b)
 461 {
 462         assert(HasStationRail(t));
 463         AssignBit(t.m6(), 1, b);
 464 }
 465
 466 /**
 467  * Can tile \a t have catenary pylons?
 468  * @pre HasStationRail(t)
 469  * @param t Tile to check
 470  * @return \c true if the tile can have catenary pylons
 471  */
 472 inline bool CanStationTileHavePylons(Tile t)
 473 {
 474         assert(HasStationRail(t));
 475         return HasBit(t.m6(), 7);
 476 }
 477
 478 /**
 479  * Set the catenary pylon state of the rail station
 480  * @pre HasStationRail(t)
 481  * @param t the station tile
 482  * @param b the catenary pylons state
 483  */
 484 inline void SetStationTileHavePylons(Tile t, bool b)
 485 {
 486         assert(HasStationRail(t));
 487         AssignBit(t.m6(), 7, b);
 488 }
 489
 490 /**
 491  * Get the rail direction of a rail station.
 492  * @param t Tile to query
 493  * @pre HasStationRail(t)
 494  * @return The direction of the rails on tile \a t.
 495  */
 496 inline Axis GetRailStationAxis(Tile t)
 497 {
 498         assert(HasStationRail(t));
 499         return HasBit(GetStationGfx(t), 0) ? AXIS_Y : AXIS_X;
 500 }
 501
 502 /**
 503  * Get the rail track of a rail station tile.
 504  * @param t Tile to query
 505  * @pre HasStationRail(t)
 506  * @return The rail track of the rails on tile \a t.
 507  */
 508 inline Track GetRailStationTrack(Tile t)
 509 {
 510         return AxisToTrack(GetRailStationAxis(t));
 511 }
 512
 513 /**
 514  * Get the trackbits of a rail station tile.
 515  * @param t Tile to query
 516  * @pre HasStationRail(t)
 517  * @return The trackbits of the rails on tile \a t.
 518  */
 519 inline TrackBits GetRailStationTrackBits(Tile t)
 520 {
 521         return AxisToTrackBits(GetRailStationAxis(t));
 522 }
 523
 524 /**
 525  * Check if a tile is a valid continuation to a railstation tile.
 526  * The tile \a test_tile is a valid continuation to \a station_tile, if all of the following are true:
 527  * \li \a test_tile is a rail station tile
 528  * \li the railtype of \a test_tile is compatible with the railtype of \a station_tile
 529  * \li the tracks on \a test_tile and \a station_tile are in the same direction
 530  * \li both tiles belong to the same station
 531  * \li \a test_tile is not blocked (@see IsStationTileBlocked)
 532  * @param test_tile Tile to test
 533  * @param station_tile Station tile to compare with
 534  * @pre IsRailStationTile(station_tile)
 535  * @return true if the two tiles are compatible
 536  */
 537 inline bool IsCompatibleTrainStationTile(Tile test_tile, Tile station_tile)
 538 {
 539         assert(IsRailStationTile(station_tile));
 540         return IsRailStationTile(test_tile) && !IsStationTileBlocked(test_tile) &&
 541                         IsCompatibleRail(GetRailType(test_tile), GetRailType(station_tile)) &&
 542                         GetRailStationAxis(test_tile) == GetRailStationAxis(station_tile) &&
 543                         GetStationIndex(test_tile) == GetStationIndex(station_tile);
 544 }
 545
 546 /**
 547  * Get the reservation state of the rail station
 548  * @pre HasStationRail(t)
 549  * @param t the station tile
 550  * @return reservation state
 551  */
 552 inline bool HasStationReservation(Tile t)
 553 {
 554         assert(HasStationRail(t));
 555         return HasBit(t.m6(), 2);
 556 }
 557
 558 /**
 559  * Set the reservation state of the rail station
 560  * @pre HasStationRail(t)
 561  * @param t the station tile
 562  * @param b the reservation state
 563  */
 564 inline void SetRailStationReservation(Tile t, bool b)
 565 {
 566         assert(HasStationRail(t));
 567         AssignBit(t.m6(), 2, b);
 568 }
 569
 570 /**
 571  * Get the reserved track bits for a waypoint
 572  * @pre HasStationRail(t)
 573  * @param t the tile
 574  * @return reserved track bits
 575  */
 576 inline TrackBits GetStationReservationTrackBits(Tile t)
 577 {
 578         return HasStationReservation(t) ? GetRailStationTrackBits(t) : TRACK_BIT_NONE;
 579 }
 580
 581 /**
 582  * Get the direction of a dock.
 583  * @param t Tile to query
 584  * @pre IsDock(t)
 585  * @pre \a t is the land part of the dock
 586  * @return The direction of the dock on tile \a t.
 587  */
 588 inline DiagDirection GetDockDirection(Tile t)
 589 {
 590         StationGfx gfx = GetStationGfx(t);
 591         assert(IsDock(t) && gfx < GFX_DOCK_BASE_WATER_PART);
 592         return (DiagDirection)(gfx);
 593 }
 594
 595 /**
 596  * Check whether a dock tile is the tile on water.
 597  */
 598 inline bool IsDockWaterPart(Tile t)
 599 {
 600         assert(IsDockTile(t));
 601         StationGfx gfx = GetStationGfx(t);
 602         return gfx >= GFX_DOCK_BASE_WATER_PART;
 603 }
 604
 605 /**
 606  * Is there a custom rail station spec on this tile?
 607  * @param t Tile to query
 608  * @pre HasStationTileRail(t)
 609  * @return True if this station is part of a newgrf station.
 610  */
 611 inline bool IsCustomStationSpecIndex(Tile t)
 612 {
 613         assert(HasStationTileRail(t));
 614         return t.m4() != 0;
 615 }
 616
 617 /**
 618  * Set the custom station spec for this tile.
 619  * @param t Tile to set the stationspec of.
 620  * @param specindex The new spec.
 621  * @pre HasStationTileRail(t)
 622  */
 623 inline void SetCustomStationSpecIndex(Tile t, uint8_t specindex)
 624 {
 625         assert(HasStationTileRail(t));
 626         t.m4() = specindex;
 627 }
 628
 629 /**
 630  * Get the custom station spec for this tile.
 631  * @param t Tile to query
 632  * @pre HasStationTileRail(t)
 633  * @return The custom station spec of this tile.
 634  */
 635 inline uint GetCustomStationSpecIndex(Tile t)
 636 {
 637         assert(HasStationTileRail(t));
 638         return t.m4();
 639 }
 640
 641 /**
 642  * Is there a custom road stop spec on this tile?
 643  * @param t Tile to query
 644  * @pre IsAnyRoadStopTile(t)
 645  * @return True if this station is part of a newgrf station.
 646  */
 647 inline bool IsCustomRoadStopSpecIndex(Tile t)
 648 {
 649         assert(IsAnyRoadStopTile(t));
 650         return GB(t.m8(), 0, 6) != 0;
 651 }
 652
 653 /**
 654  * Set the custom road stop spec for this tile.
 655  * @param t Tile to set the stationspec of.
 656  * @param specindex The new spec.
 657  * @pre IsAnyRoadStopTile(t)
 658  */
 659 inline void SetCustomRoadStopSpecIndex(Tile t, uint8_t specindex)
 660 {
 661         assert(IsAnyRoadStopTile(t));
 662         SB(t.m8(), 0, 6, specindex);
 663 }
 664
 665 /**
 666  * Get the custom road stop spec for this tile.
 667  * @param t Tile to query
 668  * @pre IsAnyRoadStopTile(t)
 669  * @return The custom station spec of this tile.
 670  */
 671 inline uint GetCustomRoadStopSpecIndex(Tile t)
 672 {
 673         assert(IsAnyRoadStopTile(t));
 674         return GB(t.m8(), 0, 6);
 675 }
 676
 677 /**
 678  * Set the random bits for a station tile.
 679  * @param t Tile to set random bits for.
 680  * @param random_bits The random bits.
 681  * @pre IsTileType(t, MP_STATION)
 682  */
 683 inline void SetStationTileRandomBits(Tile t, uint8_t random_bits)
 684 {
 685         assert(IsTileType(t, MP_STATION));
 686         SB(t.m3(), 4, 4, random_bits);
 687 }
 688
 689 /**
 690  * Get the random bits of a station tile.
 691  * @param t Tile to query
 692  * @pre IsTileType(t, MP_STATION)
 693  * @return The random bits for this station tile.
 694  */
 695 inline uint8_t GetStationTileRandomBits(Tile t)
 696 {
 697         assert(IsTileType(t, MP_STATION));
 698         return GB(t.m3(), 4, 4);
 699 }
 700
 701 /**
 702  * Make the given tile a station tile.
 703  * @param t the tile to make a station tile
 704  * @param o the owner of the station
 705  * @param sid the station to which this tile belongs
 706  * @param st the type this station tile
 707  * @param section the StationGfx to be used for this tile
 708  * @param wc The water class of the station
 709  */
 710 inline void MakeStation(Tile t, Owner o, StationID sid, StationType st, uint8_t section, WaterClass wc = WATER_CLASS_INVALID)
 711 {
 712         SetTileType(t, MP_STATION);
 713         SetTileOwner(t, o);
 714         SetWaterClass(t, wc);
 715         SetDockingTile(t, false);
 716         t.m2() = sid;
 717         t.m3() = 0;
 718         t.m4() = 0;
 719         t.m5() = section;
 720         SB(t.m6(), 2, 1, 0);
 721         SB(t.m6(), 3, 4, st);
 722         t.m7() = 0;
 723         t.m8() = 0;
 724 }
 725
 726 /**
 727  * Make the given tile a rail station tile.
 728  * @param t the tile to make a rail station tile
 729  * @param o the owner of the station
 730  * @param sid the station to which this tile belongs
 731  * @param a the axis of this tile
 732  * @param section the StationGfx to be used for this tile
 733  * @param rt the railtype of this tile
 734  */
 735 inline void MakeRailStation(Tile t, Owner o, StationID sid, Axis a, uint8_t section, RailType rt)
 736 {
 737         MakeStation(t, o, sid, STATION_RAIL, section + a);
 738         SetRailType(t, rt);
 739         SetRailStationReservation(t, false);
 740 }
 741
 742 /**
 743  * Make the given tile a rail waypoint tile.
 744  * @param t the tile to make a rail waypoint
 745  * @param o the owner of the waypoint
 746  * @param sid the waypoint to which this tile belongs
 747  * @param a the axis of this tile
 748  * @param section the StationGfx to be used for this tile
 749  * @param rt the railtype of this tile
 750  */
 751 inline void MakeRailWaypoint(Tile t, Owner o, StationID sid, Axis a, uint8_t section, RailType rt)
 752 {
 753         MakeStation(t, o, sid, STATION_WAYPOINT, section + a);
 754         SetRailType(t, rt);
 755         SetRailStationReservation(t, false);
 756 }
 757
 758 /**
 759  * Make the given tile a roadstop tile.
 760  * @param t the tile to make a roadstop
 761  * @param o the owner of the roadstop
 762  * @param sid the station to which this tile belongs
 763  * @param rst the type of roadstop to make this tile
 764  * @param road_rt the road roadtype on this tile
 765  * @param tram_rt the tram roadtype on this tile
 766  * @param d the direction of the roadstop
 767  */
 768 inline void MakeRoadStop(Tile t, Owner o, StationID sid, RoadStopType rst, RoadType road_rt, RoadType tram_rt, DiagDirection d)
 769 {
 770         MakeStation(t, o, sid, (rst == ROADSTOP_BUS ? STATION_BUS : STATION_TRUCK), d);
 771         SetRoadTypes(t, road_rt, tram_rt);
 772         SetRoadOwner(t, RTT_ROAD, o);
 773         SetRoadOwner(t, RTT_TRAM, o);
 774 }
 775
 776 /**
 777  * Make the given tile a drivethrough roadstop tile.
 778  * @param t the tile to make a roadstop
 779  * @param station the owner of the roadstop
 780  * @param road the owner of the road
 781  * @param tram the owner of the tram
 782  * @param sid the station to which this tile belongs
 783  * @param rst the type of roadstop to make this tile
 784  * @param road_rt the road roadtype on this tile
 785  * @param tram_rt the tram roadtype on this tile
 786  * @param a the direction of the roadstop
 787  */
 788 inline void MakeDriveThroughRoadStop(Tile t, Owner station, Owner road, Owner tram, StationID sid, StationType rst, RoadType road_rt, RoadType tram_rt, Axis a)
 789 {
 790         MakeStation(t, station, sid, rst, GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET + a);
 791         SetRoadTypes(t, road_rt, tram_rt);
 792         SetRoadOwner(t, RTT_ROAD, road);
 793         SetRoadOwner(t, RTT_TRAM, tram);
 794 }
 795
 796 /**
 797  * Make the given tile an airport tile.
 798  * @param t the tile to make a airport
 799  * @param o the owner of the airport
 800  * @param sid the station to which this tile belongs
 801  * @param section the StationGfx to be used for this tile
 802  * @param wc the type of water on this tile
 803  */
 804 inline void MakeAirport(Tile t, Owner o, StationID sid, uint8_t section, WaterClass wc)
 805 {
 806         MakeStation(t, o, sid, STATION_AIRPORT, section, wc);
 807 }
 808
 809 /**
 810  * Make the given tile a buoy tile.
 811  * @param t the tile to make a buoy
 812  * @param sid the station to which this tile belongs
 813  * @param wc the type of water on this tile
 814  */
 815 inline void MakeBuoy(Tile t, StationID sid, WaterClass wc)
 816 {
 817         /* Make the owner of the buoy tile the same as the current owner of the
 818          * water tile. In this way, we can reset the owner of the water to its
 819          * original state when the buoy gets removed. */
 820         MakeStation(t, GetTileOwner(t), sid, STATION_BUOY, 0, wc);
 821 }
 822
 823 /**
 824  * Make the given tile a dock tile.
 825  * @param t the tile to make a dock
 826  * @param o the owner of the dock
 827  * @param sid the station to which this tile belongs
 828  * @param d the direction of the dock
 829  * @param wc the type of water on this tile
 830  */
 831 inline void MakeDock(Tile t, Owner o, StationID sid, DiagDirection d, WaterClass wc)
 832 {
 833         MakeStation(t, o, sid, STATION_DOCK, d);
 834         MakeStation(TileIndex(t) + TileOffsByDiagDir(d), o, sid, STATION_DOCK, GFX_DOCK_BASE_WATER_PART + DiagDirToAxis(d), wc);
 835 }
 836
 837 /**
 838  * Make the given tile an oilrig tile.
 839  * @param t the tile to make an oilrig
 840  * @param sid the station to which this tile belongs
 841  * @param wc the type of water on this tile
 842  */
 843 inline void MakeOilrig(Tile t, StationID sid, WaterClass wc)
 844 {
 845         MakeStation(t, OWNER_NONE, sid, STATION_OILRIG, 0, wc);
 846 }
 847
 848 #endif /* STATION_MAP_H */