1

/* $Id$ */

     2

     3

#ifndef STATION_MAP_H

     4

#define STATION_MAP_H

     5

     6

#include "station.h"

     7

     8

typedef byte StationGfx;

     9

    10

static inline StationID GetStationIndex(TileIndex t)

    11

{

    12

	assert(IsTileType(t, MP_STATION));

    13

	return (StationID)_m[t].m2;

    14

}

    15

    16

static inline Station* GetStationByTile(TileIndex t)

    17

{

    18

	return GetStation(GetStationIndex(t));

    19

}

    20

    21

    22

enum {

    23

	GFX_RAILWAY_BASE              =   0,

    24

	GFX_AIRPORT_BASE              =   8,

    25

	GFX_RADAR_LARGE_FIRST         =  39,

    26

	GFX_RADAR_LARGE_LAST          =  50,

    27

	GFX_WINDSACK_FIRST            =  58,

    28

	GFX_WINDSACK_LAST             =  61,

    29

	GFX_TRUCK_BASE                =  67,

    30

	GFX_BUS_BASE                  =  71,

    31

	GFX_OILRIG_BASE               =  75,

    32

	GFX_DOCK_BASE                 =  76,

    33

	GFX_DOCK_BASE_WATER_PART      =  80,

    34

	GFX_BUOY_BASE                 =  82,

    35

	GFX_AIRPORT_BASE_EXTENDED     =  83,

    36

	GFX_RADAR_INTERNATIONAL_FIRST =  90,

    37

	GFX_RADAR_INTERNATIONAL_LAST  = 101,

    38

	GFX_RADAR_METROPOLITAN_FIRST  = 102,

    39

	GFX_RADAR_METROPOLITAN_LAST   = 113,

    40

	GFX_BASE_END                  = 155

    41

};

    42

    43

enum {

    44

	RAILWAY_SIZE = GFX_AIRPORT_BASE - GFX_RAILWAY_BASE,

    45

	AIRPORT_SIZE = GFX_TRUCK_BASE - GFX_AIRPORT_BASE,

    46

	TRUCK_SIZE = GFX_BUS_BASE - GFX_TRUCK_BASE,

    47

	BUS_SIZE = GFX_OILRIG_BASE - GFX_BUS_BASE,

    48

	DOCK_SIZE_TOTAL = GFX_BUOY_BASE - GFX_DOCK_BASE,

    49

	AIRPORT_SIZE_EXTENDED = GFX_BASE_END - GFX_AIRPORT_BASE_EXTENDED

    50

};

    51

    52

typedef enum HangarTiles {

    53

	HANGAR_TILE_0 = 32,

    54

	HANGAR_TILE_1 = 65,

    55

	HANGAR_TILE_2 = 86

    56

} HangarTiles;

    57

    58

typedef enum StationType {

    59

	STATION_RAIL,

    60

	STATION_HANGAR,

    61

	STATION_AIRPORT,

    62

	STATION_TRUCK,

    63

	STATION_BUS,

    64

	STATION_OILRIG,

    65

	STATION_DOCK,

    66

	STATION_BUOY

    67

} StationType;

    68

    69

StationType GetStationType(TileIndex);

    70

    71

static inline RoadStopType GetRoadStopType(TileIndex t)

    72

{

    73

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

    74

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

    75

}

    76

    77

static inline StationGfx GetStationGfx(TileIndex t)

    78

{

    79

	assert(IsTileType(t, MP_STATION));

    80

	return _m[t].m5;

    81

}

    82

    83

static inline void SetStationGfx(TileIndex t, StationGfx gfx)

    84

{

    85

	assert(IsTileType(t, MP_STATION));

    86

	_m[t].m5 = gfx;

    87

}

    88

    89

static inline bool IsRailwayStation(TileIndex t)

    90

{

    91

	return GetStationGfx(t) < GFX_RAILWAY_BASE + RAILWAY_SIZE;

    92

}

    93

    94

static inline bool IsRailwayStationTile(TileIndex t)

    95

{

    96

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

    97

}

    98

    99

static inline bool IsHangar(TileIndex t)

   100

{

   101

	StationGfx gfx = GetStationGfx(t);

   102

	return

   103

		gfx == HANGAR_TILE_0 ||

   104

		gfx == HANGAR_TILE_1 ||

   105

		gfx == HANGAR_TILE_2;

   106

}

   107

   108

static inline bool IsAirport(TileIndex t)

   109

{

   110

	StationGfx gfx = GetStationGfx(t);

   111

	return

   112

		(IS_BYTE_INSIDE(gfx, GFX_AIRPORT_BASE, GFX_AIRPORT_BASE + AIRPORT_SIZE)) ||

   113

		(IS_BYTE_INSIDE(gfx, GFX_AIRPORT_BASE_EXTENDED, GFX_AIRPORT_BASE_EXTENDED + AIRPORT_SIZE_EXTENDED));

   114

}

   115

   116

static inline bool IsTruckStop(TileIndex t)

   117

{

   118

	return IS_BYTE_INSIDE(GetStationGfx(t), GFX_TRUCK_BASE, GFX_TRUCK_BASE + TRUCK_SIZE);

   119

}

   120

   121

static inline bool IsBusStop(TileIndex t)

   122

{

   123

	return IS_BYTE_INSIDE(GetStationGfx(t), GFX_BUS_BASE, GFX_BUS_BASE + BUS_SIZE);

   124

}

   125

   126

static inline bool IsRoadStop(TileIndex t)

   127

{

   128

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

   129

}

   130

   131

static inline bool IsRoadStopTile(TileIndex t)

   132

{

   133

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

   134

}

   135

   136

/**

   137

 * Gets the direction the road stop entrance points towards.

   138

 */

   139

static inline DiagDirection GetRoadStopDir(TileIndex t)

   140

{

   141

	assert(IsRoadStopTile(t));

   142

	return (GetStationGfx(t) - GFX_TRUCK_BASE) & 3;

   143

}

   144

   145

static inline bool IsOilRig(TileIndex t)

   146

{

   147

	return GetStationGfx(t) == GFX_OILRIG_BASE;

   148

}

   149

   150

static inline bool IsDock(TileIndex t)

   151

{

   152

	return IS_BYTE_INSIDE(GetStationGfx(t), GFX_DOCK_BASE, GFX_DOCK_BASE + DOCK_SIZE_TOTAL);

   153

}

   154

   155

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

   156

{

   157

	return GetStationGfx(t) == GFX_BUOY_BASE;

   158

}

   159

   160

static inline bool IsBuoyTile(TileIndex t)

   161

{

   162

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

   163

}

   164

   165

   166

static inline bool IsHangarTile(TileIndex t)

   167

{

   168

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

   169

}

   170

   171

   172

static inline Axis GetRailStationAxis(TileIndex t)

   173

{

   174

	assert(IsRailwayStation(t));

   175

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

   176

}

   177

   178

   179

static inline Track GetRailStationTrack(TileIndex t)

   180

{

   181

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

   182

}

   183

   184

static inline bool IsCompatibleTrainStationTile(TileIndex t1, TileIndex t2)

   185

{

   186

	assert(IsRailwayStationTile(t2));

   187

	return

   188

		IsRailwayStationTile(t1) &&

   189

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

   190

		GetRailStationAxis(t1) == GetRailStationAxis(t2);

   191

}

   192

   193

   194

static inline DiagDirection GetDockDirection(TileIndex t)

   195

{

   196

	StationGfx gfx = GetStationGfx(t);

   197

	assert(gfx < GFX_DOCK_BASE_WATER_PART);

   198

	return (DiagDirection)(gfx - GFX_DOCK_BASE);

   199

}

   200

   201

static inline TileIndexDiffC GetDockOffset(TileIndex t)

   202

{

   203

	static const TileIndexDiffC buoy_offset = {0, 0};

   204

	static const TileIndexDiffC oilrig_offset = {2, 0};

   205

	static const TileIndexDiffC dock_offset[DIAGDIR_END] = {

   206

		{-2,  0},

   207

		{ 0,  2},

   208

		{ 2,  0},

   209

		{ 0, -2},

   210

	};

   211

	assert(IsTileType(t, MP_STATION));

   212

   213

	if (IsBuoy_(t)) return buoy_offset;

   214

	if (IsOilRig(t)) return oilrig_offset;

   215

   216

	assert(IsDock(t));

   217

   218

	return dock_offset[GetDockDirection(t)];

   219

}

   220

   221

static inline bool IsCustomStationSprite(TileIndex t)

   222

{

   223

	assert(IsTileType(t, MP_STATION));

   224

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

   225

}

   226

   227

static inline void SetCustomStationSprite(TileIndex t, byte sprite)

   228

{

   229

	assert(IsTileType(t, MP_STATION));

   230

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

   231

	_m[t].m4 = sprite;

   232

}

   233

   234

static inline uint GetCustomStationSprite(TileIndex t)

   235

{

   236

	assert(IsTileType(t, MP_STATION));

   237

	return _m[t].m4;

   238

}

   239

   240

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

   241

{

   242

	SetTileType(t, MP_STATION);

   243

	SetTileOwner(t, o);

   244

	_m[t].m2 = sid;

   245

	_m[t].m3 = 0;

   246

	_m[t].m4 = 0;

   247

	_m[t].m5 = m5;

   248

}

   249

   250

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

   251

{

   252

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

   253

	SetRailType(t, rt);

   254

}

   255

   256

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

   257

{

   258

	MakeStation(t, o, sid, (rst == RS_BUS ? GFX_BUS_BASE : GFX_TRUCK_BASE) + d);

   259

}

   260

   261

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

   262

{

   263

	MakeStation(t, o, sid, section);

   264

}

   265

   266

static inline void MakeBuoy(TileIndex t, StationID sid)

   267

{

   268

	MakeStation(t, OWNER_NONE, sid, GFX_BUOY_BASE);

   269

}

   270

   271

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

   272

{

   273

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

   274

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

   275

}

   276

   277

static inline void MakeOilrig(TileIndex t, StationID sid)

   278

{

   279

	MakeStation(t, OWNER_NONE, sid, GFX_OILRIG_BASE);

   280

}

   281

   282

#endif