1

/* $Id$ */

     2

     3

/** @file station_map.h */

     4

     5

#ifndef STATION_MAP_H

     6

#define STATION_MAP_H

     7

     8

#include "rail_map.h"

     9

#include "road_map.h"

    10

#include "station.h"

    11

    12

typedef byte StationGfx;

    13

    14

static inline StationID GetStationIndex(TileIndex t)

    15

{

    16

	assert(IsTileType(t, MP_STATION));

    17

	return (StationID)_m[t].m2;

    18

}

    19

    20

static inline Station *GetStationByTile(TileIndex t)

    21

{

    22

	return GetStation(GetStationIndex(t));

    23

}

    24

    25

    26

enum {

    27

	GFX_RADAR_LARGE_FIRST             =  31,

    28

	GFX_RADAR_LARGE_LAST              =  42,

    29

	GFX_WINDSACK_FIRST                =  50,

    30

	GFX_WINDSACK_LAST                 =  53,

    31

    32

	GFX_DOCK_BASE_WATER_PART          =  4,

    33

	GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET =  4,

    34

    35

	GFX_RADAR_INTERNATIONAL_FIRST     =  66,

    36

	GFX_RADAR_INTERNATIONAL_LAST      =  77,

    37

	GFX_RADAR_METROPOLITAN_FIRST      =  78,

    38

	GFX_RADAR_METROPOLITAN_LAST       =  89,

    39

	GFX_RADAR_DISTRICTWE_FIRST        = 121,

    40

	GFX_RADAR_DISTRICTWE_LAST         = 132,

    41

	GFX_WINDSACK_INTERCON_FIRST       = 140,

    42

	GFX_WINDSACK_INTERCON_LAST        = 143,

    43

};

    44

    45

static inline StationType GetStationType(TileIndex t)

    46

{

    47

	return (StationType)GB(_m[t].m6, 3, 3);

    48

}

    49

    50

static inline RoadStop::Type GetRoadStopType(TileIndex t)

    51

{

    52

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

    53

	return GetStationType(t) == STATION_TRUCK ? RoadStop::TRUCK : RoadStop::BUS;

    54

}

    55

    56

static inline StationGfx GetStationGfx(TileIndex t)

    57

{

    58

	assert(IsTileType(t, MP_STATION));

    59

	return _m[t].m5;

    60

}

    61

    62

static inline void SetStationGfx(TileIndex t, StationGfx gfx)

    63

{

    64

	assert(IsTileType(t, MP_STATION));

    65

	_m[t].m5 = gfx;

    66

}

    67

    68

static inline bool IsRailwayStation(TileIndex t)

    69

{

    70

	return GetStationType(t) == STATION_RAIL;

    71

}

    72

    73

static inline bool IsRailwayStationTile(TileIndex t)

    74

{

    75

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

    76

}

    77

    78

static inline bool IsAirport(TileIndex t)

    79

{

    80

	return GetStationType(t) == STATION_AIRPORT;

    81

}

    82

    84

    85

static inline bool IsTruckStop(TileIndex t)

    86

{

    87

	return GetStationType(t) == STATION_TRUCK;

    88

}

    89

    90

static inline bool IsBusStop(TileIndex t)

    91

{

    92

	return GetStationType(t) == STATION_BUS;

    93

}

    94

    95

static inline bool IsRoadStop(TileIndex t)

    96

{

    97

	assert(IsTileType(t, MP_STATION));

    98

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

    99

}

   100

   101

static inline bool IsRoadStopTile(TileIndex t)

   102

{

   103

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

   104

}

   105

   106

static inline bool IsStandardRoadStopTile(TileIndex t)

   107

{

   108

	return IsRoadStopTile(t) && GetStationGfx(t) < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET;

   109

}

   110

   111

static inline bool IsDriveThroughStopTile(TileIndex t)

   112

{

   113

	return IsRoadStopTile(t) && GetStationGfx(t) >= GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET;

   114

}

   115

   116

static inline bool GetStopBuiltOnTownRoad(TileIndex t)

   117

{

   118

	assert(IsDriveThroughStopTile(t));

   119

	return HASBIT(_m[t].m6, 2);

   120

}

   121

   122

   123

/**

   124

 * Gets the direction the road stop entrance points towards.

   125

 */

   126

static inline DiagDirection GetRoadStopDir(TileIndex t)

   127

{

   128

	StationGfx gfx = GetStationGfx(t);

   129

	assert(IsRoadStopTile(t));

   130

	if (gfx < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET) {

   131

		return (DiagDirection)(gfx);

   132

	} else {

   133

		return (DiagDirection)(gfx - GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);

   134

	}

   135

}

   136

   137

static inline bool IsOilRig(TileIndex t)

   138

{

   139

	return GetStationType(t) == STATION_OILRIG;

   140

}

   141

   142

static inline bool IsDock(TileIndex t)

   143

{

   144

	return GetStationType(t) == STATION_DOCK;

   145

}

   146

   147

static inline bool IsBuoy(TileIndex t)

   148

{

   149

	return GetStationType(t) == STATION_BUOY;

   150

}

   151

   152

static inline bool IsBuoyTile(TileIndex t)

   153

{

   154

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

   155

}

   156

   157

   158

static inline bool IsHangarTile(TileIndex t)

   159

{

   160

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

   161

}

   162

   163

   164

static inline Axis GetRailStationAxis(TileIndex t)

   165

{

   166

	assert(IsRailwayStation(t));

   167

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

   168

}

   169

   170

   171

static inline Track GetRailStationTrack(TileIndex t)

   172

{

   173

	return AxisToTrack(GetRailStationAxis(t));

   174

}

   175

   176

static inline bool IsCompatibleTrainStationTile(TileIndex t1, TileIndex t2)

   177

{

   178

	assert(IsRailwayStationTile(t2));

   179

	return

   180

		IsRailwayStationTile(t1) &&

   181

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

   182

		GetRailStationAxis(t1) == GetRailStationAxis(t2) &&

   183

		!IsStationTileBlocked(t1);

   184

}

   185

   186

   187

static inline DiagDirection GetDockDirection(TileIndex t)

   188

{

   189

	StationGfx gfx = GetStationGfx(t);

   190

	assert(IsDock(t) && gfx < GFX_DOCK_BASE_WATER_PART);

   191

	return (DiagDirection)(gfx);

   192

}

   193

   194

static inline TileIndexDiffC GetDockOffset(TileIndex t)

   195

{

   196

	static const TileIndexDiffC buoy_offset = {0, 0};

   197

	static const TileIndexDiffC oilrig_offset = {2, 0};

   198

	static const TileIndexDiffC dock_offset[DIAGDIR_END] = {

   199

		{-2,  0},

   200

		{ 0,  2},

   201

		{ 2,  0},

   202

		{ 0, -2},

   203

	};

   204

	assert(IsTileType(t, MP_STATION));

   205

   206

	if (IsBuoy(t)) return buoy_offset;

   207

	if (IsOilRig(t)) return oilrig_offset;

   208

   209

	assert(IsDock(t));

   210

   211

	return dock_offset[GetDockDirection(t)];

   212

}

   213

   214

static inline bool IsCustomStationSpecIndex(TileIndex t)

   215

{

   216

	assert(IsTileType(t, MP_STATION));

   217

	return _m[t].m4 != 0;

   218

}

   219

   220

static inline void SetCustomStationSpecIndex(TileIndex t, byte specindex)

   221

{

   222

	assert(IsTileType(t, MP_STATION));

   223

	_m[t].m4 = specindex;

   224

}

   225

   226

static inline uint GetCustomStationSpecIndex(TileIndex t)

   227

{

   228

	assert(IsTileType(t, MP_STATION));

   229

	return _m[t].m4;

   230

}

   231

   232

static inline void SetStationTileRandomBits(TileIndex t, byte random_bits)

   233

{

   234

	assert(IsTileType(t, MP_STATION));

   235

	SB(_m[t].m3, 4, 4, random_bits);

   236

}

   237

   238

static inline byte GetStationTileRandomBits(TileIndex t)

   239

{

   240

	assert(IsTileType(t, MP_STATION));

   241

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

   242

}

   243

   244

static inline void MakeStation(TileIndex t, Owner o, StationID sid, StationType st, byte section)

   245

{

   246

	SetTileType(t, MP_STATION);

   247

	SetTileOwner(t, o);

   248

	_m[t].m2 = sid;

   249

	_m[t].m3 = 0;

   250

	_m[t].m4 = 0;

   251

	_m[t].m5 = section;

   252

	SB(_m[t].m6, 3, 3, st);

   253

}

   254

   255

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

   256

{

   257

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

   258

	SetRailType(t, rt);

   259

}

   260

   261

static inline void MakeRoadStop(TileIndex t, Owner o, StationID sid, RoadStop::Type rst, RoadTypes rt, DiagDirection d)

   262

{

   263

	MakeStation(t, o, sid, (rst == RoadStop::BUS ? STATION_BUS : STATION_TRUCK), d);

   264

	SetRoadTypes(t, rt);

   265

}

   266

   267

static inline void MakeDriveThroughRoadStop(TileIndex t, Owner o, StationID sid, RoadStop::Type rst, RoadTypes rt, Axis a, bool on_town_road)

   268

{

   269

	MakeStation(t, o, sid, (rst == RoadStop::BUS ? STATION_BUS : STATION_TRUCK), GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET + a);

   270

	SB(_m[t].m6, 2, 1, on_town_road);

   271

	SetRoadTypes(t, rt);

   272

}

   273

   274

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

   275

{

   276

	MakeStation(t, o, sid, STATION_AIRPORT, section);

   277

}

   278

   279

static inline void MakeBuoy(TileIndex t, StationID sid)

   280

{

   281

	/* Make the owner of the buoy tile the same as the current owner of the

   282

	 * water tile. In this way, we can reset the owner of the water to its

   283

	 * original state when the buoy gets removed. */

   284

	MakeStation(t, GetTileOwner(t), sid, STATION_BUOY, 0);

   285

}

   286

   287

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

   288

{

   289

	MakeStation(t, o, sid, STATION_DOCK, d);

   290

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

   291

}

   292

   293

static inline void MakeOilrig(TileIndex t, StationID sid)

   294

{

   295

	MakeStation(t, OWNER_NONE, sid, STATION_OILRIG, 0);

   296

}

   297

   298

#endif /* STATION_MAP_H */