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

	return HASBIT(v->subtype, Train_Front);

    35

}

    36

    37

/** Set front engine state

    38

 * @param v vehicle to change

    39

 */

    40

static inline void SetFrontEngine(Vehicle *v)

    41

{

    42

	SETBIT(v->subtype, Train_Front);

    43

}

    44

    45

/** Remove the front engine state

    46

 * @param v vehicle to change

    47

 */

    48

static inline void ClearFrontEngine(Vehicle *v)

    49

{

    50

	CLRBIT(v->subtype, Train_Front);

    51

}

    52

    53

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

    54

 * @param v vehicle to check

    55

 * @return Returns true if vehicle is an articulated part

    56

 */

    57

static inline bool IsArticulatedPart(const Vehicle *v)

    58

{

    59

	return HASBIT(v->subtype, Train_Articulated_Part);

    60

}

    61

    62

/** Set a vehicle to be an articulated part

    63

 * @param v vehicle to change

    64

 */

    65

static inline void SetArticulatedPart(Vehicle *v)

    66

{

    67

	SETBIT(v->subtype, Train_Articulated_Part);

    68

}

    69

    70

/** Clear a vehicle from being an articulated part

    71

 * @param v vehicle to change

    72

 */

    73

static inline void ClearArticulatedPart(Vehicle *v)

    74

{

    75

	CLRBIT(v->subtype, Train_Articulated_Part);

    76

}

    77

    78

/** Check if a vehicle is a wagon

    79

 * @param v vehicle to check

    80

 * @return Returns true if vehicle is a wagon

    81

 */

    82

static inline bool IsTrainWagon(const Vehicle *v)

    83

{

    84

	return HASBIT(v->subtype, Train_Wagon);

    85

}

    86

    87

/** Set a vehicle to be a wagon

    88

 * @param v vehicle to change

    89

 */

    90

static inline void SetTrainWagon(Vehicle *v)

    91

{

    92

	SETBIT(v->subtype, Train_Wagon);

    93

}

    94

    95

/** Clear wagon property

    96

 * @param v vehicle to change

    97

 */

    98

static inline void ClearTrainWagon(Vehicle *v)

    99

{

   100

	CLRBIT(v->subtype, Train_Wagon);

   101

}

   102

   103

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

   104

 * @param v vehicle to check

   105

 * @return Returns true if vehicle is an engine

   106

 */

   107

static inline bool IsTrainEngine(const Vehicle *v)

   108

{

   109

	return HASBIT(v->subtype, Train_Engine);

   110

}

   111

   112

/** Set engine status

   113

 * @param v vehicle to change

   114

 */

   115

static inline void SetTrainEngine(Vehicle *v)

   116

{

   117

	SETBIT(v->subtype, Train_Engine);

   118

}

   119

   120

/** Clear engine status

   121

 * @param v vehicle to change

   122

 */

   123

static inline void ClearTrainEngine(Vehicle *v)

   124

{

   125

	CLRBIT(v->subtype, Train_Engine);

   126

}

   127

   128

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

   129

 * @param v vehicle to check

   130

 * @return Returns true if vehicle is a free wagon

   131

 */

   132

static inline bool IsFreeWagon(const Vehicle *v)

   133

{

   134

	return HASBIT(v->subtype, Train_Free_Wagon);

   135

}

   136

   137

/** Set if a vehicle is a free wagon

   138

 * @param v vehicle to change

   139

 */

   140

static inline void SetFreeWagon(Vehicle *v)

   141

{

   142

	SETBIT(v->subtype, Train_Free_Wagon);

   143

}

   144

   145

/** Clear a vehicle from being a free wagon

   146

 * @param v vehicle to change

   147

 */

   148

static inline void ClearFreeWagon(Vehicle *v)

   149

{

   150

	CLRBIT(v->subtype, Train_Free_Wagon);

   151

}

   152

   153

/** Check if a vehicle is a multiheaded engine

   154

 * @param v vehicle to check

   155

 * @return Returns true if vehicle is a multiheaded engine

   156

 */

   157

static inline bool IsMultiheaded(const Vehicle *v)

   158

{

   159

	return HASBIT(v->subtype, Train_Multiheaded);

   160

}

   161

   162

/** Set if a vehicle is a multiheaded engine

   163

 * @param v vehicle to change

   164

 */

   165

static inline void SetMultiheaded(Vehicle *v)

   166

{

   167

	SETBIT(v->subtype, Train_Multiheaded);

   168

}

   169

   170

/** Clear multiheaded engine property

   171

 * @param v vehicle to change

   172

 */

   173

static inline void ClearMultiheaded(Vehicle *v)

   174

{

   175

	CLRBIT(v->subtype, Train_Multiheaded);

   176

}

   177

   178

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

   179

 * @param v Vehicle.

   180

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

   181

 */

   182

static inline bool EngineHasArticPart(const Vehicle *v)

   183

{

   184

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

   185

}

   186

   187

/**

   188

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

   189

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

   190

 * Result is undefined for normal engine.

   191

 */

   192

static inline Vehicle *GetNextArticPart(const Vehicle *v)

   193

{

   194

	assert(EngineHasArticPart(v));

   195

	return v->next;

   196

}

   197

   198

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

   199

 * @param v Vehicle.

   200

 * @return Last part of the engine.

   201

 */

   202

static inline Vehicle *GetLastEnginePart(Vehicle *v)

   203

{

   204

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

   205

	return v;

   206

}

   207

   208

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

   209

 * @param v Vehicle.

   210

 * @return Next vehicle in the consist.

   211

 */

   212

static inline Vehicle *GetNextVehicle(const Vehicle *v)

   213

{

   214

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

   215

   216

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

   217

	return v->next;

   218

}

   219

   220

void ConvertOldMultiheadToNew();

   221

void ConnectMultiheadedTrains();

   222

uint CountArticulatedParts(EngineID engine_type);

   223

   224

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

   225

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

   226

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

   227

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

   228

   229

byte FreightWagonMult(CargoID cargo);

   230

   231

#endif /* TRAIN_H */