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

static inline StationID GetStationIndex(TileIndex t)

    18

{

    19

	assert(IsTileType(t, MP_STATION));

    20

	return (StationID)_m[t].m2;

    21

}

    22

    23

static inline Station *GetStationByTile(TileIndex t)

    24

{

    25

	return GetStation(GetStationIndex(t));

    26

}

    27

    28

    29

enum {

    30

	GFX_RADAR_LARGE_FIRST             =  31,

    31

	GFX_RADAR_LARGE_LAST              =  42,

    32

	GFX_WINDSACK_FIRST                =  50,

    33

	GFX_WINDSACK_LAST                 =  53,

    34

    35

	GFX_DOCK_BASE_WATER_PART          =  4,

    36

	GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET =  4,

    37

    38

	GFX_RADAR_INTERNATIONAL_FIRST     =  66,

    39

	GFX_RADAR_INTERNATIONAL_LAST      =  77,

    40

	GFX_RADAR_METROPOLITAN_FIRST      =  78,

    41

	GFX_RADAR_METROPOLITAN_LAST       =  89,

    42

	GFX_RADAR_DISTRICTWE_FIRST        = 121,

    43

	GFX_RADAR_DISTRICTWE_LAST         = 132,

    44

	GFX_WINDSACK_INTERCON_FIRST       = 140,

    45

	GFX_WINDSACK_INTERCON_LAST        = 143,

    46

};

    47

    48

static inline StationType GetStationType(TileIndex t)

    49

{

    50

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

    51

}

    52

    53

static inline RoadStopType GetRoadStopType(TileIndex t)

    54

{

    55

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

    56

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

    57

}

    58

    59

static inline StationGfx GetStationGfx(TileIndex t)

    60

{

    61

	assert(IsTileType(t, MP_STATION));

    62

	return _m[t].m5;

    63

}

    64

    65

static inline void SetStationGfx(TileIndex t, StationGfx gfx)

    66

{

    67

	assert(IsTileType(t, MP_STATION));

    68

	_m[t].m5 = gfx;

    69

}

    70

    71

static inline uint8 GetStationAnimationFrame(TileIndex t)

    72

{

    73

	assert(IsTileType(t, MP_STATION));

    74

	return _me[t].m7;

    75

}

    76

    77

static inline void SetStationAnimationFrame(TileIndex t, uint8 frame)

    78

{

    79

	assert(IsTileType(t, MP_STATION));

    80

	_me[t].m7 = frame;

    81

}

    82

    83

static inline bool IsRailwayStation(TileIndex t)

    84

{

    85

	return GetStationType(t) == STATION_RAIL;

    86

}

    87

    88

static inline bool IsRailwayStationTile(TileIndex t)

    89

{

    90

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

    91

}

    92

    93

static inline bool IsAirport(TileIndex t)

    94

{

    95

	return GetStationType(t) == STATION_AIRPORT;

    96

}

    97

    98

bool IsHangar(TileIndex t);

    99

   100

static inline bool IsTruckStop(TileIndex t)

   101

{

   102

	return GetStationType(t) == STATION_TRUCK;

   103

}

   104

   105

static inline bool IsBusStop(TileIndex t)

   106

{

   107

	return GetStationType(t) == STATION_BUS;

   108

}

   109

   110

static inline bool IsRoadStop(TileIndex t)

   111

{

   112

	assert(IsTileType(t, MP_STATION));

   113

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

   114

}

   115

   116

static inline bool IsRoadStopTile(TileIndex t)

   117

{

   118

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

   119

}

   120

   121

static inline bool IsStandardRoadStopTile(TileIndex t)

   122

{

   123

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

   124

}

   125

   126

static inline bool IsDriveThroughStopTile(TileIndex t)

   127

{

   128

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

   129

}

   130

   131

static inline bool GetStopBuiltOnTownRoad(TileIndex t)

   132

{

   133

	assert(IsDriveThroughStopTile(t));

   134

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

   135

}

   136

   137

static inline void SetStopBuiltOnTownRoad(TileIndex t, bool on_town_road)

   138

{

   139

	assert(IsDriveThroughStopTile(t));

   140

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

   141

}

   142

   143

   144

/**

   145

 * Gets the direction the road stop entrance points towards.

   146

 */

   147

static inline DiagDirection GetRoadStopDir(TileIndex t)

   148

{

   149

	StationGfx gfx = GetStationGfx(t);

   150

	assert(IsRoadStopTile(t));

   151

	if (gfx < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET) {

   152

		return (DiagDirection)(gfx);

   153

	} else {

   154

		return (DiagDirection)(gfx - GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);

   155

	}

   156

}

   157

   158

static inline bool IsOilRig(TileIndex t)

   159

{

   160

	return GetStationType(t) == STATION_OILRIG;

   161

}

   162

   163

static inline bool IsDock(TileIndex t)

   164

{

   165

	return GetStationType(t) == STATION_DOCK;

   166

}

   167

   168

static inline bool IsBuoy(TileIndex t)

   169

{

   170

	return GetStationType(t) == STATION_BUOY;

   171

}

   172

   173

static inline bool IsBuoyTile(TileIndex t)

   174

{

   175

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

   176

}

   177

   178

static inline bool IsHangarTile(TileIndex t)

   179

{

   180

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

   181

}

   182

   183

   184

static inline Axis GetRailStationAxis(TileIndex t)

   185

{

   186

	assert(IsRailwayStation(t));

   187

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

   188

}

   189

   190

   191

static inline Track GetRailStationTrack(TileIndex t)

   192

{

   193

	return AxisToTrack(GetRailStationAxis(t));

   194

}

   195

   196

static inline bool IsCompatibleTrainStationTile(TileIndex t1, TileIndex t2)

   197

{

   198

	assert(IsRailwayStationTile(t2));

   199

	return

   200

		IsRailwayStationTile(t1) &&

   201

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

   202

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

   203

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

   204

		!IsStationTileBlocked(t1);

   205

}

   206

   207

   208

static inline DiagDirection GetDockDirection(TileIndex t)

   209

{

   210

	StationGfx gfx = GetStationGfx(t);

   211

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

   212

	return (DiagDirection)(gfx);

   213

}

   214

   215

static inline TileIndexDiffC GetDockOffset(TileIndex t)

   216

{

   217

	static const TileIndexDiffC buoy_offset = {0, 0};

   218

	static const TileIndexDiffC oilrig_offset = {2, 0};

   219

	static const TileIndexDiffC dock_offset[DIAGDIR_END] = {

   220

		{-2,  0},

   221

		{ 0,  2},

   222

		{ 2,  0},

   223

		{ 0, -2},

   224

	};

   225

	assert(IsTileType(t, MP_STATION));

   226

   227

	if (IsBuoy(t)) return buoy_offset;

   228

	if (IsOilRig(t)) return oilrig_offset;

   229

   230

	assert(IsDock(t));

   231

   232

	return dock_offset[GetDockDirection(t)];

   233

}

   234

   235

static inline bool IsCustomStationSpecIndex(TileIndex t)

   236

{

   237

	assert(IsTileType(t, MP_STATION));

   238

	return _m[t].m4 != 0;

   239

}

   240

   241

static inline void SetCustomStationSpecIndex(TileIndex t, byte specindex)

   242

{

   243

	assert(IsTileType(t, MP_STATION));

   244

	_m[t].m4 = specindex;

   245

}

   246

   247

static inline uint GetCustomStationSpecIndex(TileIndex t)

   248

{

   249

	assert(IsTileType(t, MP_STATION));

   250

	return _m[t].m4;

   251

}

   252

   253

static inline void SetStationTileRandomBits(TileIndex t, byte random_bits)

   254

{

   255

	assert(IsTileType(t, MP_STATION));

   256

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

   257

}

   258

   259

static inline byte GetStationTileRandomBits(TileIndex t)

   260

{

   261

	assert(IsTileType(t, MP_STATION));

   262

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

   263

}

   264

   265

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

   266

{

   267

	SetTileType(t, MP_STATION);

   268

	SetTileOwner(t, o);

   269

	_m[t].m2 = sid;

   270

	_m[t].m3 = 0;

   271

	_m[t].m4 = 0;

   272

	_m[t].m5 = section;

   273

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

   274

}

   275

   276

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

   277

{

   278

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

   279

	SetRailType(t, rt);

   280

}

   281

   282

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

   283

{

   284

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

   285

	SetRoadTypes(t, rt);

   286

}

   287

   288

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

   289

{

   290

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

   291

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

   292

	SetRoadTypes(t, rt);

   293

}

   294

   295

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

   296

{

   297

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

   298

}

   299

   300

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

   301

{

   302

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

   303

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

   304

	 * original state when the buoy gets removed. */

   305

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

   306

	SetWaterClass(t, wc);

   307

}

   308

   309

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

   310

{

   311

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

   312

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

   313

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

   314

}

   315

   316

static inline void MakeOilrig(TileIndex t, StationID sid)

   317

{

   318

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

   319

}

   320

   321

#endif /* STATION_MAP_H */