1

/* $Id$ */

     2

     3

/** @file train.h */

     4

     5

#ifndef TRAIN_H

     6

#define TRAIN_H

     7

     8

#include "stdafx.h"

     9

#include "core/bitmath_func.hpp"

    10

#include "vehicle_base.h"

    11

    12

    13

/*

    14

 * enum to handle train subtypes

    15

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

    16

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

    17

 */

    18

    19

enum TrainSubtype {

    20

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

    21

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

    22

	TS_WAGON             = 2, ///< Wagon

    23

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

    24

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

    25

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

    26

};

    27

    28

    29

/** Check if a vehicle is front engine

    30

 * @param v vehicle to check

    31

 * @return Returns true if vehicle is a front engine

    32

 */

    33

static inline bool IsFrontEngine(const Vehicle *v)

    34

{

    35

	assert(v->type == VEH_TRAIN);

    36

	return HasBit(v->subtype, TS_FRONT);

    37

}

    38

    39

/** Set front engine state

    40

 * @param v vehicle to change

    41

 */

    42

static inline void SetFrontEngine(Vehicle *v)

    43

{

    44

	assert(v->type == VEH_TRAIN);

    45

	SetBit(v->subtype, TS_FRONT);

    46

}

    47

    48

/** Remove the front engine state

    49

 * @param v vehicle to change

    50

 */

    51

static inline void ClearFrontEngine(Vehicle *v)

    52

{

    53

	assert(v->type == VEH_TRAIN);

    54

	ClrBit(v->subtype, TS_FRONT);

    55

}

    56

    57

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

    58

 * @param v vehicle to check

    59

 * @return Returns true if vehicle is an articulated part

    60

 */

    61

static inline bool IsArticulatedPart(const Vehicle *v)

    62

{

    63

	assert(v->type == VEH_TRAIN);

    64

	return HasBit(v->subtype, TS_ARTICULATED_PART);

    65

}

    66

    67

/** Set a vehicle to be an articulated part

    68

 * @param v vehicle to change

    69

 */

    70

static inline void SetArticulatedPart(Vehicle *v)

    71

{

    72

	assert(v->type == VEH_TRAIN);

    73

	SetBit(v->subtype, TS_ARTICULATED_PART);

    74

}

    75

    76

/** Clear a vehicle from being an articulated part

    77

 * @param v vehicle to change

    78

 */

    79

static inline void ClearArticulatedPart(Vehicle *v)

    80

{

    81

	assert(v->type == VEH_TRAIN);

    82

	ClrBit(v->subtype, TS_ARTICULATED_PART);

    83

}

    84

    85

/** Check if a vehicle is a wagon

    86

 * @param v vehicle to check

    87

 * @return Returns true if vehicle is a wagon

    88

 */

    89

static inline bool IsTrainWagon(const Vehicle *v)

    90

{

    91

	assert(v->type == VEH_TRAIN);

    92

	return HasBit(v->subtype, TS_WAGON);

    93

}

    94

    95

/** Set a vehicle to be a wagon

    96

 * @param v vehicle to change

    97

 */

    98

static inline void SetTrainWagon(Vehicle *v)

    99

{

   100

	assert(v->type == VEH_TRAIN);

   101

	SetBit(v->subtype, TS_WAGON);

   102

}

   103

   104

/** Clear wagon property

   105

 * @param v vehicle to change

   106

 */

   107

static inline void ClearTrainWagon(Vehicle *v)

   108

{

   109

	assert(v->type == VEH_TRAIN);

   110

	ClrBit(v->subtype, TS_WAGON);

   111

}

   112

   113

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

   114

 * @param v vehicle to check

   115

 * @return Returns true if vehicle is an engine

   116

 */

   117

static inline bool IsTrainEngine(const Vehicle *v)

   118

{

   119

	assert(v->type == VEH_TRAIN);

   120

	return HasBit(v->subtype, TS_ENGINE);

   121

}

   122

   123

/** Set engine status

   124

 * @param v vehicle to change

   125

 */

   126

static inline void SetTrainEngine(Vehicle *v)

   127

{

   128

	assert(v->type == VEH_TRAIN);

   129

	SetBit(v->subtype, TS_ENGINE);

   130

}

   131

   132

/** Clear engine status

   133

 * @param v vehicle to change

   134

 */

   135

static inline void ClearTrainEngine(Vehicle *v)

   136

{

   137

	assert(v->type == VEH_TRAIN);

   138

	ClrBit(v->subtype, TS_ENGINE);

   139

}

   140

   141

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

   142

 * @param v vehicle to check

   143

 * @return Returns true if vehicle is a free wagon

   144

 */

   145

static inline bool IsFreeWagon(const Vehicle *v)

   146

{

   147

	assert(v->type == VEH_TRAIN);

   148

	return HasBit(v->subtype, TS_FREE_WAGON);

   149

}

   150

   151

/** Set if a vehicle is a free wagon

   152

 * @param v vehicle to change

   153

 */

   154

static inline void SetFreeWagon(Vehicle *v)

   155

{

   156

	assert(v->type == VEH_TRAIN);

   157

	SetBit(v->subtype, TS_FREE_WAGON);

   158

}

   159

   160

/** Clear a vehicle from being a free wagon

   161

 * @param v vehicle to change

   162

 */

   163

static inline void ClearFreeWagon(Vehicle *v)

   164

{

   165

	assert(v->type == VEH_TRAIN);

   166

	ClrBit(v->subtype, TS_FREE_WAGON);

   167

}

   168

   169

/** Check if a vehicle is a multiheaded engine

   170

 * @param v vehicle to check

   171

 * @return Returns true if vehicle is a multiheaded engine

   172

 */

   173

static inline bool IsMultiheaded(const Vehicle *v)

   174

{

   175

	assert(v->type == VEH_TRAIN);

   176

	return HasBit(v->subtype, TS_MULTIHEADED);

   177

}

   178

   179

/** Set if a vehicle is a multiheaded engine

   180

 * @param v vehicle to change

   181

 */

   182

static inline void SetMultiheaded(Vehicle *v)

   183

{

   184

	assert(v->type == VEH_TRAIN);

   185

	SetBit(v->subtype, TS_MULTIHEADED);

   186

}

   187

   188

/** Clear multiheaded engine property

   189

 * @param v vehicle to change

   190

 */

   191

static inline void ClearMultiheaded(Vehicle *v)

   192

{

   193

	assert(v->type == VEH_TRAIN);

   194

	ClrBit(v->subtype, TS_MULTIHEADED);

   195

}

   196

   197

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

   198

 * @param v Vehicle.

   199

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

   200

 */

   201

static inline bool EngineHasArticPart(const Vehicle *v)

   202

{

   203

	assert(v->type == VEH_TRAIN);

   204

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

   205

}

   206

   207

/**

   208

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

   209

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

   210

 * Result is undefined for normal engine.

   211

 */

   212

static inline Vehicle *GetNextArticPart(const Vehicle *v)

   213

{

   214

	assert(EngineHasArticPart(v));

   215

	return v->Next();

   216

}

   217

   218

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

   219

 * @param v Vehicle.

   220

 * @return Last part of the engine.

   221

 */

   222

static inline Vehicle *GetLastEnginePart(Vehicle *v)

   223

{

   224

	assert(v->type == VEH_TRAIN);

   225

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

   226

	return v;

   227

}

   228

   229

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

   230

 * @param v Vehicle.

   231

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

   232

 */

   233

static inline bool IsRearDualheaded(const Vehicle *v)

   234

{

   235

	assert(v->type == VEH_TRAIN);

   236

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

   237

}

   238

   239

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

   240

 * @param v Vehicle.

   241

 * @return Next vehicle in the consist.

   242

 */

   243

static inline Vehicle *GetNextVehicle(const Vehicle *v)

   244

{

   245

	assert(v->type == VEH_TRAIN);

   246

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

   247

   248

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

   249

	return v->Next();

   250

}

   251

   252

/** Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.

   253

 * @param v Vehicle.

   254

 * @return Next vehicle in the consist.

   255

 */

   256

static inline Vehicle *GetNextUnit(Vehicle *v)

   257

{

   258

	assert(v->type == VEH_TRAIN);

   259

	v = GetNextVehicle(v);

   260

	if (v != NULL && IsRearDualheaded(v)) v = v->Next();

   261

   262

	return v;

   263

}

   264

   265

void ConvertOldMultiheadToNew();

   266

void ConnectMultiheadedTrains();

   267

uint CountArticulatedParts(EngineID engine_type);

   268

   269

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

   270

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

   271

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

   272

   273

byte FreightWagonMult(CargoID cargo);

   274

   275

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

   276

int CheckTrainStoppedInDepot(const Vehicle *v);

   277

void UpdateTrainAcceleration(Vehicle* v);

   278

   279

/**

   280

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

   281

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

   282

 * and you reinitialize that to a Train using:

   283

 *   v = new (v) Train();

   284

 *

   285

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

   286

 */

   287

struct Train : public Vehicle {

   288

	/** Initializes the Vehicle to a train */

   289

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

   290

   291

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

   292

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

   293

   294

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

   295

	void MarkDirty();

   296

	void UpdateDeltaXY(Direction direction);

   297

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

   298

	WindowClass GetVehicleListWindowClass() const { return WC_TRAINS_LIST; }

   299

	void PlayLeaveStationSound() const;

   300

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

   301

	int GetImage(Direction direction) const;

   302

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

   303

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

   304

	Money GetRunningCost() const;

   305

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

   306

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

   307

	void Tick();

   308

	void OnNewDay();

   309

};

   310

   311

#endif /* TRAIN_H */