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

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

   229

 * @param v Vehicle.

   230

 * @return Next vehicle in the consist.

   231

 */

   232

static inline Vehicle *GetNextVehicle(const Vehicle *v)

   233

{

   234

	assert(v->type == VEH_TRAIN);

   235

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

   236

   237

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

   238

	return v->next;

   239

}

   240

   241

void ConvertOldMultiheadToNew();

   242

void ConnectMultiheadedTrains();

   243

uint CountArticulatedParts(EngineID engine_type);

   244

   245

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

   246

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

   247

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

   248

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

   249

   250

byte FreightWagonMult(CargoID cargo);

   251

   252

/**

   253

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

   254

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

   255

 * and you reinitialize that to a Train using:

   256

 *   v = new (v) Train();

   257

 *

   258

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

   259

 */

   260

struct Train : public Vehicle {

   261

	/** Initializes the Vehicle to a train */

   262

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

   263

   264

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

   265

	virtual ~Train() {}

   266

   267

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

   268

	void MarkDirty();

   269

	void UpdateDeltaXY(Direction direction);

   270

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

   271

	WindowClass GetVehicleListWindowClass() const { return WC_TRAINS_LIST; }

   272

	void PlayLeaveStationSound() const;

   273

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

   274

	bool HasFront() const { return true; }

   275

};

   276

   277

#endif /* TRAIN_H */