1

/* $Id$ */

     2

     3

#ifndef STATION_MAP_H

     4

#define STATION_MAP_H

     5

     6

#include "station.h"

     7

     8

static inline StationID GetStationIndex(TileIndex t)

     9

{

    10

	assert(IsTileType(t, MP_STATION));

    11

	return (StationID)_m[t].m2;

    12

}

    13

    14

static inline Station* GetStationByTile(TileIndex t)

    15

{

    16

	return GetStation(GetStationIndex(t));

    17

}

    18

    19

    20

enum {

    21

	RAILWAY_BASE = 0x0,

    22

	AIRPORT_BASE = 0x8,

    23

	TRUCK_BASE = 0x43,

    24

	BUS_BASE = 0x47,

    25

	OILRIG_BASE = 0x4B,

    26

	DOCK_BASE = 0x4C,

    27

	DOCK_BASE_WATER_PART = 0x50,

    28

	BUOY_BASE = 0x52,

    29

	AIRPORT_BASE_EXTENDED = 0x53,

    30

    31

	BASE_END = 0x73

    32

};

    33

    34

enum {

    35

	RAILWAY_SIZE = AIRPORT_BASE - RAILWAY_BASE,

    36

	AIRPORT_SIZE = TRUCK_BASE - AIRPORT_BASE,

    37

	TRUCK_SIZE = BUS_BASE - TRUCK_BASE,

    38

	BUS_SIZE = OILRIG_BASE - BUS_BASE,

    39

	DOCK_SIZE_TOTAL = BUOY_BASE - DOCK_BASE,

    40

	AIRPORT_SIZE_EXTENDED = BASE_END - AIRPORT_BASE_EXTENDED

    41

};

    42

    43

typedef enum HangarTiles {

    44

	HANGAR_TILE_0 = 32,

    45

	HANGAR_TILE_1 = 65,

    46

	HANGAR_TILE_2 = 86

    47

} HangarTiles;

    48

    49

typedef enum StationType {

    50

	STATION_RAIL,

    51

	STATION_HANGAR,

    52

	STATION_AIRPORT,

    53

	STATION_TRUCK,

    54

	STATION_BUS,

    55

	STATION_OILRIG,

    56

	STATION_DOCK,

    57

	STATION_BUOY

    58

} StationType;

    59

    60

StationType GetStationType(TileIndex);

    61

    62

static inline RoadStopType GetRoadStopType(TileIndex t)

    63

{

    64

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

    65

	return GetStationType(t) == STATION_TRUCK ? RS_TRUCK : RS_BUS;

    66

}

    67

    68

static inline bool IsRailwayStation(TileIndex t)

    69

{

    70

	assert(IsTileType(t, MP_STATION));

    71

	return _m[t].m5 < RAILWAY_BASE + RAILWAY_SIZE;

    72

}

    73

    74

static inline bool IsRailwayStationTile(TileIndex t)

    75

{

    76

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

    77

}

    78

    79

static inline bool IsHangar(TileIndex t)

    80

{

    81

	assert(IsTileType(t, MP_STATION));

    82

	return

    83

		_m[t].m5 == HANGAR_TILE_0 ||

    84

		_m[t].m5 == HANGAR_TILE_1 ||

    85

		_m[t].m5 == HANGAR_TILE_2;

    86

}

    87

    88

static inline bool IsAirport(TileIndex t)

    89

{

    90

	assert(IsTileType(t, MP_STATION));

    91

	return

    92

		IS_INT_INSIDE(_m[t].m5, AIRPORT_BASE, AIRPORT_BASE + AIRPORT_SIZE) ||

    93

		IS_INT_INSIDE(_m[t].m5, AIRPORT_BASE_EXTENDED, AIRPORT_BASE_EXTENDED + AIRPORT_SIZE_EXTENDED);

    94

}

    95

    96

static inline bool IsTruckStop(TileIndex t)

    97

{

    98

	assert(IsTileType(t, MP_STATION));

    99

	return IS_INT_INSIDE(_m[t].m5, TRUCK_BASE, TRUCK_BASE + TRUCK_SIZE);

   100

}

   101

   102

static inline bool IsBusStop(TileIndex t)

   103

{

   104

	assert(IsTileType(t, MP_STATION));

   105

	return IS_INT_INSIDE(_m[t].m5, BUS_BASE, BUS_BASE + BUS_SIZE);

   106

}

   107

   108

static inline bool IsRoadStop(TileIndex t)

   109

{

   110

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

   111

}

   112

   113

static inline bool IsRoadStopTile(TileIndex t)

   114

{

   115

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

   116

}

   117

   118

/**

   119

 * Gets the direction the road stop entrance points towards.

   120

 */

   121

static inline DiagDirection GetRoadStopDir(TileIndex tile)

   122

{

   123

	assert(IsRoadStopTile(tile));

   124

	return (_m[tile].m5 - TRUCK_BASE) & 3;

   125

}

   126

   127

static inline bool IsOilRig(TileIndex t)

   128

{

   129

	assert(IsTileType(t, MP_STATION));

   130

	return _m[t].m5 == OILRIG_BASE;

   131

}

   132

   133

static inline bool IsDock(TileIndex t)

   134

{

   135

	assert(IsTileType(t, MP_STATION));

   136

	return IS_INT_INSIDE(_m[t].m5, DOCK_BASE, DOCK_BASE + DOCK_SIZE_TOTAL);

   137

}

   138

   139

static inline bool IsBuoy_(TileIndex t) // XXX _ due to naming conflict

   140

{

   141

	assert(IsTileType(t, MP_STATION));

   142

	return _m[t].m5 == BUOY_BASE;

   143

}

   144

   145

static inline bool IsBuoyTile(TileIndex t)

   146

{

   147

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

   148

}

   149

   150

   151

static inline bool IsHangarTile(TileIndex t)

   152

{

   153

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

   154

}

   155

   156

   157

static inline Axis GetRailStationAxis(TileIndex t)

   158

{

   159

	assert(IsRailwayStation(t));

   160

	return HASBIT(_m[t].m5, 0) ? AXIS_Y : AXIS_X;

   161

}

   162

   163

   164

static inline Track GetRailStationTrack(TileIndex t)

   165

{

   166

	return GetRailStationAxis(t) == AXIS_X ? TRACK_X : TRACK_Y;

   167

}

   168

   169

static inline bool IsCompatibleTrainStationTile(TileIndex t1, TileIndex t2)

   170

{

   171

	assert(IsRailwayStationTile(t2));

   172

	return

   173

		IsRailwayStationTile(t1) &&

   174

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

   175

		GetRailStationAxis(t1) == GetRailStationAxis(t2);

   176

}

   177

   178

   179

static inline DiagDirection GetDockDirection(TileIndex t)

   180

{

   181

	assert(IsTileType(t, MP_STATION));

   182

	assert(_m[t].m5 < DOCK_BASE_WATER_PART);

   183

   184

	return (DiagDirection)(_m[t].m5 - DOCK_BASE);

   185

}

   186

   187

static inline TileIndexDiffC GetDockOffset(TileIndex t)

   188

{

   189

	static const TileIndexDiffC buoy_offset = {0, 0};

   190

	static const TileIndexDiffC oilrig_offset = {2, 0};

   191

	static const TileIndexDiffC dock_offset[DIAGDIR_END] = {

   192

		{-2,  0},

   193

		{ 0,  2},

   194

		{ 2,  0},

   195

		{ 0, -2},

   196

	};

   197

	assert(IsTileType(t, MP_STATION));

   198

   199

	if (IsBuoy_(t)) return buoy_offset;

   200

	if (IsOilRig(t)) return oilrig_offset;

   201

   202

	assert(IsDock(t));

   203

   204

	return dock_offset[GetDockDirection(t)];

   205

}

   206

   207

static inline bool IsCustomStationSprite(TileIndex t)

   208

{

   209

	assert(IsTileType(t, MP_STATION));

   210

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

   211

}

   212

   213

static inline void SetCustomStationSprite(TileIndex t, byte sprite)

   214

{

   215

	assert(IsTileType(t, MP_STATION));

   216

	SETBIT(_m[t].m3, 4);

   217

	_m[t].m4 = sprite;

   218

}

   219

   220

static inline uint GetCustomStationSprite(TileIndex t)

   221

{

   222

	assert(IsTileType(t, MP_STATION));

   223

	return _m[t].m4;

   224

}

   225

   226

static inline byte GetStationGfx(TileIndex t)

   227

{

   228

	assert(IsTileType(t, MP_STATION));

   229

	return _m[t].m5;

   230

}

   231

   232

   233

static inline void MakeStation(TileIndex t, Owner o, StationID sid, byte m5)

   234

{

   235

	SetTileType(t, MP_STATION);

   236

	SetTileOwner(t, o);

   237

	_m[t].m2 = sid;

   238

	_m[t].m3 = 0;

   239

	_m[t].m4 = 0;

   240

	_m[t].m5 = m5;

   241

}

   242

   243

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

   244

{

   245

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

   246

	SetRailType(t, rt);

   247

}

   248

   249

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

   250

{

   251

	MakeStation(t, o, sid, (rst == RS_BUS ? BUS_BASE : TRUCK_BASE) + d);

   252

}

   253

   254

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

   255

{

   256

	MakeStation(t, o, sid, section);

   257

}

   258

   259

static inline void MakeBuoy(TileIndex t, StationID sid)

   260

{

   261

	MakeStation(t, OWNER_NONE, sid, BUOY_BASE);

   262

}

   263

   264

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

   265

{

   266

	MakeStation(t, o, sid, DOCK_BASE + d);

   267

	MakeStation(t + TileOffsByDir(d), o, sid, DOCK_BASE_WATER_PART + DiagDirToAxis(d));

   268

}

   269

   270

static inline void MakeOilrig(TileIndex t, StationID sid)

   271

{

   272

	MakeStation(t, OWNER_NONE, sid, OILRIG_BASE);

   273

}

   274

   275

#endif