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

typedef enum TrainSubtypes {

    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

} TrainSubtype;

    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

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

   177

 * @param v Vehicle.

   178

 * @return Next vehicle in the consist.

   179

 */

   180

static inline Vehicle *GetNextVehicle(const Vehicle *v)

   181

{

   182

	Vehicle *u = v->next;

   183

	while (u != NULL && IsArticulatedPart(u)) {

   184

		u = u->next;

   185

	}

   186

	return u;

   187

}

   188

   189

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

   190

 * @param v Vehicle.

   191

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

   192

 */

   193

static inline bool EngineHasArticPart(const Vehicle *v)

   194

{

   195

	return (v->next != NULL && IsArticulatedPart(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 = v->next;

   205

	return v;

   206

}

   207

   208

void ConvertOldMultiheadToNew(void);

   209

void ConnectMultiheadedTrains(void);

   210

   211

#endif /* TRAIN_H */