1

/* $Id$ */

     2

     3

/** @file train.h */

     4

     5

#ifndef TRAIN_H

     6

#define TRAIN_H

     7

     8

#include "stdafx.h"

     9

#include "vehicle.h"

    10

    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

    18

enum TrainSubtype {

    19

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

    20

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

    21

	Train_Wagon             = 2, ///< Wagon

    22

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

    23

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

    24

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

    25

};

    26

    27

    28

/** Check if a vehicle is front engine

    29

 * @param v vehicle to check

    30

 * @return Returns true if vehicle is a front engine

    31

 */

    32

static inline bool IsFrontEngine(const Vehicle *v)

    33

{

    34

	assert(v->type == VEH_TRAIN);

    35

	return HASBIT(v->subtype, Train_Front);

    36

}

    37

    38

/** Set front engine state

    39

 * @param v vehicle to change

    40

 */

    41

static inline void SetFrontEngine(Vehicle *v)

    42

{

    43

	assert(v->type == VEH_TRAIN);

    44

	SETBIT(v->subtype, Train_Front);

    45

}

    46

    47

/** Remove the front engine state

    48

 * @param v vehicle to change

    49

 */

    50

static inline void ClearFrontEngine(Vehicle *v)

    51

{

    52

	assert(v->type == VEH_TRAIN);

    53

	CLRBIT(v->subtype, Train_Front);

    54

}

    55

    56

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

    57

 * @param v vehicle to check

    58

 * @return Returns true if vehicle is an articulated part

    59

 */

    60

static inline bool IsArticulatedPart(const Vehicle *v)

    61

{

    62

	assert(v->type == VEH_TRAIN);

    63

	return HASBIT(v->subtype, Train_Articulated_Part);

    64

}

    65

    66

/** Set a vehicle to be an articulated part

    67

 * @param v vehicle to change

    68

 */

    69

static inline void SetArticulatedPart(Vehicle *v)

    70

{

    71

	assert(v->type == VEH_TRAIN);

    72

	SETBIT(v->subtype, Train_Articulated_Part);

    73

}

    74

    75

/** Clear a vehicle from being an articulated part

    76

 * @param v vehicle to change

    77

 */

    78

static inline void ClearArticulatedPart(Vehicle *v)

    79

{

    80

	assert(v->type == VEH_TRAIN);

    81

	CLRBIT(v->subtype, Train_Articulated_Part);

    82

}

    83

    84

/** Check if a vehicle is a wagon

    85

 * @param v vehicle to check

    86

 * @return Returns true if vehicle is a wagon

    87

 */

    88

static inline bool IsTrainWagon(const Vehicle *v)

    89

{

    90

	assert(v->type == VEH_TRAIN);

    91

	return HASBIT(v->subtype, Train_Wagon);

    92

}

    93

    94

/** Set a vehicle to be a wagon

    95

 * @param v vehicle to change

    96

 */

    97

static inline void SetTrainWagon(Vehicle *v)

    98

{

    99

	assert(v->type == VEH_TRAIN);

   100

	SETBIT(v->subtype, Train_Wagon);

   101

}

   102

   103

/** Clear wagon property

   104

 * @param v vehicle to change

   105

 */

   106

static inline void ClearTrainWagon(Vehicle *v)

   107

{

   108

	assert(v->type == VEH_TRAIN);

   109

	CLRBIT(v->subtype, Train_Wagon);

   110

}

   111

   112

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

   113

 * @param v vehicle to check

   114

 * @return Returns true if vehicle is an engine

   115

 */

   116

static inline bool IsTrainEngine(const Vehicle *v)

   117

{

   118

	assert(v->type == VEH_TRAIN);

   119

	return HASBIT(v->subtype, Train_Engine);

   120

}

   121

   122

/** Set engine status

   123

 * @param v vehicle to change

   124

 */

   125

static inline void SetTrainEngine(Vehicle *v)

   126

{

   127

	assert(v->type == VEH_TRAIN);

   128

	SETBIT(v->subtype, Train_Engine);

   129

}

   130

   131

/** Clear engine status

   132

 * @param v vehicle to change

   133

 */

   134

static inline void ClearTrainEngine(Vehicle *v)

   135

{

   136

	assert(v->type == VEH_TRAIN);

   137

	CLRBIT(v->subtype, Train_Engine);

   138

}

   139

   140

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

   141

 * @param v vehicle to check

   142

 * @return Returns true if vehicle is a free wagon

   143

 */

   144

static inline bool IsFreeWagon(const Vehicle *v)

   145

{

   146

	assert(v->type == VEH_TRAIN);

   147

	return HASBIT(v->subtype, Train_Free_Wagon);

   148

}

   149

   150

/** Set if a vehicle is a free wagon

   151

 * @param v vehicle to change

   152

 */

   153

static inline void SetFreeWagon(Vehicle *v)

   154

{

   155

	assert(v->type == VEH_TRAIN);

   156

	SETBIT(v->subtype, Train_Free_Wagon);

   157

}

   158

   159

/** Clear a vehicle from being a free wagon

   160

 * @param v vehicle to change

   161

 */

   162

static inline void ClearFreeWagon(Vehicle *v)

   163

{

   164

	assert(v->type == VEH_TRAIN);

   165

	CLRBIT(v->subtype, Train_Free_Wagon);

   166

}

   167

   168

/** Check if a vehicle is a multiheaded engine

   169

 * @param v vehicle to check

   170

 * @return Returns true if vehicle is a multiheaded engine

   171

 */

   172

static inline bool IsMultiheaded(const Vehicle *v)

   173

{

   174

	assert(v->type == VEH_TRAIN);

   175

	return HASBIT(v->subtype, Train_Multiheaded);

   176

}

   177

   178

/** Set if a vehicle is a multiheaded engine

   179

 * @param v vehicle to change

   180

 */

   181

static inline void SetMultiheaded(Vehicle *v)

   182

{

   183

	assert(v->type == VEH_TRAIN);

   184

	SETBIT(v->subtype, Train_Multiheaded);

   185

}

   186

   187

/** Clear multiheaded engine property

   188

 * @param v vehicle to change

   189

 */

   190

static inline void ClearMultiheaded(Vehicle *v)

   191

{

   192

	assert(v->type == VEH_TRAIN);

   193

	CLRBIT(v->subtype, Train_Multiheaded);

   194

}

   195

   196

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

   197

 * @param v Vehicle.

   198

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

   199

 */

   200

static inline bool EngineHasArticPart(const Vehicle *v)

   201

{

   202

	assert(v->type == VEH_TRAIN);

   203

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

   204

}

   205

   206

/**

   207

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

   208

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

   209

 * Result is undefined for normal engine.

   210

 */

   211

static inline Vehicle *GetNextArticPart(const Vehicle *v)

   212

{

   213

	assert(EngineHasArticPart(v));

   214

	return v->Next();

   215

}

   216

   217

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

   218

 * @param v Vehicle.

   219

 * @return Last part of the engine.

   220

 */

   221

static inline Vehicle *GetLastEnginePart(Vehicle *v)

   222

{

   223

	assert(v->type == VEH_TRAIN);

   224

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

   225

	return v;

   226

}

   227

   228

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

   229

 * @param v Vehicle.

   230

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

   231

 */

   232

static inline bool IsRearDualheaded(const Vehicle *v)

   233

{

   234

	assert(v->type == VEH_TRAIN);

   235

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

   236

}

   237

   238

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

   239

 * @param v Vehicle.

   240

 * @return Next vehicle in the consist.

   241

 */

   242

static inline Vehicle *GetNextVehicle(const Vehicle *v)

   243

{

   244

	assert(v->type == VEH_TRAIN);

   245

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

   246

   247

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

   248

	return v->Next();

   249

}

   250

   264

void ConvertOldMultiheadToNew();

   265

void ConnectMultiheadedTrains();

   266

uint CountArticulatedParts(EngineID engine_type);

   267

   268

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

   269

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

   270

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

   271

   272

byte FreightWagonMult(CargoID cargo);

   273

   274

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

   275

int CheckTrainStoppedInDepot(const Vehicle *v);

   276

   277

/**

   278

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

   279

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

   280

 * and you reinitialize that to a Train using:

   281

 *   v = new (v) Train();

   282

 *

   283

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

   284

 */

   285

struct Train : public Vehicle {

   286

	/** Initializes the Vehicle to a train */

   287

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

   288

   289

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

   290

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

   291

   292

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

   293

	void MarkDirty();

   294

	void UpdateDeltaXY(Direction direction);

   295

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

   296

	WindowClass GetVehicleListWindowClass() const { return WC_TRAINS_LIST; }

   297

	void PlayLeaveStationSound() const;

   298

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

   299

	bool HasFront() const { return true; }

   300

	int GetImage(Direction direction) const;

   301

	int GetDisplaySpeed() const { return this->cur_speed * 10 / 16; }

   302

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

   303

	Money GetRunningCost() const;

   304

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

   305

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

   306

	void Tick();

   307

};

   308

   309

#endif /* TRAIN_H */