1

/* $Id$ */

     2

     3

#ifndef TRAIN_H

     4

#define TRAIN_H

     5

     6

#include "stdafx.h"

     7

#include "vehicle.h"

     8

     9

    10

/*

    11

 * enum to handle train subtypes

    12

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

    13

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

    14

 */

    15

    16

enum TrainSubtype {

    17

	Train_Front             = 0, // Leading engine of a train

    18

	Train_Articulated_Part  = 1, // Articulated part of an engine

    19

	Train_Wagon             = 2, // Wagon

    20

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

    21

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

    22

	Train_Multiheaded       = 5, // Engine is a multiheaded

    23

};

    24

    25

    26

/** Check if a vehicle is front engine

    27

 * @param v vehicle to check

    28

 * @return Returns true if vehicle is a front engine

    29

 */

    30

static inline bool IsFrontEngine(const Vehicle *v)

    31

{

    32

	return HASBIT(v->subtype, Train_Front);

    33

}

    34

    35

/** Set front engine state

    36

 * @param v vehicle to change

    37

 */

    38

static inline void SetFrontEngine(Vehicle *v)

    39

{

    40

	SETBIT(v->subtype, Train_Front);

    41

}

    42

    43

/** Remove the front engine state

    44

 * @param v vehicle to change

    45

 */

    46

static inline void ClearFrontEngine(Vehicle *v)

    47

{

    48

	CLRBIT(v->subtype, Train_Front);

    49

}

    50

    51

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

    52

 * @param v vehicle to check

    53

 * @return Returns true if vehicle is an articulated part

    54

 */

    55

static inline bool IsArticulatedPart(const Vehicle *v)

    56

{

    57

	return HASBIT(v->subtype, Train_Articulated_Part);

    58

}

    59

    60

/** Set a vehicle to be an articulated part

    61

 * @param v vehicle to change

    62

 */

    63

static inline void SetArticulatedPart(Vehicle *v)

    64

{

    65

	SETBIT(v->subtype, Train_Articulated_Part);

    66

}

    67

    68

/** Clear a vehicle from being an articulated part

    69

 * @param v vehicle to change

    70

 */

    71

static inline void ClearArticulatedPart(Vehicle *v)

    72

{

    73

	CLRBIT(v->subtype, Train_Articulated_Part);

    74

}

    75

    76

/** Check if a vehicle is a wagon

    77

 * @param v vehicle to check

    78

 * @return Returns true if vehicle is a wagon

    79

 */

    80

static inline bool IsTrainWagon(const Vehicle *v)

    81

{

    82

	return HASBIT(v->subtype, Train_Wagon);

    83

}

    84

    85

/** Set a vehicle to be a wagon

    86

 * @param v vehicle to change

    87

 */

    88

static inline void SetTrainWagon(Vehicle *v)

    89

{

    90

	SETBIT(v->subtype, Train_Wagon);

    91

}

    92

    93

/** Clear wagon property

    94

 * @param v vehicle to change

    95

 */

    96

static inline void ClearTrainWagon(Vehicle *v)

    97

{

    98

	CLRBIT(v->subtype, Train_Wagon);

    99

}

   100

   101

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

   102

 * @param v vehicle to check

   103

 * @return Returns true if vehicle is an engine

   104

 */

   105

static inline bool IsTrainEngine(const Vehicle *v)

   106

{

   107

	return HASBIT(v->subtype, Train_Engine);

   108

}

   109

   110

/** Set engine status

   111

 * @param v vehicle to change

   112

 */

   113

static inline void SetTrainEngine(Vehicle *v)

   114

{

   115

	SETBIT(v->subtype, Train_Engine);

   116

}

   117

   118

/** Clear engine status

   119

 * @param v vehicle to change

   120

 */

   121

static inline void ClearTrainEngine(Vehicle *v)

   122

{

   123

	CLRBIT(v->subtype, Train_Engine);

   124

}

   125

   126

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

   127

 * @param v vehicle to check

   128

 * @return Returns true if vehicle is a free wagon

   129

 */

   130

static inline bool IsFreeWagon(const Vehicle *v)

   131

{

   132

	return HASBIT(v->subtype, Train_Free_Wagon);

   133

}

   134

   135

/** Set if a vehicle is a free wagon

   136

 * @param v vehicle to change

   137

 */

   138

static inline void SetFreeWagon(Vehicle *v)

   139

{

   140

	SETBIT(v->subtype, Train_Free_Wagon);

   141

}

   142

   143

/** Clear a vehicle from being a free wagon

   144

 * @param v vehicle to change

   145

 */

   146

static inline void ClearFreeWagon(Vehicle *v)

   147

{

   148

	CLRBIT(v->subtype, Train_Free_Wagon);

   149

}

   150

   151

/** Check if a vehicle is a multiheaded engine

   152

 * @param v vehicle to check

   153

 * @return Returns true if vehicle is a multiheaded engine

   154

 */

   155

static inline bool IsMultiheaded(const Vehicle *v)

   156

{

   157

	return HASBIT(v->subtype, Train_Multiheaded);

   158

}

   159

   160

/** Set if a vehicle is a multiheaded engine

   161

 * @param v vehicle to change

   162

 */

   163

static inline void SetMultiheaded(Vehicle *v)

   164

{

   165

	SETBIT(v->subtype, Train_Multiheaded);

   166

}

   167

   168

/** Clear multiheaded engine property

   169

 * @param v vehicle to change

   170

 */

   171

static inline void ClearMultiheaded(Vehicle *v)

   172

{

   173

	CLRBIT(v->subtype, Train_Multiheaded);

   174

}

   175

   176

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

   177

 * @param v Vehicle.

   178

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

   179

 */

   180

static inline bool EngineHasArticPart(const Vehicle *v)

   181

{

   182

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

   183

}

   184

   185

/**

   186

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

   187

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

   188

 * Result is undefined for normal engine.

   189

 */

   190

static inline Vehicle *GetNextArticPart(const Vehicle *v)

   191

{

   192

	assert(EngineHasArticPart(v));

   193

	return v->next;

   194

}

   195

   196

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

   197

 * @param v Vehicle.

   198

 * @return Last part of the engine.

   199

 */

   200

static inline Vehicle *GetLastEnginePart(Vehicle *v)

   201

{

   202

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

   203

	return v;

   204

}

   205

   206

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

   207

 * @param v Vehicle.

   208

 * @return Next vehicle in the consist.

   209

 */

   210

static inline Vehicle *GetNextVehicle(const Vehicle *v)

   211

{

   212

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

   213

   214

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

   215

	return v->next;

   216

}

   217

   218

void ConvertOldMultiheadToNew();

   219

void ConnectMultiheadedTrains();

   220

uint CountArticulatedParts(EngineID engine_type);

   221

   222

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

   223

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

   224

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

   225

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

   226

   227

byte FreightWagonMult(CargoID cargo);

   228

   229

#endif /* TRAIN_H */