1

/* $Id$ */

     2

     3

/** @file station_map.h Maps accessors for stations. */

     4

     5

#ifndef STATION_MAP_H

     6

#define STATION_MAP_H

     7

     8

#include "rail_map.h"

     9

#include "road_map.h"

    10

#include "water_map.h"

    11

#include "station_func.h"

    12

#include "station_base.h"

    13

#include "rail.h"

    14

    15

typedef byte StationGfx;

    16

    17

/** Get Station ID from a tile

    18

 * @pre Tile \t must be part of the station

    19

 * @param t Tile to query station ID from

    20

 * @return Station ID of the station at \a t */

    21

static inline StationID GetStationIndex(TileIndex t)

    22

{

    23

	assert(IsTileType(t, MP_STATION));

    24

	return (StationID)_m[t].m2;

    25

}

    26

    27

static inline Station *GetStationByTile(TileIndex t)

    28

{

    29

	return GetStation(GetStationIndex(t));

    30

}

    31

    32

    33

enum {

    34

	GFX_RADAR_LARGE_FIRST             =  31,

    35

	GFX_RADAR_LARGE_LAST              =  42,

    36

	GFX_WINDSACK_FIRST                =  50,

    37

	GFX_WINDSACK_LAST                 =  53,

    38

    39

	GFX_DOCK_BASE_WATER_PART          =  4,

    40

	GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET =  4,

    41

    42

	GFX_RADAR_INTERNATIONAL_FIRST     =  66,

    43

	GFX_RADAR_INTERNATIONAL_LAST      =  77,

    44

	GFX_RADAR_METROPOLITAN_FIRST      =  78,

    45

	GFX_RADAR_METROPOLITAN_LAST       =  89,

    46

	GFX_RADAR_DISTRICTWE_FIRST        = 121,

    47

	GFX_RADAR_DISTRICTWE_LAST         = 132,

    48

	GFX_WINDSACK_INTERCON_FIRST       = 140,

    49

	GFX_WINDSACK_INTERCON_LAST        = 143,

    50

};

    51

    52

static inline StationType GetStationType(TileIndex t)

    53

{

    54

	return (StationType)GB(_m[t].m6, 3, 3);

    55

}

    56

    57

static inline RoadStopType GetRoadStopType(TileIndex t)

    58

{

    59

	assert(GetStationType(t) == STATION_TRUCK || GetStationType(t) == STATION_BUS);

    60

	return GetStationType(t) == STATION_TRUCK ? ROADSTOP_TRUCK : ROADSTOP_BUS;

    61

}

    62

    63

static inline StationGfx GetStationGfx(TileIndex t)

    64

{

    65

	assert(IsTileType(t, MP_STATION));

    66

	return _m[t].m5;

    67

}

    68

    69

static inline void SetStationGfx(TileIndex t, StationGfx gfx)

    70

{

    71

	assert(IsTileType(t, MP_STATION));

    72

	_m[t].m5 = gfx;

    73

}

    74

    75

static inline uint8 GetStationAnimationFrame(TileIndex t)

    76

{

    77

	assert(IsTileType(t, MP_STATION));

    78

	return _me[t].m7;

    79

}

    80

    81

static inline void SetStationAnimationFrame(TileIndex t, uint8 frame)

    82

{

    83

	assert(IsTileType(t, MP_STATION));

    84

	_me[t].m7 = frame;

    85

}

    86

    87

static inline bool IsRailwayStation(TileIndex t)

    88

{

    89

	return GetStationType(t) == STATION_RAIL;

    90

}

    91

    92

static inline bool IsRailwayStationTile(TileIndex t)

    93

{

    94

	return IsTileType(t, MP_STATION) && IsRailwayStation(t);

    95

}

    96

    97

static inline bool IsAirport(TileIndex t)

    98

{

    99

	return GetStationType(t) == STATION_AIRPORT;

   100

}

   101

   102

bool IsHangar(TileIndex t);

   103

   104

/**

   105

 * Is the station at \a t a truck stop?

   106

 * @param t Tile to check

   107

 * @return \c true if station is a truck stop, \c false otherwise */

   108

static inline bool IsTruckStop(TileIndex t)

   109

{

   110

	return GetStationType(t) == STATION_TRUCK;

   111

}

   112

   113

/**

   114

 * Is the station at \a t a bus stop?

   115

 * @param t Tile to check

   116

 * @return \c true if station is a bus stop, \c false otherwise */

   117

static inline bool IsBusStop(TileIndex t)

   118

{

   119

	return GetStationType(t) == STATION_BUS;

   120

}

   121

   122

/**

   123

 * Is the station at \a t a road station?

   124

 * @pre Tile at \a t is a station tile

   125

 * @param t Tile to check

   126

 * @return \c true if station at the tile is a bus top or a truck stop, \c false otherwise */

   127

static inline bool IsRoadStop(TileIndex t)

   128

{

   129

	assert(IsTileType(t, MP_STATION));

   130

	return IsTruckStop(t) || IsBusStop(t);

   131

}

   132

   133

static inline bool IsRoadStopTile(TileIndex t)

   134

{

   135

	return IsTileType(t, MP_STATION) && IsRoadStop(t);

   136

}

   137

   138

static inline bool IsStandardRoadStopTile(TileIndex t)

   139

{

   140

	return IsRoadStopTile(t) && GetStationGfx(t) < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET;

   141

}

   142

   143

static inline bool IsDriveThroughStopTile(TileIndex t)

   144

{

   145

	return IsRoadStopTile(t) && GetStationGfx(t) >= GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET;

   146

}

   147

   148

static inline bool GetStopBuiltOnTownRoad(TileIndex t)

   149

{

   150

	assert(IsDriveThroughStopTile(t));

   151

	return HasBit(_m[t].m6, 2);

   152

}

   153

   154

static inline void SetStopBuiltOnTownRoad(TileIndex t, bool on_town_road)

   155

{

   156

	assert(IsDriveThroughStopTile(t));

   157

	SB(_m[t].m6, 2, 1, on_town_road);

   158

}

   159

   160

   161

/**

   162

 * Gets the direction the road stop entrance points towards.

   163

 */

   164

static inline DiagDirection GetRoadStopDir(TileIndex t)

   165

{

   166

	StationGfx gfx = GetStationGfx(t);

   167

	assert(IsRoadStopTile(t));

   168

	if (gfx < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET) {

   169

		return (DiagDirection)(gfx);

   170

	} else {

   171

		return (DiagDirection)(gfx - GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);

   172

	}

   173

}

   174

   175

static inline bool IsOilRig(TileIndex t)

   176

{

   177

	return GetStationType(t) == STATION_OILRIG;

   178

}

   179

   180

static inline bool IsDock(TileIndex t)

   181

{

   182

	return GetStationType(t) == STATION_DOCK;

   183

}

   184

   185

static inline bool IsDockTile(TileIndex t)

   186

{

   187

	return IsTileType(t, MP_STATION) && GetStationType(t) == STATION_DOCK;

   188

}

   189

   190

static inline bool IsBuoy(TileIndex t)

   191

{

   192

	return GetStationType(t) == STATION_BUOY;

   193

}

   194

   195

static inline bool IsBuoyTile(TileIndex t)

   196

{

   197

	return IsTileType(t, MP_STATION) && IsBuoy(t);

   198

}

   199

   200

static inline bool IsHangarTile(TileIndex t)

   201

{

   202

	return IsTileType(t, MP_STATION) && IsHangar(t);

   203

}

   204

   205

   206

static inline Axis GetRailStationAxis(TileIndex t)

   207

{

   208

	assert(IsRailwayStation(t));

   209

	return HasBit(GetStationGfx(t), 0) ? AXIS_Y : AXIS_X;

   210

}

   211

   212

   213

static inline Track GetRailStationTrack(TileIndex t)

   214

{

   215

	return AxisToTrack(GetRailStationAxis(t));

   216

}

   217

   218

static inline bool IsCompatibleTrainStationTile(TileIndex t1, TileIndex t2)

   219

{

   220

	assert(IsRailwayStationTile(t2));

   221

	return

   222

		IsRailwayStationTile(t1) &&

   223

		IsCompatibleRail(GetRailType(t1), GetRailType(t2)) &&

   224

		GetRailStationAxis(t1) == GetRailStationAxis(t2) &&

   225

		GetStationIndex(t1) == GetStationIndex(t2) &&

   226

		!IsStationTileBlocked(t1);

   227

}

   228

   229

/**

   230

 * Get the reservation state of the rail station

   231

 * @pre IsRailwayStationTile(t)

   232

 * @param t the station tile

   233

 * @return reservation state

   234

 */

   235

static inline bool GetRailwayStationReservation(TileIndex t)

   236

{

   237

	assert(IsRailwayStationTile(t));

   238

	return HasBit(_m[t].m6, 2);

   239

}

   240

   241

/**

   242

 * Set the reservation state of the rail station

   243

 * @pre IsRailwayStationTile(t)

   244

 * @param t the station tile

   245

 * @param b the reservation state

   246

 */

   247

static inline void SetRailwayStationReservation(TileIndex t, bool b)

   248

{

   249

	assert(IsRailwayStationTile(t));

   250

	SB(_m[t].m6, 2, 1, b ? 1 : 0);

   251

}

   252

   253

/**

   254

 * Get the reserved track bits for a waypoint

   255

 * @pre IsRailwayStationTile(t)

   256

 * @param t the tile

   257

 * @return reserved track bits

   258

 */

   259

static inline TrackBits GetRailStationReservation(TileIndex t)

   260

{

   261

	return GetRailwayStationReservation(t) ? AxisToTrackBits(GetRailStationAxis(t)) : TRACK_BIT_NONE;

   262

}

   263

   264

   265

static inline DiagDirection GetDockDirection(TileIndex t)

   266

{

   267

	StationGfx gfx = GetStationGfx(t);

   268

	assert(IsDock(t) && gfx < GFX_DOCK_BASE_WATER_PART);

   269

	return (DiagDirection)(gfx);

   270

}

   271

   272

static inline TileIndexDiffC GetDockOffset(TileIndex t)

   273

{

   274

	static const TileIndexDiffC buoy_offset = {0, 0};

   275

	static const TileIndexDiffC oilrig_offset = {2, 0};

   276

	static const TileIndexDiffC dock_offset[DIAGDIR_END] = {

   277

		{-2,  0},

   278

		{ 0,  2},

   279

		{ 2,  0},

   280

		{ 0, -2},

   281

	};

   282

	assert(IsTileType(t, MP_STATION));

   283

   284

	if (IsBuoy(t)) return buoy_offset;

   285

	if (IsOilRig(t)) return oilrig_offset;

   286

   287

	assert(IsDock(t));

   288

   289

	return dock_offset[GetDockDirection(t)];

   290

}

   291

   292

static inline bool IsCustomStationSpecIndex(TileIndex t)

   293

{

   294

	assert(IsTileType(t, MP_STATION));

   295

	return _m[t].m4 != 0;

   296

}

   297

   298

static inline void SetCustomStationSpecIndex(TileIndex t, byte specindex)

   299

{

   300

	assert(IsTileType(t, MP_STATION));

   301

	_m[t].m4 = specindex;

   302

}

   303

   304

static inline uint GetCustomStationSpecIndex(TileIndex t)

   305

{

   306

	assert(IsTileType(t, MP_STATION));

   307

	return _m[t].m4;

   308

}

   309

   310

static inline void SetStationTileRandomBits(TileIndex t, byte random_bits)

   311

{

   312

	assert(IsTileType(t, MP_STATION));

   313

	SB(_m[t].m3, 4, 4, random_bits);

   314

}

   315

   316

static inline byte GetStationTileRandomBits(TileIndex t)

   317

{

   318

	assert(IsTileType(t, MP_STATION));

   319

	return GB(_m[t].m3, 4, 4);

   320

}

   321

   322

static inline void MakeStation(TileIndex t, Owner o, StationID sid, StationType st, byte section)

   323

{

   324

	SetTileType(t, MP_STATION);

   325

	SetTileOwner(t, o);

   326

	_m[t].m2 = sid;

   327

	_m[t].m3 = 0;

   328

	_m[t].m4 = 0;

   329

	_m[t].m5 = section;

   330

	SB(_m[t].m6, 3, 3, st);

   331

}

   332

   333

static inline void MakeRailStation(TileIndex t, Owner o, StationID sid, Axis a, byte section, RailType rt)

   334

{

   335

	MakeStation(t, o, sid, STATION_RAIL, section + a);

   336

	SetRailType(t, rt);

   337

	SetRailwayStationReservation(t, false);

   338

}

   339

   340

static inline void MakeRoadStop(TileIndex t, Owner o, StationID sid, RoadStopType rst, RoadTypes rt, DiagDirection d)

   341

{

   342

	MakeStation(t, o, sid, (rst == ROADSTOP_BUS ? STATION_BUS : STATION_TRUCK), d);

   343

	SetRoadTypes(t, rt);

   344

}

   345

   346

static inline void MakeDriveThroughRoadStop(TileIndex t, Owner o, StationID sid, RoadStopType rst, RoadTypes rt, Axis a, bool on_town_road)

   347

{

   348

	MakeStation(t, o, sid, (rst == ROADSTOP_BUS ? STATION_BUS : STATION_TRUCK), GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET + a);

   349

	SB(_m[t].m6, 2, 1, on_town_road);

   350

	SetRoadTypes(t, rt);

   351

}

   352

   353

static inline void MakeAirport(TileIndex t, Owner o, StationID sid, byte section)

   354

{

   355

	MakeStation(t, o, sid, STATION_AIRPORT, section);

   356

}

   357

   358

static inline void MakeBuoy(TileIndex t, StationID sid, WaterClass wc)

   359

{

   360

	/* Make the owner of the buoy tile the same as the current owner of the

   361

	 * water tile. In this way, we can reset the owner of the water to its

   362

	 * original state when the buoy gets removed. */

   363

	MakeStation(t, GetTileOwner(t), sid, STATION_BUOY, 0);

   364

	SetWaterClass(t, wc);

   365

}

   366

   367

static inline void MakeDock(TileIndex t, Owner o, StationID sid, DiagDirection d, WaterClass wc)

   368

{

   369

	MakeStation(t, o, sid, STATION_DOCK, d);

   370

	MakeStation(t + TileOffsByDiagDir(d), o, sid, STATION_DOCK, GFX_DOCK_BASE_WATER_PART + DiagDirToAxis(d));

   371

	SetWaterClass(t + TileOffsByDiagDir(d), wc);

   372

}

   373

   374

static inline void MakeOilrig(TileIndex t, StationID sid, WaterClass wc)

   375

{

   376

	MakeStation(t, OWNER_NONE, sid, STATION_OILRIG, 0);

   377

	SetWaterClass(t, wc);

   378

}

   379

   380

#endif /* STATION_MAP_H */