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 "water_map.h"

    11

#include "station_func.h"

    12

#include "station_base.h"

    13

#include "rail.h"

    14

    15

typedef byte StationGfx;

    16

    17

static inline StationID GetStationIndex(TileIndex t)

    18

{

    19

	assert(IsTileType(t, MP_STATION));

    20

	return (StationID)_m[t].m2;

    21

}

    22

    23

static inline Station *GetStationByTile(TileIndex t)

    24

{

    25

	return GetStation(GetStationIndex(t));

    26

}

    27

    28

    29

enum {

    30

	GFX_RADAR_LARGE_FIRST             =  31,

    31

	GFX_RADAR_LARGE_LAST              =  42,

    32

	GFX_WINDSACK_FIRST                =  50,

    33

	GFX_WINDSACK_LAST                 =  53,

    34

    35

	GFX_DOCK_BASE_WATER_PART          =  4,

    36

	GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET =  4,

    37

    38

	GFX_RADAR_INTERNATIONAL_FIRST     =  66,

    39

	GFX_RADAR_INTERNATIONAL_LAST      =  77,

    40

	GFX_RADAR_METROPOLITAN_FIRST      =  78,

    41

	GFX_RADAR_METROPOLITAN_LAST       =  89,

    42

	GFX_RADAR_DISTRICTWE_FIRST        = 121,

    43

	GFX_RADAR_DISTRICTWE_LAST         = 132,

    44

	GFX_WINDSACK_INTERCON_FIRST       = 140,

    45

	GFX_WINDSACK_INTERCON_LAST        = 143,

    46

};

    47

    48

static inline StationType GetStationType(TileIndex t)

    49

{

    50

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

    51

}

    52

    53

static inline RoadStopType GetRoadStopType(TileIndex t)

    54

{

    55

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

    56

	return GetStationType(t) == STATION_TRUCK ? ROADSTOP_TRUCK : ROADSTOP_BUS;

    57

}

    58

    59

static inline StationGfx GetStationGfx(TileIndex t)

    60

{

    61

	assert(IsTileType(t, MP_STATION));

    62

	return _m[t].m5;

    63

}

    64

    65

static inline void SetStationGfx(TileIndex t, StationGfx gfx)

    66

{

    67

	assert(IsTileType(t, MP_STATION));

    68

	_m[t].m5 = gfx;

    69

}

    70

    83

static inline bool IsRailwayStation(TileIndex t)

    84

{

    85

	return GetStationType(t) == STATION_RAIL;

    86

}

    87

    88

static inline bool IsRailwayStationTile(TileIndex t)

    89

{

    90

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

    91

}

    92

    93

static inline bool IsAirport(TileIndex t)

    94

{

    95

	return GetStationType(t) == STATION_AIRPORT;

    96

}

    97

    98

bool IsHangar(TileIndex t);

    99

   100

static inline bool IsTruckStop(TileIndex t)

   101

{

   102

	return GetStationType(t) == STATION_TRUCK;

   103

}

   104

   105

static inline bool IsBusStop(TileIndex t)

   106

{

   107

	return GetStationType(t) == STATION_BUS;

   108

}

   109

   110

static inline bool IsRoadStop(TileIndex t)

   111

{

   112

	assert(IsTileType(t, MP_STATION));

   113

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

   114

}

   115

   116

static inline bool IsRoadStopTile(TileIndex t)

   117

{

   118

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

   119

}

   120

   121

static inline bool IsStandardRoadStopTile(TileIndex t)

   122

{

   123

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

   124

}

   125

   126

static inline bool IsDriveThroughStopTile(TileIndex t)

   127

{

   128

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

   129

}

   130

   131

static inline bool GetStopBuiltOnTownRoad(TileIndex t)

   132

{

   133

	assert(IsDriveThroughStopTile(t));

   134

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

   135

}

   136

   137

   138

/**

   139

 * Gets the direction the road stop entrance points towards.

   140

 */

   141

static inline DiagDirection GetRoadStopDir(TileIndex t)

   142

{

   143

	StationGfx gfx = GetStationGfx(t);

   144

	assert(IsRoadStopTile(t));

   145

	if (gfx < GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET) {

   146

		return (DiagDirection)(gfx);

   147

	} else {

   148

		return (DiagDirection)(gfx - GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET);

   149

	}

   150

}

   151

   152

static inline bool IsOilRig(TileIndex t)

   153

{

   154

	return GetStationType(t) == STATION_OILRIG;

   155

}

   156

   157

static inline bool IsDock(TileIndex t)

   158

{

   159

	return GetStationType(t) == STATION_DOCK;

   160

}

   161

   162

static inline bool IsBuoy(TileIndex t)

   163

{

   164

	return GetStationType(t) == STATION_BUOY;

   165

}

   166

   167

static inline bool IsBuoyTile(TileIndex t)

   168

{

   169

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

   170

}

   171

   172

static inline bool IsHangarTile(TileIndex t)

   173

{

   174

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

   175

}

   176

   177

   178

static inline Axis GetRailStationAxis(TileIndex t)

   179

{

   180

	assert(IsRailwayStation(t));

   181

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

   182

}

   183

   184

   185

static inline Track GetRailStationTrack(TileIndex t)

   186

{

   187

	return AxisToTrack(GetRailStationAxis(t));

   188

}

   189

   190

static inline bool IsCompatibleTrainStationTile(TileIndex t1, TileIndex t2)

   191

{

   192

	assert(IsRailwayStationTile(t2));

   193

	return

   194

		IsRailwayStationTile(t1) &&

   195

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

   196

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

   197

		GetStationIndex(t1) == GetStationIndex(t2) &&

   198

		!IsStationTileBlocked(t1);

   199

}

   200

   201

   202

static inline DiagDirection GetDockDirection(TileIndex t)

   203

{

   204

	StationGfx gfx = GetStationGfx(t);

   205

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

   206

	return (DiagDirection)(gfx);

   207

}

   208

   209

static inline TileIndexDiffC GetDockOffset(TileIndex t)

   210

{

   211

	static const TileIndexDiffC buoy_offset = {0, 0};

   212

	static const TileIndexDiffC oilrig_offset = {2, 0};

   213

	static const TileIndexDiffC dock_offset[DIAGDIR_END] = {

   214

		{-2,  0},

   215

		{ 0,  2},

   216

		{ 2,  0},

   217

		{ 0, -2},

   218

	};

   219

	assert(IsTileType(t, MP_STATION));

   220

   221

	if (IsBuoy(t)) return buoy_offset;

   222

	if (IsOilRig(t)) return oilrig_offset;

   223

   224

	assert(IsDock(t));

   225

   226

	return dock_offset[GetDockDirection(t)];

   227

}

   228

   229

static inline bool IsCustomStationSpecIndex(TileIndex t)

   230

{

   231

	assert(IsTileType(t, MP_STATION));

   232

	return _m[t].m4 != 0;

   233

}

   234

   235

static inline void SetCustomStationSpecIndex(TileIndex t, byte specindex)

   236

{

   237

	assert(IsTileType(t, MP_STATION));

   238

	_m[t].m4 = specindex;

   239

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

   240

}

   241

   242

static inline uint GetCustomStationSpecIndex(TileIndex t)

   243

{

   244

	assert(IsTileType(t, MP_STATION));

   245

	return _m[t].m4;

   246

}

   247

   248

static inline void SetStationTileRandomBits(TileIndex t, byte random_bits)

   249

{

   250

	assert(IsTileType(t, MP_STATION));

   251

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

   252

}

   253

   254

static inline byte GetStationTileRandomBits(TileIndex t)

   255

{

   256

	assert(IsTileType(t, MP_STATION));

   257

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

   258

}

   259

   260

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

   261

{

   262

	SetTileType(t, MP_STATION);

   263

	SetTileOwner(t, o);

   264

	_m[t].m2 = sid;

   265

	_m[t].m3 = 0;

   266

	_m[t].m4 = 0;

   267

	_m[t].m5 = section;

   268

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

   269

}

   270

   271

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

   272

{

   273

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

   274

	SetRailType(t, rt);

   275

}

   276

   277

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

   278

{

   279

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

   280

	SetRoadTypes(t, rt);

   281

}

   282

   283

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

   284

{

   285

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

   286

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

   287

	SetRoadTypes(t, rt);

   288

}

   289

   290

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

   291

{

   292

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

   293

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

   294

}

   295

   296

static inline void MakeBuoy(TileIndex t, StationID sid, WaterClass wc)

   297

{

   298

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

   299

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

   300

	 * original state when the buoy gets removed. */

   301

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

   302

	SetWaterClass(t, wc);

   303

}

   304

   305

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

   306

{

   307

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

   308

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

   309

	SetWaterClass(t + TileOffsByDiagDir(d), wc);

   310

}

   311

   312

static inline void MakeOilrig(TileIndex t, StationID sid)

   313

{

   314

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

   315

}

   316

   317

#endif /* STATION_MAP_H */