1

/* $Id$ */

     2

     3

/** @file station_map.h */

     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 bool IsRailwayStation(TileIndex t)

    72

{

    73

	return GetStationType(t) == STATION_RAIL;

    74

}

    75

    76

static inline bool IsRailwayStationTile(TileIndex t)

    77

{

    78

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

    79

}

    80

    81

static inline bool IsAirport(TileIndex t)

    82

{

    83

	return GetStationType(t) == STATION_AIRPORT;

    84

}

    85

    86

bool IsHangar(TileIndex t);

    87

    88

static inline bool IsTruckStop(TileIndex t)

    89

{

    90

	return GetStationType(t) == STATION_TRUCK;

    91

}

    92

    93

static inline bool IsBusStop(TileIndex t)

    94

{

    95

	return GetStationType(t) == STATION_BUS;

    96

}

    97

    98

static inline bool IsRoadStop(TileIndex t)

    99

{

   100

	assert(IsTileType(t, MP_STATION));

   101

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

   102

}

   103

   104

static inline bool IsRoadStopTile(TileIndex t)

   105

{

   106

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

   107

}

   108

   109

static inline bool IsStandardRoadStopTile(TileIndex t)

   110

{

   111

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

   112

}

   113

   114

static inline bool IsDriveThroughStopTile(TileIndex t)

   115

{

   116

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

   117

}

   118

   119

static inline bool GetStopBuiltOnTownRoad(TileIndex t)

   120

{

   121

	assert(IsDriveThroughStopTile(t));

   122

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

   123

}

   124

   125

   126

/**

   127

 * Gets the direction the road stop entrance points towards.

   128

 */

   129

static inline DiagDirection GetRoadStopDir(TileIndex t)

   130

{

   131

	StationGfx gfx = GetStationGfx(t);

   132

	assert(IsRoadStopTile(t));

   133

	if (gfx < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET) {

   134

		return (DiagDirection)(gfx);

   135

	} else {

   136

		return (DiagDirection)(gfx - GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);

   137

	}

   138

}

   139

   140

static inline bool IsOilRig(TileIndex t)

   141

{

   142

	return GetStationType(t) == STATION_OILRIG;

   143

}

   144

   145

static inline bool IsDock(TileIndex t)

   146

{

   147

	return GetStationType(t) == STATION_DOCK;

   148

}

   149

   150

static inline bool IsBuoy(TileIndex t)

   151

{

   152

	return GetStationType(t) == STATION_BUOY;

   153

}

   154

   155

static inline bool IsBuoyTile(TileIndex t)

   156

{

   157

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

   158

}

   159

   160

static inline bool IsHangarTile(TileIndex t)

   161

{

   162

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

   163

}

   164

   165

   166

static inline Axis GetRailStationAxis(TileIndex t)

   167

{

   168

	assert(IsRailwayStation(t));

   169

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

   170

}

   171

   172

   173

static inline Track GetRailStationTrack(TileIndex t)

   174

{

   175

	return AxisToTrack(GetRailStationAxis(t));

   176

}

   177

   178

static inline bool IsCompatibleTrainStationTile(TileIndex t1, TileIndex t2)

   179

{

   180

	assert(IsRailwayStationTile(t2));

   181

	return

   182

		IsRailwayStationTile(t1) &&

   183

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

   184

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

   185

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

   186

		!IsStationTileBlocked(t1);

   187

}

   188

   189

   190

static inline DiagDirection GetDockDirection(TileIndex t)

   191

{

   192

	StationGfx gfx = GetStationGfx(t);

   193

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

   194

	return (DiagDirection)(gfx);

   195

}

   196

   197

static inline TileIndexDiffC GetDockOffset(TileIndex t)

   198

{

   199

	static const TileIndexDiffC buoy_offset = {0, 0};

   200

	static const TileIndexDiffC oilrig_offset = {2, 0};

   201

	static const TileIndexDiffC dock_offset[DIAGDIR_END] = {

   202

		{-2,  0},

   203

		{ 0,  2},

   204

		{ 2,  0},

   205

		{ 0, -2},

   206

	};

   207

	assert(IsTileType(t, MP_STATION));

   208

   209

	if (IsBuoy(t)) return buoy_offset;

   210

	if (IsOilRig(t)) return oilrig_offset;

   211

   212

	assert(IsDock(t));

   213

   214

	return dock_offset[GetDockDirection(t)];

   215

}

   216

   217

static inline bool IsCustomStationSpecIndex(TileIndex t)

   218

{

   219

	assert(IsTileType(t, MP_STATION));

   220

	return _m[t].m4 != 0;

   221

}

   222

   223

static inline void SetCustomStationSpecIndex(TileIndex t, byte specindex)

   224

{

   225

	assert(IsTileType(t, MP_STATION));

   226

	_m[t].m4 = specindex;

   227

}

   228

   229

static inline uint GetCustomStationSpecIndex(TileIndex t)

   230

{

   231

	assert(IsTileType(t, MP_STATION));

   232

	return _m[t].m4;

   233

}

   234

   235

static inline void SetStationTileRandomBits(TileIndex t, byte random_bits)

   236

{

   237

	assert(IsTileType(t, MP_STATION));

   238

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

   239

}

   240

   241

static inline byte GetStationTileRandomBits(TileIndex t)

   242

{

   243

	assert(IsTileType(t, MP_STATION));

   244

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

   245

}

   246

   247

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

   248

{

   249

	SetTileType(t, MP_STATION);

   250

	SetTileOwner(t, o);

   251

	_m[t].m2 = sid;

   252

	_m[t].m3 = 0;

   253

	_m[t].m4 = 0;

   254

	_m[t].m5 = section;

   255

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

   256

}

   257

   258

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

   259

{

   260

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

   261

	SetRailType(t, rt);

   262

}

   263

   264

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

   265

{

   266

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

   267

	SetRoadTypes(t, rt);

   268

}

   269

   270

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

   271

{

   272

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

   273

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

   274

	SetRoadTypes(t, rt);

   275

}

   276

   277

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

   278

{

   279

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

   280

}

   281

   282

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

   283

{

   284

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

   285

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

   286

	 * original state when the buoy gets removed. */

   287

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

   288

	SetWaterClass(t, wc);

   289

}

   290

   291

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

   292

{

   293

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

   294

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

   295

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

   296

}

   297

   298

static inline void MakeOilrig(TileIndex t, StationID sid)

   299

{

   300

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

   301

}

   302

   303

#endif /* STATION_MAP_H */