1

/* $Id$ */

     2

     3

/** @file train.h Base for the train class. */

     4

     5

#ifndef TRAIN_H

     6

#define TRAIN_H

     7

     8

#include "stdafx.h"

     9

#include "core/bitmath_func.hpp"

    10

#include "vehicle_base.h"

    11

    12

    13

/** enum to handle train subtypes

    14

 * Do not access it directly unless you have to. Use the access functions below

    15

 * This is an enum to tell what bit to access as it is a bitmask

    16

 */

    17

enum TrainSubtype {

    18

	TS_FRONT             = 0, ///< Leading engine of a train

    19

	TS_ARTICULATED_PART  = 1, ///< Articulated part of an engine

    20

	TS_WAGON             = 2, ///< Wagon

    21

	TS_ENGINE            = 3, ///< Engine, that can be front engines, but might be placed behind another engine

    22

	TS_FREE_WAGON        = 4, ///< First in a wagon chain (in depot)

    23

	TS_MULTIHEADED       = 5, ///< Engine is a multiheaded

    24

};

    25

    26

    27

/** Check if a vehicle is front engine

    28

 * @param v vehicle to check

    29

 * @return Returns true if vehicle is a front engine

    30

 */

    31

static inline bool IsFrontEngine(const Vehicle *v)

    32

{

    33

	assert(v->type == VEH_TRAIN);

    34

	return HasBit(v->subtype, TS_FRONT);

    35

}

    36

    37

/** Set front engine state

    38

 * @param v vehicle to change

    39

 */

    40

static inline void SetFrontEngine(Vehicle *v)

    41

{

    42

	assert(v->type == VEH_TRAIN);

    43

	SetBit(v->subtype, TS_FRONT);

    44

}

    45

    46

/** Remove the front engine state

    47

 * @param v vehicle to change

    48

 */

    49

static inline void ClearFrontEngine(Vehicle *v)

    50

{

    51

	assert(v->type == VEH_TRAIN);

    52

	ClrBit(v->subtype, TS_FRONT);

    53

}

    54

    55

/** Check if a vehicle is an articulated part of an engine

    56

 * @param v vehicle to check

    57

 * @return Returns true if vehicle is an articulated part

    58

 */

    59

static inline bool IsArticulatedPart(const Vehicle *v)

    60

{

    61

	assert(v->type == VEH_TRAIN);

    62

	return HasBit(v->subtype, TS_ARTICULATED_PART);

    63

}

    64

    65

/** Set a vehicle to be an articulated part

    66

 * @param v vehicle to change

    67

 */

    68

static inline void SetArticulatedPart(Vehicle *v)

    69

{

    70

	assert(v->type == VEH_TRAIN);

    71

	SetBit(v->subtype, TS_ARTICULATED_PART);

    72

}

    73

    74

/** Clear a vehicle from being an articulated part

    75

 * @param v vehicle to change

    76

 */

    77

static inline void ClearArticulatedPart(Vehicle *v)

    78

{

    79

	assert(v->type == VEH_TRAIN);

    80

	ClrBit(v->subtype, TS_ARTICULATED_PART);

    81

}

    82

    83

/** Check if a vehicle is a wagon

    84

 * @param v vehicle to check

    85

 * @return Returns true if vehicle is a wagon

    86

 */

    87

static inline bool IsTrainWagon(const Vehicle *v)

    88

{

    89

	assert(v->type == VEH_TRAIN);

    90

	return HasBit(v->subtype, TS_WAGON);

    91

}

    92

    93

/** Set a vehicle to be a wagon

    94

 * @param v vehicle to change

    95

 */

    96

static inline void SetTrainWagon(Vehicle *v)

    97

{

    98

	assert(v->type == VEH_TRAIN);

    99

	SetBit(v->subtype, TS_WAGON);

   100

}

   101

   102

/** Clear wagon property

   103

 * @param v vehicle to change

   104

 */

   105

static inline void ClearTrainWagon(Vehicle *v)

   106

{

   107

	assert(v->type == VEH_TRAIN);

   108

	ClrBit(v->subtype, TS_WAGON);

   109

}

   110

   111

/** Check if a vehicle is an engine (can be first in a train)

   112

 * @param v vehicle to check

   113

 * @return Returns true if vehicle is an engine

   114

 */

   115

static inline bool IsTrainEngine(const Vehicle *v)

   116

{

   117

	assert(v->type == VEH_TRAIN);

   118

	return HasBit(v->subtype, TS_ENGINE);

   119

}

   120

   121

/** Set engine status

   122

 * @param v vehicle to change

   123

 */

   124

static inline void SetTrainEngine(Vehicle *v)

   125

{

   126

	assert(v->type == VEH_TRAIN);

   127

	SetBit(v->subtype, TS_ENGINE);

   128

}

   129

   130

/** Clear engine status

   131

 * @param v vehicle to change

   132

 */

   133

static inline void ClearTrainEngine(Vehicle *v)

   134

{

   135

	assert(v->type == VEH_TRAIN);

   136

	ClrBit(v->subtype, TS_ENGINE);

   137

}

   138

   139

/** Check if a vehicle is a free wagon (got no engine in front of it)

   140

 * @param v vehicle to check

   141

 * @return Returns true if vehicle is a free wagon

   142

 */

   143

static inline bool IsFreeWagon(const Vehicle *v)

   144

{

   145

	assert(v->type == VEH_TRAIN);

   146

	return HasBit(v->subtype, TS_FREE_WAGON);

   147

}

   148

   149

/** Set if a vehicle is a free wagon

   150

 * @param v vehicle to change

   151

 */

   152

static inline void SetFreeWagon(Vehicle *v)

   153

{

   154

	assert(v->type == VEH_TRAIN);

   155

	SetBit(v->subtype, TS_FREE_WAGON);

   156

}

   157

   158

/** Clear a vehicle from being a free wagon

   159

 * @param v vehicle to change

   160

 */

   161

static inline void ClearFreeWagon(Vehicle *v)

   162

{

   163

	assert(v->type == VEH_TRAIN);

   164

	ClrBit(v->subtype, TS_FREE_WAGON);

   165

}

   166

   167

/** Check if a vehicle is a multiheaded engine

   168

 * @param v vehicle to check

   169

 * @return Returns true if vehicle is a multiheaded engine

   170

 */

   171

static inline bool IsMultiheaded(const Vehicle *v)

   172

{

   173

	assert(v->type == VEH_TRAIN);

   174

	return HasBit(v->subtype, TS_MULTIHEADED);

   175

}

   176

   177

/** Set if a vehicle is a multiheaded engine

   178

 * @param v vehicle to change

   179

 */

   180

static inline void SetMultiheaded(Vehicle *v)

   181

{

   182

	assert(v->type == VEH_TRAIN);

   183

	SetBit(v->subtype, TS_MULTIHEADED);

   184

}

   185

   186

/** Clear multiheaded engine property

   187

 * @param v vehicle to change

   188

 */

   189

static inline void ClearMultiheaded(Vehicle *v)

   190

{

   191

	assert(v->type == VEH_TRAIN);

   192

	ClrBit(v->subtype, TS_MULTIHEADED);

   193

}

   194

   195

/** Check if an engine has an articulated part.

   196

 * @param v Vehicle.

   197

 * @return True if the engine has an articulated part.

   198

 */

   199

static inline bool EngineHasArticPart(const Vehicle *v)

   200

{

   201

	assert(v->type == VEH_TRAIN);

   202

	return (v->Next() != NULL && IsArticulatedPart(v->Next()));

   203

}

   204

   205

/**

   206

 * Get the next part of a multi-part engine.

   207

 * Will only work on a multi-part engine (EngineHasArticPart(v) == true),

   208

 * Result is undefined for normal engine.

   209

 */

   210

static inline Vehicle *GetNextArticPart(const Vehicle *v)

   211

{

   212

	assert(EngineHasArticPart(v));

   213

	return v->Next();

   214

}

   215

   216

/** Get the last part of a multi-part engine.

   217

 * @param v Vehicle.

   218

 * @return Last part of the engine.

   219

 */

   220

static inline Vehicle *GetLastEnginePart(Vehicle *v)

   221

{

   222

	assert(v->type == VEH_TRAIN);

   223

	while (EngineHasArticPart(v)) v = GetNextArticPart(v);

   224

	return v;

   225

}

   226

   227

/** Tell if we are dealing with the rear end of a multiheaded engine.

   228

 * @param v Vehicle.

   229

 * @return True if the engine is the rear part of a dualheaded engine.

   230

 */

   231

static inline bool IsRearDualheaded(const Vehicle *v)

   232

{

   233

	assert(v->type == VEH_TRAIN);

   234

	return (IsMultiheaded(v) && !IsTrainEngine(v));

   235

}

   236

   237

/** Get the next real (non-articulated part) vehicle in the consist.

   238

 * @param v Vehicle.

   239

 * @return Next vehicle in the consist.

   240

 */

   241

static inline Vehicle *GetNextVehicle(const Vehicle *v)

   242

{

   243

	assert(v->type == VEH_TRAIN);

   244

	while (EngineHasArticPart(v)) v = GetNextArticPart(v);

   245

   246

	/* v now contains the last artic part in the engine */

   247

	return v->Next();

   248

}

   249

   250

/** Get the previous real (non-articulated part) vehicle in the consist.

   251

 * @param w Vehicle.

   252

 * @return Previous vehicle in the consist.

   253

 */

   254

static inline Vehicle *GetPrevVehicle(const Vehicle *w)

   255

{

   256

	assert(w->type == VEH_TRAIN);

   257

   258

	Vehicle *v = w->Previous();

   259

	while (v != NULL && IsArticulatedPart(v)) v = v->Previous();

   260

   261

	return v;

   262

}

   263

   264

/** Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.

   265

 * @param v Vehicle.

   266

 * @return Next vehicle in the consist.

   267

 */

   268

static inline Vehicle *GetNextUnit(const Vehicle *v)

   269

{

   270

	assert(v->type == VEH_TRAIN);

   271

	Vehicle *w = GetNextVehicle(v);

   272

	if (w != NULL && IsRearDualheaded(w)) w = GetNextVehicle(w);

   273

   274

	return w;

   275

}

   276

   277

/** Get the previous real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.

   278

 * @param v Vehicle.

   279

 * @return Previous vehicle in the consist.

   280

 */

   281

static inline Vehicle *GetPrevUnit(const Vehicle *v)

   282

{

   283

	assert(v->type == VEH_TRAIN);

   284

	Vehicle *w = GetPrevVehicle(v);

   285

	if (w != NULL && IsRearDualheaded(w)) w = GetPrevVehicle(w);

   286

   287

	return w;

   288

}

   289

   290

void ConvertOldMultiheadToNew();

   291

void ConnectMultiheadedTrains();

   292

   293

void CcBuildLoco(bool success, TileIndex tile, uint32 p1, uint32 p2);

   294

void CcBuildWagon(bool success, TileIndex tile, uint32 p1, uint32 p2);

   295

   296

byte FreightWagonMult(CargoID cargo);

   297

   298

int CheckTrainInDepot(const Vehicle *v, bool needs_to_be_stopped);

   299

int CheckTrainStoppedInDepot(const Vehicle *v);

   300

void UpdateTrainAcceleration(Vehicle* v);

   301

void CheckTrainsLengths();

   302

   303

void FreeTrainTrackReservation(const Vehicle *v, TileIndex origin = INVALID_TILE, Trackdir orig_td = INVALID_TRACKDIR);

   304

bool TryPathReserve(Vehicle *v, bool mark_as_stuck = false, bool first_tile_okay = false);

   305

   306

/**

   307

 * This class 'wraps' Vehicle; you do not actually instantiate this class.

   308

 * You create a Vehicle using AllocateVehicle, so it is added to the pool

   309

 * and you reinitialize that to a Train using:

   310

 *   v = new (v) Train();

   311

 *

   312

 * As side-effect the vehicle type is set correctly.

   313

 */

   314

struct Train : public Vehicle {

   315

	/** Initializes the Vehicle to a train */

   316

	Train() { this->type = VEH_TRAIN; }

   317

   318

	/** We want to 'destruct' the right class. */

   319

	virtual ~Train() { this->PreDestructor(); }

   320

   321

	const char *GetTypeString() const { return "train"; }

   322

	void MarkDirty();

   323

	void UpdateDeltaXY(Direction direction);

   324

	ExpensesType GetExpenseType(bool income) const { return income ? EXPENSES_TRAIN_INC : EXPENSES_TRAIN_RUN; }

   325

	void PlayLeaveStationSound() const;

   326

	bool IsPrimaryVehicle() const { return IsFrontEngine(this); }

   327

	SpriteID GetImage(Direction direction) const;

   328

	int GetDisplaySpeed() const { return this->u.rail.last_speed * 10 / 16; }

   329

	int GetDisplayMaxSpeed() const { return this->u.rail.cached_max_speed * 10 / 16; }

   330

	Money GetRunningCost() const;

   331

	bool IsInDepot() const { return CheckTrainInDepot(this, false) != -1; }

   332

	bool IsStoppedInDepot() const { return CheckTrainStoppedInDepot(this) >= 0; }

   333

	void Tick();

   334

	void OnNewDay();

   335

	TileIndex GetOrderStationLocation(StationID station);

   336

	bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse);

   337

};

   338

   339

#endif /* TRAIN_H */