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

    75

{

    76

	assert(IsTileType(t, MP_STATION));

    77

	return

    78

		_m[t].m5 == HANGAR_TILE_0 ||

    79

		_m[t].m5 == HANGAR_TILE_1 ||

    80

		_m[t].m5 == HANGAR_TILE_2;

    81

}

    82

    83

static inline bool IsAirport(TileIndex t)

    84

{

    85

	assert(IsTileType(t, MP_STATION));

    86

	return

    87

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

    88

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

    89

}

    90

    91

static inline bool IsTruckStop(TileIndex t)

    92

{

    93

	assert(IsTileType(t, MP_STATION));

    94

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

    95

}

    96

    97

static inline bool IsBusStop(TileIndex t)

    98

{

    99

	assert(IsTileType(t, MP_STATION));

   100

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

   101

}

   102

   103

static inline bool IsRoadStop(TileIndex t)

   104

{

   105

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

   106

}

   107

   108

static inline bool IsRoadStopTile(TileIndex t)

   109

{

   110

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

   111

}

   112

   113

/**

   114

 * Gets the direction the road stop entrance points towards.

   115

 */

   116

static inline DiagDirection GetRoadStopDir(TileIndex tile)

   117

{

   118

	assert(IsRoadStopTile(tile));

   119

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

   120

}

   121

   122

static inline bool IsOilRig(TileIndex t)

   123

{

   124

	assert(IsTileType(t, MP_STATION));

   125

	return _m[t].m5 == OILRIG_BASE;

   126

}

   127

   128

static inline bool IsDock(TileIndex t)

   129

{

   130

	assert(IsTileType(t, MP_STATION));

   131

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

   132

}

   133

   134

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

   135

{

   136

	assert(IsTileType(t, MP_STATION));

   137

	return _m[t].m5 == BUOY_BASE;

   138

}

   139

   140

   141

static inline bool IsHangarTile(TileIndex t)

   142

{

   143

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

   144

}

   145

   146

   147

static inline Axis GetRailStationAxis(TileIndex t)

   148

{

   149

	assert(IsRailwayStation(t));

   150

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

   151

}

   152

   153

   154

static inline Track GetRailStationTrack(TileIndex t)

   155

{

   156

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

   157

}

   158

   159

   160

static inline DiagDirection GetDockDirection(TileIndex t)

   161

{

   162

	assert(IsTileType(t, MP_STATION));

   163

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

   164

   165

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

   166

}

   167

   168

   169

static inline bool IsCustomStationSprite(TileIndex t)

   170

{

   171

	assert(IsTileType(t, MP_STATION));

   172

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

   173

}

   174

   175

static inline void SetCustomStationSprite(TileIndex t, byte sprite)

   176

{

   177

	assert(IsTileType(t, MP_STATION));

   178

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

   179

	_m[t].m4 = sprite;

   180

}

   181

   182

static inline uint GetCustomStationSprite(TileIndex t)

   183

{

   184

	assert(IsTileType(t, MP_STATION));

   185

	return _m[t].m4;

   186

}

   187

   188

   189

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

   190

{

   191

	SetTileType(t, MP_STATION);

   192

	SetTileOwner(t, o);

   193

	_m[t].m2 = sid;

   194

	_m[t].m3 = 0;

   195

	_m[t].m4 = 0;

   196

	_m[t].m5 = m5;

   197

}

   198

   199

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

   200

{

   201

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

   202

	SetRailType(t, rt);

   203

}

   204

   205

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

   206

{

   207

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

   208

}

   209

   210

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

   211

{

   212

	MakeStation(t, o, sid, section);

   213

}

   214

   215

static inline void MakeBuoy(TileIndex t, StationID sid)

   216

{

   217

	MakeStation(t, OWNER_NONE, sid, BUOY_BASE);

   218

}

   219

   220

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

   221

{

   222

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

   223

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

   224

}

   225

   226

static inline void MakeOilrig(TileIndex t, StationID sid)

   227

{

   228

	MakeStation(t, OWNER_NONE, sid, OILRIG_BASE);

   229

}

   230

   231

#endif