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"

    12

    13

typedef byte StationGfx;

    14

    15

static inline StationID GetStationIndex(TileIndex t)

    16

{

    17

	assert(IsTileType(t, MP_STATION));

    18

	return (StationID)_m[t].m2;

    19

}

    20

    21

static inline Station *GetStationByTile(TileIndex t)

    22

{

    23

	return GetStation(GetStationIndex(t));

    24

}

    25

    26

    27

enum {

    28

	GFX_RADAR_LARGE_FIRST             =  31,

    29

	GFX_RADAR_LARGE_LAST              =  42,

    30

	GFX_WINDSACK_FIRST                =  50,

    31

	GFX_WINDSACK_LAST                 =  53,

    32

    33

	GFX_DOCK_BASE_WATER_PART          =  4,

    34

	GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET =  4,

    35

    36

	GFX_RADAR_INTERNATIONAL_FIRST     =  66,

    37

	GFX_RADAR_INTERNATIONAL_LAST      =  77,

    38

	GFX_RADAR_METROPOLITAN_FIRST      =  78,

    39

	GFX_RADAR_METROPOLITAN_LAST       =  89,

    40

	GFX_RADAR_DISTRICTWE_FIRST        = 121,

    41

	GFX_RADAR_DISTRICTWE_LAST         = 132,

    42

	GFX_WINDSACK_INTERCON_FIRST       = 140,

    43

	GFX_WINDSACK_INTERCON_LAST        = 143,

    44

};

    45

    46

static inline StationType GetStationType(TileIndex t)

    47

{

    48

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

    49

}

    50

    51

static inline RoadStop::Type GetRoadStopType(TileIndex t)

    52

{

    53

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

    54

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

    55

}

    56

    57

static inline StationGfx GetStationGfx(TileIndex t)

    58

{

    59

	assert(IsTileType(t, MP_STATION));

    60

	return _m[t].m5;

    61

}

    62

    63

static inline void SetStationGfx(TileIndex t, StationGfx gfx)

    64

{

    65

	assert(IsTileType(t, MP_STATION));

    66

	_m[t].m5 = gfx;

    67

}

    68

    69

static inline bool IsRailwayStation(TileIndex t)

    70

{

    71

	return GetStationType(t) == STATION_RAIL;

    72

}

    73

    74

static inline bool IsRailwayStationTile(TileIndex t)

    75

{

    76

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

    77

}

    78

    79

static inline bool IsAirport(TileIndex t)

    80

{

    81

	return GetStationType(t) == STATION_AIRPORT;

    82

}

    83

    84

bool IsHangar(TileIndex t);

    85

    86

static inline bool IsTruckStop(TileIndex t)

    87

{

    88

	return GetStationType(t) == STATION_TRUCK;

    89

}

    90

    91

static inline bool IsBusStop(TileIndex t)

    92

{

    93

	return GetStationType(t) == STATION_BUS;

    94

}

    95

    96

static inline bool IsRoadStop(TileIndex t)

    97

{

    98

	assert(IsTileType(t, MP_STATION));

    99

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

   100

}

   101

   102

static inline bool IsRoadStopTile(TileIndex t)

   103

{

   104

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

   105

}

   106

   107

static inline bool IsStandardRoadStopTile(TileIndex t)

   108

{

   109

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

   110

}

   111

   112

static inline bool IsDriveThroughStopTile(TileIndex t)

   113

{

   114

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

   115

}

   116

   117

static inline bool GetStopBuiltOnTownRoad(TileIndex t)

   118

{

   119

	assert(IsDriveThroughStopTile(t));

   120

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

   121

}

   122

   123

   124

/**

   125

 * Gets the direction the road stop entrance points towards.

   126

 */

   127

static inline DiagDirection GetRoadStopDir(TileIndex t)

   128

{

   129

	StationGfx gfx = GetStationGfx(t);

   130

	assert(IsRoadStopTile(t));

   131

	if (gfx < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET) {

   132

		return (DiagDirection)(gfx);

   133

	} else {

   134

		return (DiagDirection)(gfx - GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);

   135

	}

   136

}

   137

   138

static inline bool IsOilRig(TileIndex t)

   139

{

   140

	return GetStationType(t) == STATION_OILRIG;

   141

}

   142

   143

static inline bool IsDock(TileIndex t)

   144

{

   145

	return GetStationType(t) == STATION_DOCK;

   146

}

   147

   148

static inline bool IsBuoy(TileIndex t)

   149

{

   150

	return GetStationType(t) == STATION_BUOY;

   151

}

   152

   153

static inline bool IsBuoyTile(TileIndex t)

   154

{

   155

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

   156

}

   157

   158

static inline bool IsCanalBuoyTile(TileIndex t)

   159

{

   160

	return IsBuoyTile(t) && !IsTileOwner(t, OWNER_WATER);

   161

}

   162

   163

static inline bool IsSeaBuoyTile(TileIndex t)

   164

{

   165

	return IsBuoyTile(t) && IsTileOwner(t, OWNER_WATER);

   166

}

   167

   168

static inline bool IsHangarTile(TileIndex t)

   169

{

   170

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

   171

}

   172

   173

   174

static inline Axis GetRailStationAxis(TileIndex t)

   175

{

   176

	assert(IsRailwayStation(t));

   177

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

   178

}

   179

   180

   181

static inline Track GetRailStationTrack(TileIndex t)

   182

{

   183

	return AxisToTrack(GetRailStationAxis(t));

   184

}

   185

   186

static inline bool IsCompatibleTrainStationTile(TileIndex t1, TileIndex t2)

   187

{

   188

	assert(IsRailwayStationTile(t2));

   189

	return

   190

		IsRailwayStationTile(t1) &&

   191

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

   192

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

   193

		!IsStationTileBlocked(t1);

   194

}

   195

   196

   197

static inline DiagDirection GetDockDirection(TileIndex t)

   198

{

   199

	StationGfx gfx = GetStationGfx(t);

   200

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

   201

	return (DiagDirection)(gfx);

   202

}

   203

   204

static inline TileIndexDiffC GetDockOffset(TileIndex t)

   205

{

   206

	static const TileIndexDiffC buoy_offset = {0, 0};

   207

	static const TileIndexDiffC oilrig_offset = {2, 0};

   208

	static const TileIndexDiffC dock_offset[DIAGDIR_END] = {

   209

		{-2,  0},

   210

		{ 0,  2},

   211

		{ 2,  0},

   212

		{ 0, -2},

   213

	};

   214

	assert(IsTileType(t, MP_STATION));

   215

   216

	if (IsBuoy(t)) return buoy_offset;

   217

	if (IsOilRig(t)) return oilrig_offset;

   218

   219

	assert(IsDock(t));

   220

   221

	return dock_offset[GetDockDirection(t)];

   222

}

   223

   224

static inline bool IsCustomStationSpecIndex(TileIndex t)

   225

{

   226

	assert(IsTileType(t, MP_STATION));

   227

	return _m[t].m4 != 0;

   228

}

   229

   230

static inline void SetCustomStationSpecIndex(TileIndex t, byte specindex)

   231

{

   232

	assert(IsTileType(t, MP_STATION));

   233

	_m[t].m4 = specindex;

   234

	_m[t].m6 &= 0x7F; // clear top bit of m6 to indicate it is not an fsmport

   235

}

   236

   237

static inline uint GetCustomStationSpecIndex(TileIndex t)

   238

{

   239

	assert(IsTileType(t, MP_STATION));

   240

	return _m[t].m4;

   241

}

   242

   243

static inline void SetStationTileRandomBits(TileIndex t, byte random_bits)

   244

{

   245

	assert(IsTileType(t, MP_STATION));

   246

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

   247

}

   248

   249

static inline byte GetStationTileRandomBits(TileIndex t)

   250

{

   251

	assert(IsTileType(t, MP_STATION));

   252

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

   253

}

   254

   255

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

   256

{

   257

	SetTileType(t, MP_STATION);

   258

	SetTileOwner(t, o);

   259

	_m[t].m2 = sid;

   260

	_m[t].m3 = 0;

   261

	_m[t].m4 = 0;

   262

	_m[t].m5 = section;

   263

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

   264

}

   265

   266

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

   267

{

   268

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

   269

	SetRailType(t, rt);

   270

}

   271

   272

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

   273

{

   274

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

   275

	SetRoadTypes(t, rt);

   276

}

   277

   278

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

   279

{

   280

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

   281

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

   282

	SetRoadTypes(t, rt);

   283

}

   284

   285

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

   286

{

   287

	/* 255 indicates "skip" this tile, allowing hollow gaps inside airports */

   288

	if (section != 255) MakeStation(t, o, sid, STATION_AIRPORT, section);

   289

}

   290

   291

static inline void MakeBuoy(TileIndex t, StationID sid)

   292

{

   293

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

   294

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

   295

	 * original state when the buoy gets removed. */

   296

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

   297

}

   298

   299

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

   300

{

   301

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

   302

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

   303

}

   304

   305

static inline void MakeOilrig(TileIndex t, StationID sid)

   306

{

   307

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

   308

}

   309

   310

#endif /* STATION_MAP_H */