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

   109

{

   110

	assert(IsTileType(t, MP_STATION));

   111

	return _m[t].m5 == OILRIG_BASE;

   112

}

   113

   114

static inline bool IsDock(TileIndex t)

   115

{

   116

	assert(IsTileType(t, MP_STATION));

   117

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

   118

}

   119

   120

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

   121

{

   122

	assert(IsTileType(t, MP_STATION));

   123

	return _m[t].m5 == BUOY_BASE;

   124

}

   125

   126

   127

static inline bool IsHangarTile(TileIndex t)

   128

{

   129

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

   130

}

   131

   132

   133

static inline Axis GetRailStationAxis(TileIndex t)

   134

{

   135

	assert(IsRailwayStation(t));

   136

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

   137

}

   138

   139

   140

static inline Track GetRailStationTrack(TileIndex t)

   141

{

   142

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

   143

}

   144

   145

   146

static inline DiagDirection GetDockDirection(TileIndex t)

   147

{

   148

	assert(IsTileType(t, MP_STATION));

   149

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

   150

   151

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

   152

}

   153

   154

   155

static inline bool IsCustomStationSprite(TileIndex t)

   156

{

   157

	assert(IsTileType(t, MP_STATION));

   158

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

   159

}

   160

   161

static inline void SetCustomStationSprite(TileIndex t, byte sprite)

   162

{

   163

	assert(IsTileType(t, MP_STATION));

   164

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

   165

	_m[t].m4 = sprite;

   166

}

   167

   168

static inline uint GetCustomStationSprite(TileIndex t)

   169

{

   170

	assert(IsTileType(t, MP_STATION));

   171

	return _m[t].m4;

   172

}

   173

   174

   175

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

   176

{

   177

	SetTileType(t, MP_STATION);

   178

	SetTileOwner(t, o);

   179

	_m[t].m2 = sid;

   180

	_m[t].m3 = 0;

   181

	_m[t].m4 = 0;

   182

	_m[t].m5 = m5;

   183

}

   184

   185

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

   186

{

   187

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

   188

	SetRailType(t, rt);

   189

}

   190

   191

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

   192

{

   193

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

   194

}

   195

   196

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

   197

{

   198

	MakeStation(t, o, sid, section);

   199

}

   200

   201

static inline void MakeBuoy(TileIndex t, StationID sid)

   202

{

   203

	MakeStation(t, OWNER_NONE, sid, BUOY_BASE);

   204

}

   205

   206

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

   207

{

   208

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

   209

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

   210

}

   211

   212

static inline void MakeOilrig(TileIndex t, StationID sid)

   213

{

   214

	MakeStation(t, OWNER_NONE, sid, OILRIG_BASE);

   215

}

   216

   217

#endif