1

/* $Id$ */

     2

     3

/** @vehicle.h */

     4

     5

#ifndef VEHICLE_H

     6

#define VEHICLE_H

     7

     8

#include "oldpool.h"

     9

#include "order.h"

    10

#include "rail.h"

    12

    13

/** The returned bits of VehicleEnterTile. */

    14

enum VehicleEnterTileStatus {

    15

	VETS_ENTERED_STATION  = 1, ///< The vehicle entered a station

    16

	VETS_ENTERED_WORMHOLE = 2, ///< The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/tunnel)

    17

	VETS_CANNOT_ENTER     = 3, ///< The vehicle cannot enter the tile

    18

    19

	/**

    20

	 * Shift the VehicleEnterTileStatus this many bits

    21

	 * to the right to get the station ID when

    22

	 * VETS_ENTERED_STATION is set

    23

	 */

    24

	VETS_STATION_ID_OFFSET = 8,

    25

    26

	/** Bit sets of the above specified bits */

    27

	VETSB_CONTINUE         = 0,                          ///< The vehicle can continue normally

    28

	VETSB_ENTERED_STATION  = 1 << VETS_ENTERED_STATION,  ///< The vehicle entered a station

    29

	VETSB_ENTERED_WORMHOLE = 1 << VETS_ENTERED_WORMHOLE, ///< The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/tunnel)

    30

	VETSB_CANNOT_ENTER     = 1 << VETS_CANNOT_ENTER,     ///< The vehicle cannot enter the tile

    31

};

    32

    33

/** Road vehicle states */

    34

enum RoadVehicleStates {

    35

	/*

    36

	 * Lower 4 bits are used for vehicle track direction. (Trackdirs)

    37

	 * When in a road stop (bit 5 or bit 6 set) these bits give the

    38

	 * track direction of the entry to the road stop.

    39

	 * As the entry direction will always be a diagonal

    40

	 * direction (X_NE, Y_SE, X_SW or Y_NW) only bits 0 and 3

    41

	 * are needed to hold this direction. Bit 1 is then used to show

    42

	 * that the vehicle is using the second road stop bay.

    43

	 * Bit 2 is then used for drive-through stops to show the vehicle

    44

	 * is stopping at this road stop.

    45

	 */

    46

    47

	/* Numeric values */

    48

	RVSB_IN_DEPOT                = 0xFE,                      ///< The vehicle is in a depot

    49

	RVSB_WORMHOLE                = 0xFF,                      ///< The vehicle is in a tunnel and/or bridge

    50

    51

	/* Bit numbers */

    52

	RVS_USING_SECOND_BAY         =    1,                      ///< Only used while in a road stop

    53

	RVS_IS_STOPPING              =    2,                      ///< Only used for drive-through stops. Vehicle will stop here

    54

	RVS_DRIVE_SIDE               =    4,                      ///< Only used when retrieving move data

    55

	RVS_IN_ROAD_STOP             =    5,                      ///< The vehicle is in a road stop

    56

	RVS_IN_DT_ROAD_STOP          =    6,                      ///< The vehicle is in a drive-through road stop

    57

    58

	/* Bit sets of the above specified bits */

    59

	RVSB_IN_ROAD_STOP            = 1 << RVS_IN_ROAD_STOP,     ///< The vehicle is in a road stop

    60

	RVSB_IN_ROAD_STOP_END        = RVSB_IN_ROAD_STOP + TRACKDIR_END,

    61

	RVSB_IN_DT_ROAD_STOP         = 1 << RVS_IN_DT_ROAD_STOP,  ///< The vehicle is in a drive-through road stop

    62

	RVSB_IN_DT_ROAD_STOP_END     = RVSB_IN_DT_ROAD_STOP + TRACKDIR_END,

    63

    64

	RVSB_TRACKDIR_MASK           = 0x0F,                      ///< The mask used to extract track dirs

    65

	RVSB_ROAD_STOP_TRACKDIR_MASK = 0x09                       ///< Only bits 0 and 3 are used to encode the trackdir for road stops

    66

};

    67

    68

enum VehicleType {

    69

	VEH_TRAIN,

    70

	VEH_ROAD,

    71

	VEH_SHIP,

    72

	VEH_AIRCRAFT,

    73

	VEH_SPECIAL,

    74

	VEH_DISASTER,

    75

	VEH_END,

    76

	VEH_INVALID = 0xFF,

    77

};

    78

template <> struct EnumPropsT<VehicleType> : MakeEnumPropsT<VehicleType, byte, VEH_TRAIN, VEH_END, VEH_INVALID> {};

    79

typedef TinyEnumT<VehicleType> VehicleTypeByte;

    80

    81

enum VehStatus {

    82

	VS_HIDDEN          = 0x01,

    83

	VS_STOPPED         = 0x02,

    84

	VS_UNCLICKABLE     = 0x04,

    85

	VS_DEFPAL          = 0x08,

    86

	VS_TRAIN_SLOWING   = 0x10,

    87

	VS_SHADOW          = 0x20,

    88

	VS_AIRCRAFT_BROKEN = 0x40,

    89

	VS_CRASHED         = 0x80,

    90

};

    91

    92

enum VehicleFlags {

    93

	VF_LOADING_FINISHED,

    94

	VF_CARGO_UNLOADING,

    95

	VF_BUILT_AS_PROTOTYPE,

    96

};

    97

    98

/* Effect vehicle types */

    99

enum EffectVehicle {

   100

	EV_CHIMNEY_SMOKE   = 0,

   101

	EV_STEAM_SMOKE     = 1,

   102

	EV_DIESEL_SMOKE    = 2,

   103

	EV_ELECTRIC_SPARK  = 3,

   104

	EV_SMOKE           = 4,

   105

	EV_EXPLOSION_LARGE = 5,

   106

	EV_BREAKDOWN_SMOKE = 6,

   107

	EV_EXPLOSION_SMALL = 7,

   108

	EV_BULLDOZER       = 8,

   109

	EV_BUBBLE          = 9

   110

};

   111

   112

struct VehicleRail {

   113

	uint16 last_speed; // NOSAVE: only used in UI

   114

	uint16 crash_anim_pos;

   115

   116

	/* cached values, recalculated on load and each time a vehicle is added to/removed from the consist. */

   117

	uint16 cached_max_speed;  // max speed of the consist. (minimum of the max speed of all vehicles in the consist)

   118

	uint32 cached_power;      // total power of the consist.

   119

	uint8 cached_veh_length;  // length of this vehicle in units of 1/8 of normal length, cached because this can be set by a callback

   120

	uint16 cached_total_length; ///< Length of the whole train, valid only for first engine.

   121

   122

	/* cached values, recalculated when the cargo on a train changes (in addition to the conditions above) */

   123

	uint32 cached_weight;     // total weight of the consist.

   124

	uint32 cached_veh_weight; // weight of the vehicle.

   125

	uint32 cached_max_te;     // max tractive effort of consist

   126

	/**

   127

	 * Position/type of visual effect.

   128

	 * bit 0 - 3 = position of effect relative to vehicle. (0 = front, 8 = centre, 15 = rear)

   129

	 * bit 4 - 5 = type of effect. (0 = default for engine class, 1 = steam, 2 = diesel, 3 = electric)

   130

	 * bit     6 = disable visual effect.

   131

	 * bit     7 = disable powered wagons.

   132

	 */

   133

	byte cached_vis_effect;

   134

   135

	/* NOSAVE: for wagon override - id of the first engine in train

   136

	 * 0xffff == not in train */

   137

	EngineID first_engine;

   138

   139

	TrackBitsByte track;

   140

	byte force_proceed;

   141

	RailTypeByte railtype;

   142

	RailTypeMask compatible_railtypes;

   143

   144

	byte flags;

   145

   146

	/* Link between the two ends of a multiheaded engine */

   147

	Vehicle *other_multiheaded_part;

   148

   149

	/* Cached wagon override spritegroup */

   150

	const struct SpriteGroup *cached_override;

   151

};

   152

   153

enum {

   154

	VRF_REVERSING         = 0,

   155

   156

	/* used to calculate if train is going up or down */

   157

	VRF_GOINGUP           = 1,

   158

	VRF_GOINGDOWN         = 2,

   159

   160

	/* used to store if a wagon is powered or not */

   161

	VRF_POWEREDWAGON      = 3,

   162

   163

	/* used to reverse the visible direction of the vehicle */

   164

	VRF_REVERSE_DIRECTION = 4,

   165

   166

	/* used to mark train as lost because PF can't find the route */

   167

	VRF_NO_PATH_TO_DESTINATION = 5,

   168

   169

	/* used to mark that electric train engine is allowed to run on normal rail */

   170

	VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL = 6,

   171

};

   172

   173

struct VehicleAir {

   174

	uint16 crashed_counter;

   175

	uint16 cached_max_speed;

   176

	byte pos;

   177

	byte previous_pos;

   178

	StationID targetairport;

   179

	byte state;

   180

};

   181

   182

struct VehicleRoad {

   183

	byte state;             ///< @see RoadVehicleStates

   184

	byte frame;

   185

	uint16 blocked_ctr;

   186

	byte overtaking;

   187

	byte overtaking_ctr;

   188

	uint16 crashed_ctr;

   189

	byte reverse_ctr;

   190

	struct RoadStop *slot;

   191

	byte slot_age;

   195

};

   196

   197

struct VehicleSpecial {

   198

	uint16 unk0;

   199

	byte unk2;

   200

};

   201

   202

struct VehicleDisaster {

   203

	uint16 image_override;

   204

	uint16 unk2;

   205

};

   206

   207

struct VehicleShip {

   208

	TrackBitsByte state;

   209

};

   210

   211

   212

struct Vehicle {

   213

	VehicleTypeByte type;    ///< Type of vehicle

   214

	byte subtype;            // subtype (Filled with values from EffectVehicles/TrainSubTypes/AircraftSubTypes)

   215

   216

	VehicleID index;         // NOSAVE: Index in vehicle array

   217

   218

	Vehicle *next;           // next

   219

	Vehicle *first;          // NOSAVE: pointer to the first vehicle in the chain

   220

	Vehicle *depot_list;     //NOSAVE: linked list to tell what vehicles entered a depot during the last tick. Used by autoreplace

   221

   222

	StringID string_id;      // Displayed string

   223

   224

	UnitID unitnumber;       // unit number, for display purposes only

   225

	PlayerByte owner;        // which player owns the vehicle?

   226

   227

	TileIndex tile;          // Current tile index

   228

	TileIndex dest_tile;     // Heading for this tile

   229

   230

	int32 x_pos;             // coordinates

   231

	int32 y_pos;

   232

	byte z_pos;

   233

	DirectionByte direction; // facing

   234

   235

	byte spritenum;          // currently displayed sprite index

   236

	                         // 0xfd == custom sprite, 0xfe == custom second head sprite

   237

	                         // 0xff == reserved for another custom sprite

   238

	uint16 cur_image;        // sprite number for this vehicle

   239

	byte sprite_width;       // width of vehicle sprite

   240

	byte sprite_height;      // height of vehicle sprite

   241

	byte z_height;           // z-height of vehicle sprite

   242

	int8 x_offs;             // x offset for vehicle sprite

   243

	int8 y_offs;             // y offset for vehicle sprite

   244

	EngineID engine_type;

   245

   246

	/* for randomized variational spritegroups

   247

	 * bitmask used to resolve them; parts of it get reseeded when triggers

   248

	 * of corresponding spritegroups get matched */

   249

	byte random_bits;

   250

	byte waiting_triggers;   // triggers to be yet matched

   251

   252

	uint16 max_speed;        // maximum speed

   253

	uint16 cur_speed;        // current speed

   254

	byte subspeed;           // fractional speed

   255

	byte acceleration;       // used by train & aircraft

   256

	byte progress;

   257

	uint32 motion_counter;

   258

   259

	byte vehstatus;          // Status

   260

	StationID last_station_visited;

   261

   262

	CargoID cargo_type;      // type of cargo this vehicle is carrying

   263

	byte cargo_days;         // how many days have the pieces been in transit

   264

	StationID cargo_source;  // source of cargo

   265

	TileIndex cargo_source_xy; //< stores the Tile where the source station is located, in case it is removed

   266

	uint16 cargo_cap;        // total capacity

   267

	uint16 cargo_count;      // how many pieces are used

   268

	byte cargo_subtype;      ///< Used for livery refits (NewGRF variations)

   269

   270

	byte day_counter;        // increased by one for each day

   271

	byte tick_counter;       // increased by one for each tick

   272

   273

	/* Begin Order-stuff */

   274

	Order current_order;     ///< The current order (+ status, like: loading)

   275

	VehicleOrderID cur_order_index; ///< The index to the current order

   276

   277

	Order *orders;           ///< Pointer to the first order for this vehicle

   278

	VehicleOrderID num_orders;      ///< How many orders there are in the list

   279

   280

	Vehicle *next_shared;    ///< If not NULL, this points to the next vehicle that shared the order

   281

	Vehicle *prev_shared;    ///< If not NULL, this points to the prev vehicle that shared the order

   282

	/* End Order-stuff */

   283

   284

	/* Boundaries for the current position in the world and a next hash link.

   285

	 * NOSAVE: All of those can be updated with VehiclePositionChanged() */

   286

	int32 left_coord;

   287

	int32 top_coord;

   288

	int32 right_coord;

   289

	int32 bottom_coord;

   290

	Vehicle *next_hash;

   291

   292

	/* Related to age and service time */

   293

	Date age;     // Age in days

   294

	Date max_age; // Maximum age

   295

	Date date_of_last_service;

   296

	Date service_interval;

   297

	uint16 reliability;

   298

	uint16 reliability_spd_dec;

   299

	byte breakdown_ctr;

   300

	byte breakdown_delay;

   301

	byte breakdowns_since_last_service;

   302

	byte breakdown_chance;

   303

	Year build_year;

   304

   305

	bool leave_depot_instantly; // NOSAVE: stores if the vehicle needs to leave the depot it just entered. Used by autoreplace

   306

   307

	uint16 load_unload_time_rem;

   308

	uint16 cargo_paid_for;      // How much of the cargo currently on board has been paid for.

   309

	byte vehicle_flags;         // Used for gradual loading and other miscellaneous things (@see VehicleFlags enum)

   310

   311

	int32 profit_this_year;

   312

	int32 profit_last_year;

   313

	int32 cargo_feeder_share;      ///< value of feeder pickup to be paid for on delivery of cargo

   314

	TileIndex cargo_loaded_at_xy;  ///< tile index where feeder cargo was loaded

   315

	uint32 value;

   316

   317

	GroupID group_id;              ///< Index of group Pool array

   318

   319

	union {

   320

		VehicleRail rail;

   321

		VehicleAir air;

   322

		VehicleRoad road;

   323

		VehicleSpecial special;

   324

		VehicleDisaster disaster;

   325

		VehicleShip ship;

   326

	} u;

   327

   328

	void BeginLoading();

   329

	void LeaveStation();

   330

   331

	/**

   332

	 * Handle the loading of the vehicle; when not it skips through dummy

   333

	 * orders and does nothing in all other cases.

   334

	 * @param mode is the non-first call for this vehicle in this tick?

   335

	 */

   336

	void HandleLoading(bool mode = false);

   337

   338

	/**

   339

	 * An overriden version of new, so you can use the vehicle instance

   340

	 * instead of a newly allocated piece of memory.

   341

	 * @param size the size of the variable (unused)

   342

	 * @param v    the vehicle to use as 'storage' backend

   343

	 * @return the memory that is 'allocated'

   344

	 */

   345

	void* operator new(size_t size, Vehicle *v) { return v; }

   346

   347

	/**

   348

	 * 'Free' the memory allocated by the overriden new.

   349

	 * @param p the memory to 'free'

   350

	 * @param v the vehicle that was given to 'new' on creation.

   351

	 * @note This function isn't used (at the moment) and only added

   352

	 *       to please some compiler.

   353

	 */

   354

	void operator delete(void *p, Vehicle *v) {}

   355

   356

	/**

   357

	 * 'Free' the memory allocated by the overriden new.

   358

	 * @param p the memory to 'free'

   359

	 * @note This function isn't used (at the moment) and only added

   360

	 *       as the above function was needed to please some compiler

   361

	 *       which made it necessary to add this to please yet

   362

	 *       another compiler...

   363

	 */

   364

	void operator delete(void *p) {}

   365

   366

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

   367

	virtual ~Vehicle() {}

   368

   369

	/**

   370

	 * Get a string 'representation' of the vehicle type.

   371

	 * @return the string representation.

   372

	 */

   373

	virtual const char* GetTypeString() const = 0;

   374

   375

	/**

   376

	 * Marks the vehicles to be redrawn and updates cached variables

   377

	 */

   378

	virtual void MarkDirty() {}

   379

   380

	/**

   381

	 * Updates the x and y offsets and the size of the sprite used

   382

	 * for this vehicle.

   383

	 * @param direction the direction the vehicle is facing

   384

	 */

   385

	virtual void UpdateDeltaXY(Direction direction) {}

   386

   387

	/**

   388

	 * Sets the expense type associated to this vehicle type

   389

	 * @param income whether this is income or (running) expenses of the vehicle

   390

	 */

   391

	virtual ExpensesType GetExpenseType(bool income) const { return EXPENSES_OTHER; }

   392

   393

	/**

   394

	 * Invalidates the vehicle list window of this type of vehicle

   395

	 */

   396

	virtual WindowClass GetVehicleListWindowClass() const { return WC_NONE; }

   397

   398

	/**

   399

	 * Play the sound associated with leaving the station

   400

	 */

   401

	virtual void PlayLeaveStationSound() const {}

   402

};

   403

   404

/**

   405

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

   406

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

   407

 * and you reinitialize that to a Train using:

   408

 *   v = new (v) Train();

   409

 *

   410

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

   411

 *

   412

 * A special vehicle is one of the following:

   413

 *  - smoke

   414

 *  - electric sparks for trains

   415

 *  - explosions

   416

 *  - bulldozer (road works)

   417

 *  - bubbles (industry)

   418

 */

   419

struct SpecialVehicle : public Vehicle {

   420

	/** Initializes the Vehicle to a special vehicle */

   421

	SpecialVehicle() { this->type = VEH_SPECIAL; }

   422

   423

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

   424

	virtual ~SpecialVehicle() {}

   425

   426

	const char *GetTypeString() const { return "special vehicle"; }

   427

	void UpdateDeltaXY(Direction direction);

   428

};

   429

   430

/**

   431

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

   432

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

   433

 * and you reinitialize that to a Train using:

   434

 *   v = new (v) Train();

   435

 *

   436

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

   437

 */

   438

struct DisasterVehicle : public Vehicle {

   439

	/** Initializes the Vehicle to a disaster vehicle */

   440

	DisasterVehicle() { this->type = VEH_DISASTER; }

   441

   442

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

   443

	virtual ~DisasterVehicle() {}

   444

   445

	const char *GetTypeString() const { return "disaster vehicle"; }

   446

	void UpdateDeltaXY(Direction direction);

   447

};

   448

   449

/**

   450

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

   451

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

   452

 * and you reinitialize that to a Train using:

   453

 *   v = new (v) Train();

   454

 *

   455

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

   456

 */

   457

struct InvalidVehicle : public Vehicle {

   458

	/** Initializes the Vehicle to a invalid vehicle */

   459

	InvalidVehicle() { this->type = VEH_INVALID; }

   460

   461

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

   462

	virtual ~InvalidVehicle() {}

   463

   464

	const char *GetTypeString() const { return "invalid vehicle"; }

   465

};

   466

   467

#define is_custom_sprite(x) (x >= 0xFD)

   468

#define IS_CUSTOM_FIRSTHEAD_SPRITE(x) (x == 0xFD)

   469

#define IS_CUSTOM_SECONDHEAD_SPRITE(x) (x == 0xFE)

   470

   471

typedef void *VehicleFromPosProc(Vehicle *v, void *data);

   472

   473

void VehicleServiceInDepot(Vehicle *v);

   474

Vehicle *AllocateVehicle();

   475

bool AllocateVehicles(Vehicle **vl, int num);

   476

Vehicle *ForceAllocateVehicle();

   477

Vehicle *ForceAllocateSpecialVehicle();

   478

void VehiclePositionChanged(Vehicle *v);

   479

void AfterLoadVehicles();

   480

Vehicle *GetLastVehicleInChain(Vehicle *v);

   481

Vehicle *GetPrevVehicleInChain(const Vehicle *v);

   482

Vehicle *GetFirstVehicleInChain(const Vehicle *v);

   483

uint CountVehiclesInChain(const Vehicle* v);

   484

bool IsEngineCountable(const Vehicle *v);

   485

void DeleteVehicleChain(Vehicle *v);

   486

void *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc);

   487

void CallVehicleTicks();

   488