1

/* $Id$ */

     2

     3

#ifndef STATION_MAP_H

     4

#define STATION_MAP_H

     5

     6

#include "station.h"

     7

#include "water_map.h" /* for IsClearWaterTile */

     8

     9

    10

static inline StationID GetStationIndex(TileIndex t)

    11

{

    12

	return (StationID)_m[t].m2;

    13

}

    14

    15

static inline Station* GetStationByTile(TileIndex t)

    16

{

    17

	return GetStation(GetStationIndex(t));

    18

}

    19

    20

    21

enum {

    22

	RAILWAY_BASE = 0x0,

    23

	AIRPORT_BASE = 0x8,

    24

	TRUCK_BASE = 0x43,

    25

	BUS_BASE = 0x47,

    26

	OILRIG_BASE = 0x4B,

    27

	DOCK_BASE = 0x4C,

    28

	DOCK_BASE_WATER_PART = 0x50,

    29

	BUOY_BASE = 0x52,

    30

	AIRPORT_BASE_EXTENDED = 0x53,

    31

    32

	TYPE_MAX = 0x72

    33

};

    34

    35

enum {

    36

	RAILWAY_SIZE = AIRPORT_BASE - RAILWAY_BASE,

    37

	AIRPORT_SIZE = TRUCK_BASE - AIRPORT_BASE,

    38

	TRUCK_SIZE = BUS_BASE - TRUCK_BASE,

    39

	BUS_SIZE = OILRIG_BASE - BUS_BASE,

    40

	DOCK_SIZE_TOTAL = BUOY_BASE - DOCK_BASE,

    41

	AIRPORT_SIZE_EXTENDED = TYPE_MAX - AIRPORT_BASE_EXTENDED

    42

};

    43

    44

typedef enum HangarTiles {

    45

	HANGAR_TILE_0 = 32,

    46

	HANGAR_TILE_1 = 65,

    47

	HANGAR_TILE_2 = 86

    48

} HangarTiles;

    49

    50

typedef enum StationType {

    51

	STATION_RAIL,

    52

	STATION_HANGAR,

    53

	STATION_AIRPORT,

    54

	STATION_TRUCK,

    55

	STATION_BUS,

    56

	STATION_OILRIG,

    57

	STATION_DOCK,

    58

	STATION_BUOY

    59

} StationType;

    60

    61

StationType GetStationType(TileIndex);

    62

    63

static inline bool IsRailwayStation(TileIndex t)

    64

{

    65

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

    66

}

    67

    68

static inline bool IsHangar(TileIndex t)

    69

{

    70

	return

    71

		_m[t].m5 == HANGAR_TILE_0 ||

    72

		_m[t].m5 == HANGAR_TILE_1 ||

    73

		_m[t].m5 == HANGAR_TILE_2;

    74

}

    75

    76

static inline bool IsAirport(TileIndex t)

    77

{

    78

	return

    79

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

    80

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

    81

}

    82

    83

static inline bool IsTruckStop(TileIndex t)

    84

{

    85

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

    86

}

    87

    88

static inline bool IsBusStop(TileIndex t)

    89

{

    90

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

    91

}

    92

    93

static inline bool IsRoadStop(TileIndex t)

    94

{

    95

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

    96

}

    97

    98

static inline bool IsOilRig(TileIndex t)

    99

{

   100

	return _m[t].m5 == OILRIG_BASE;

   101

}

   102

   103

static inline bool IsDock(TileIndex t)

   104

{

   105

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

   106

}

   107

   108

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

   109

{

   110

	return _m[t].m5 == BUOY_BASE;

   111

}

   112

   113

   114

static inline bool IsHangarTile(TileIndex t)

   115

{

   116

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

   117

}

   118

   119

   120

static inline Axis GetRailStationAxis(TileIndex t)

   121

{

   122

	assert(IsRailwayStation(t));

   123

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

   124

}

   125

   126

   127

static inline Track GetRailStationTrack(TileIndex t)

   128

{

   129

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

   130

}

   131

   132

   133

static inline DiagDirection GetDockDirection(TileIndex t)

   134

{

   135

	assert(IsTileType(t, MP_STATION));

   136

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

   137

   138

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

   139

}

   140

   141

   142

static inline bool IsCustomStationSprite(TileIndex t)

   143

{

   144

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

   145

}

   146

   147

static inline void SetCustomStationSprite(TileIndex t, byte sprite)

   148

{

   149

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

   150

	_m[t].m4 = sprite;

   151

}

   152

   153

static inline uint GetCustomStationSprite(TileIndex t)

   154

{

   155

	return _m[t].m4;

   156

}

   157

   158

   159

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

   160

{

   161

	SetTileType(t, MP_STATION);

   162

	SetTileOwner(t, o);

   163

	_m[t].m2 = sid;

   164

	_m[t].m3 = 0;

   165

	_m[t].m4 = 0;

   166

	_m[t].m5 = m5;

   167

}

   168

   169

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

   170

{

   171

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

   172

	SetRailType(t, rt);

   173

}

   174

   175

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

   176

{

   177

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

   178

}

   179

   180

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

   181

{

   182

	MakeStation(t, o, sid, section);

   183

}

   184

   185

static inline void MakeBuoy(TileIndex t, StationID sid)

   186

{

   187

	MakeStation(t, OWNER_NONE, sid, BUOY_BASE);

   188

}

   189

   190

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

   191

{

   192

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

   193

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

   194

}

   195

   196

static inline void MakeOilrig(TileIndex t, StationID sid)

   197

{

   198

	MakeStation(t, OWNER_NONE, sid, OILRIG_BASE);

   199

}

   200

   201

#endif