1

/* $Id$ */

     2

     3

/** @file  vehicle_base.h Base class for all vehicles. */

     4

     5

#ifndef VEHICLE_BASE_H

     6

#define VEHICLE_BASE_H

     7

     8

#include "vehicle_type.h"

     9

#include "track_type.h"

    10

#include "rail_type.h"

    11

#include "road_type.h"

    12

#include "cargo_type.h"

    13

#include "direction_type.h"

    14

#include "gfx_type.h"

    15

#include "command_type.h"

    16

#include "date_type.h"

    17

#include "company_base.h"

    18

#include "company_type.h"

    19

#include "oldpool.h"

    20

#include "order_base.h"

    21

#include "cargopacket.h"

    22

#include "texteff.hpp"

    23

#include "group_type.h"

    24

#include "engine_type.h"

    25

#include "order_func.h"

    26

#include "transport_type.h"

    27

    28

/** Road vehicle states */

    29

enum RoadVehicleStates {

    30

	/*

    31

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

    32

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

    33

	 * track direction of the entry to the road stop.

    34

	 * As the entry direction will always be a diagonal

    35

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

    36

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

    37

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

    38

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

    39

	 * is stopping at this road stop.

    40

	 */

    41

    42

	/* Numeric values */

    43

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

    44

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

    45

    46

	/* Bit numbers */

    47

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

    48

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

    49

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

    50

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

    51

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

    52

    53

	/* Bit sets of the above specified bits */

    54

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

    55

	RVSB_IN_ROAD_STOP_END        = RVSB_IN_ROAD_STOP + TRACKDIR_END,

    56

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

    57

	RVSB_IN_DT_ROAD_STOP_END     = RVSB_IN_DT_ROAD_STOP + TRACKDIR_END,

    58

    59

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

    60

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

    61

};

    62

    63

enum VehStatus {

    64

	VS_HIDDEN          = 0x01,

    65

	VS_STOPPED         = 0x02,

    66

	VS_UNCLICKABLE     = 0x04,

    67

	VS_DEFPAL          = 0x08,

    68

	VS_TRAIN_SLOWING   = 0x10,

    69

	VS_SHADOW          = 0x20,

    70

	VS_AIRCRAFT_BROKEN = 0x40,

    71

	VS_CRASHED         = 0x80,

    72

};

    73

    74

enum VehicleFlags {

    75

	VF_LOADING_FINISHED,

    76

	VF_CARGO_UNLOADING,

    77

	VF_BUILT_AS_PROTOTYPE,

    78

	VF_TIMETABLE_STARTED,       ///< Whether the vehicle has started running on the timetable yet.

    79

	VF_AUTOFILL_TIMETABLE,      ///< Whether the vehicle should fill in the timetable automatically.

    80

	VF_AUTOFILL_PRES_WAIT_TIME, ///< Whether non-destructive auto-fill should preserve waiting times

    81

};

    82

    83

struct VehicleRail {

    84

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

    85

	Vehicle *other_multiheaded_part;

    86

    87

	/* Cached wagon override spritegroup */

    88

	const struct SpriteGroup *cached_override;

    89

    90

	uint16 last_speed; // NOSAVE: only used in UI

    91

	uint16 crash_anim_pos;

    92

    93

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

    94

	uint32 cached_power;        ///< total power of the consist.

    95

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

    96

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

    97

	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

    98

	bool cached_tilt;           ///< train can tilt; feature provides a bonus in curves

    99

   100

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

   101

	uint32 cached_weight;     ///< total weight of the consist.

   102

	uint32 cached_veh_weight; ///< weight of the vehicle.

   103

	uint32 cached_max_te;     ///< max tractive effort of consist

   104

   105

	/**

   106

	 * Position/type of visual effect.

   107

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

   108

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

   109

	 * bit     6 = disable visual effect.

   110

	 * bit     7 = disable powered wagons.

   111

	 */

   112

	byte cached_vis_effect;

   113

	byte user_def_data;

   114

   115

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

   116

	 * 0xffff == not in train */

   117

	EngineID first_engine;

   118

   119

	uint16 flags;

   120

	TrackBitsByte track;

   121

	byte force_proceed;

   122

	RailTypeByte railtype;

   123

	RailTypes compatible_railtypes;

   124

};

   125

   126

enum VehicleRailFlags {

   127

	VRF_REVERSING         = 0,

   128

   129

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

   130

	VRF_GOINGUP           = 1,

   131

	VRF_GOINGDOWN         = 2,

   132

   133

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

   134

	VRF_POWEREDWAGON      = 3,

   135

   136

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

   137

	VRF_REVERSE_DIRECTION = 4,

   138

   139

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

   140

	VRF_NO_PATH_TO_DESTINATION = 5,

   141

   142

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

   143

	VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL = 6,

   144

   145

	/* used for vehicle var 0xFE bit 8 (toggled each time the train is reversed, accurate for first vehicle only) */

   146

	VRF_TOGGLE_REVERSE = 7,

   147

   148

	/* used to mark a train that can't get a path reservation */

   149

	VRF_TRAIN_STUCK    = 8,

   150

};

   151

   152

struct VehicleAir {

   153

	uint16 crashed_counter;

   154

	uint16 cached_max_speed;

   155

	byte pos;

   156

	byte previous_pos;

   157

	StationID targetairport;

   158

	byte state;

   159

};

   160

   161

struct VehicleRoad {

   162

	byte state;             ///< @see RoadVehicleStates

   163

	byte frame;

   164

	uint16 blocked_ctr;

   165

	byte overtaking;

   166

	byte overtaking_ctr;

   167

	uint16 crashed_ctr;

   168

	byte reverse_ctr;

   169

	struct RoadStop *slot;

   170

	byte slot_age;

   171

	EngineID first_engine;

   172

	byte cached_veh_length;

   173

   174

	RoadType roadtype;

   175

	RoadTypes compatible_roadtypes;

   176

};

   177

   178

struct VehicleEffect {

   179

	uint16 animation_state;

   180

	byte animation_substate;

   181

};

   182

   183

struct VehicleDisaster {

   184

	uint16 image_override;

   185

	VehicleID big_ufo_destroyer_target;

   186

};

   187

   188

struct VehicleShip {

   189

	TrackBitsByte state;

   190

};

   191

   192

DECLARE_OLD_POOL(Vehicle, Vehicle, 9, 125)

   193

   194

/* Some declarations of functions, so we can make them friendly */

   195

struct SaveLoad;

   196

extern const SaveLoad *GetVehicleDescription(VehicleType vt);

   197

extern void AfterLoadVehicles(bool clear_te_id);

   198

struct LoadgameState;

   199

extern bool LoadOldVehicle(LoadgameState *ls, int num);

   200

   201

struct Vehicle : PoolItem<Vehicle, VehicleID, &_Vehicle_pool>, BaseVehicle {

   202

private:

   203

	Vehicle *next;           ///< pointer to the next vehicle in the chain

   204

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

   205

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

   206

   207

	Vehicle *next_shared;     ///< pointer to the next vehicle that shares the order

   208

	Vehicle *previous_shared; ///< NOSAVE: pointer to the previous vehicle in the shared order chain

   209

	Vehicle *first_shared;    ///< NOSAVE: pointer to the first vehicle in the shared order chain

   210

public:

   211

	friend const SaveLoad *GetVehicleDescription(VehicleType vt); ///< So we can use private/protected variables in the saveload code

   212

	friend void AfterLoadVehicles(bool clear_te_id);              ///< So we can set the previous and first pointers while loading

   213

	friend bool LoadOldVehicle(LoadgameState *ls, int num);       ///< So we can set the proper next pointer while loading

   214

   215

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

   216

   217

	char *name;              ///< Name of vehicle

   218

   219

	TileIndex tile;          ///< Current tile index

   220

	TileIndex dest_tile;     ///< Heading for this tile

   221

   222

	Money profit_this_year;        ///< Profit this year << 8, low 8 bits are fract

   223

	Money profit_last_year;        ///< Profit last year << 8, low 8 bits are fract

   224

	Money value;

   225

   226

	/* Used for timetabling. */

   227

	uint32 current_order_time;     ///< How many ticks have passed since this order started.

   228

	int32 lateness_counter;        ///< How many ticks late (or early if negative) this vehicle is.

   229

   230

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

   231

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

   232

	int32 left_coord;

   233

	int32 top_coord;

   234

	int32 right_coord;

   235

	int32 bottom_coord;

   236

	Vehicle *next_hash;

   237

	Vehicle *next_new_hash;

   238

	Vehicle **old_new_hash;

   239

   240

	SpriteID colormap; // NOSAVE: cached color mapping

   241

   242

	/* Related to age and service time */

   243

	Year build_year;

   244

	Date age;     // Age in days

   245

	Date max_age; // Maximum age

   246

	Date date_of_last_service;

   247

	Date service_interval;

   248

	uint16 reliability;

   249

	uint16 reliability_spd_dec;

   250

	byte breakdown_ctr;

   251

	byte breakdown_delay;

   252

	byte breakdowns_since_last_service;

   253

	byte breakdown_chance;

   254

   255

	int32 x_pos;             // coordinates

   256

	int32 y_pos;

   257

	byte z_pos;

   258

	DirectionByte direction; // facing

   259

   260

	OwnerByte owner;         // which company owns the vehicle?

   261

	byte spritenum;          // currently displayed sprite index

   262

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

   263

	                         // 0xff == reserved for another custom sprite

   264

	uint16 cur_image;        // sprite number for this vehicle

   265

	byte x_extent;           // x-extent of vehicle bounding box

   266

	byte y_extent;           // y-extent of vehicle bounding box

   267

	byte z_extent;           // z-extent of vehicle bounding box

   268

	int8 x_offs;             // x offset for vehicle sprite

   269

	int8 y_offs;             // y offset for vehicle sprite

   270

	EngineID engine_type;

   271

   272

	TextEffectID fill_percent_te_id; // a text-effect id to a loading indicator object

   273

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

   274

   275

	uint16 max_speed;        ///< maximum speed

   276

	uint16 cur_speed;        ///< current speed

   277

	byte subspeed;           ///< fractional speed

   278

	byte acceleration;       ///< used by train & aircraft

   279

	uint32 motion_counter;

   280

	byte progress;

   281

   282

	/* for randomized variational spritegroups

   283

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

   284

	 * of corresponding spritegroups get matched */

   285

	byte random_bits;

   286

	byte waiting_triggers;   ///< triggers to be yet matched

   287

   288

	StationID last_station_visited;

   289

   290

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

   291

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

   292

	uint16 cargo_cap;        ///< total capacity

   293

	CargoList cargo;         ///< The cargo this vehicle is carrying

   294

   295

	byte day_counter;        ///< Increased by one for each day

   296

	byte tick_counter;       ///< Increased by one for each tick

   297

	byte running_ticks;      ///< Number of ticks this vehicle was not stopped this day

   298

   299

	byte vehstatus;                 ///< Status

   300

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

   301

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

   302

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

   303

   304

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

   305

   306

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

   307

   308

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

   309

	uint16 load_unload_time_rem;

   310

   311

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

   312

   313

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

   314

   315

	union {

   316

		VehicleRail rail;

   317

		VehicleAir air;

   318

		VehicleRoad road;

   319

		VehicleEffect effect;

   320

		VehicleDisaster disaster;

   321

		VehicleShip ship;

   322

	} u;

   323

   324

   325

	/**

   326

	 * Allocates a lot of vehicles.

   327

	 * @param vl pointer to an array of vehicles to get allocated. Can be NULL if the vehicles aren't needed (makes it test only)

   328

	 * @param num number of vehicles to allocate room for

   329

	 * @return true if there is room to allocate all the vehicles

   330

	 */

   331

	static bool AllocateList(Vehicle **vl, int num);

   332

   333

	/** Create a new vehicle */

   334

	Vehicle();

   335

   336

	/** Destroy all stuff that (still) needs the virtual functions to work properly */

   337

	void PreDestructor();

   338

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

   339

	virtual ~Vehicle();

   340

   341

	void BeginLoading();

   342

	void LeaveStation();

   343

   344

	/**

   345

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

   346

	 * orders and does nothing in all other cases.

   347

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

   348

	 */

   349

	void HandleLoading(bool mode = false);

   350

   351

	/**

   352

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

   353

	 * @return the string representation.

   354

	 */

   355

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

   356

   357

	/**

   358

	 * Marks the vehicles to be redrawn and updates cached variables

   359

	 *

   360

	 * This method marks the area of the vehicle on the screen as dirty.

   361

	 * It can be use to repaint the vehicle.

   362

	 *

   363

	 * @ingroup dirty

   364

	 */

   365

	virtual void MarkDirty() {}

   366

   367

	/**

   368

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

   369

	 * for this vehicle.

   370

	 * @param direction the direction the vehicle is facing

   371

	 */

   372

	virtual void UpdateDeltaXY(Direction direction) {}

   373

   374

	/**

   375

	 * Sets the expense type associated to this vehicle type

   376

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

   377

	 */

   378

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

   379

   380

	/**

   381

	 * Play the sound associated with leaving the station

   382

	 */

   383

	virtual void PlayLeaveStationSound() const {}

   384

   385

	/**

   386

	 * Whether this is the primary vehicle in the chain.

   387

	 */

   388

	virtual bool IsPrimaryVehicle() const { return false; }

   389

   390

	/**

   391

	 * Gets the sprite to show for the given direction

   392

	 * @param direction the direction the vehicle is facing

   393

	 * @return the sprite for the given vehicle in the given direction

   394

	 */

   395

	virtual SpriteID GetImage(Direction direction) const { return 0; }

   396

   397

	/**

   398

	 * Gets the speed in mph that can be sent into SetDParam for string processing.

   399

	 * @return the vehicle's speed

   400

	 */

   401

	virtual int GetDisplaySpeed() const { return 0; }

   402

   403

	/**

   404

	 * Gets the maximum speed in mph that can be sent into SetDParam for string processing.

   405

	 * @return the vehicle's maximum speed

   406

	 */

   407

	virtual int GetDisplayMaxSpeed() const { return 0; }

   408

   409

	/**

   410

	 * Gets the running cost of a vehicle

   411

	 * @return the vehicle's running cost

   412

	 */

   413

	virtual Money GetRunningCost() const { return 0; }

   414

   415

	/**

   416

	 * Check whether the vehicle is in the depot.

   417

	 * @return true if and only if the vehicle is in the depot.

   418

	 */

   419

	virtual bool IsInDepot() const { return false; }

   420

   421

	/**

   422

	 * Check whether the vehicle is in the depot *and* stopped.

   423

	 * @return true if and only if the vehicle is in the depot and stopped.

   424

	 */

   425

	virtual bool IsStoppedInDepot() const { return this->IsInDepot() && (this->vehstatus & VS_STOPPED) != 0; }

   426

   427

	/**

   428

	 * Calls the tick handler of the vehicle

   429

	 */

   430

	virtual void Tick() {};

   431

   432

	/**

   433

	 * Calls the new day handler of the vehicle

   434

	 */

   435

	virtual void OnNewDay() {};

   436

   437

	/**

   438

	 * Gets the running cost of a vehicle  that can be sent into SetDParam for string processing.

   439

	 * @return the vehicle's running cost

   440

	 */

   441

	Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }

   442

   443

	/**

   444

	 * Gets the profit vehicle had this year. It can be sent into SetDParam for string processing.

   445

	 * @return the vehicle's profit this year

   446

	 */

   447

	Money GetDisplayProfitThisYear() const { return (this->profit_this_year >> 8); }

   448

   449

	/**

   450

	 * Gets the profit vehicle had last year. It can be sent into SetDParam for string processing.

   451

	 * @return the vehicle's profit last year

   452

	 */

   453

	Money GetDisplayProfitLastYear() const { return (this->profit_last_year >> 8); }

   454

   455

	/**

   456

	 * Set the next vehicle of this vehicle.

   457

	 * @param next the next vehicle. NULL removes the next vehicle.

   458

	 */

   459

	void SetNext(Vehicle *next);

   460

   461

	/**

   462

	 * Get the next vehicle of this vehicle.

   463

	 * @note articulated parts are also counted as vehicles.

   464

	 * @return the next vehicle or NULL when there isn't a next vehicle.

   465

	 */

   466

	inline Vehicle *Next() const { return this->next; }

   467

   468

	/**

   469

	 * Get the previous vehicle of this vehicle.

   470

	 * @note articulated parts are also counted as vehicles.

   471

	 * @return the previous vehicle or NULL when there isn't a previous vehicle.

   472

	 */

   473

	inline Vehicle *Previous() const { return this->previous; }

   474

   475

	/**

   476

	 * Get the first vehicle of this vehicle chain.

   477

	 * @return the first vehicle of the chain.

   478

	 */

   479

	inline Vehicle *First() const { return this->first; }

   480

   481

   482

	/**

   483

	 * Adds this vehicle to a shared vehicle chain.

   484

	 * @param shared_chain a vehicle of the chain with shared vehicles.

   485

	 * @pre !this->IsOrderListShared()

   486

	 */

   487

	void AddToShared(Vehicle *shared_chain);

   488

   489

	/**

   490

	 * Removes the vehicle from the shared order list.

   491

	 */

   492

	void RemoveFromShared();

   493

   494

	/**

   495

	 * Get the next vehicle of this vehicle.

   496

	 * @note articulated parts are also counted as vehicles.

   497

	 * @return the next vehicle or NULL when there isn't a next vehicle.

   498

	 */

   499

	inline Vehicle *NextShared() const { return this->next_shared; }

   500

   501

	/**

   502

	 * Get the first vehicle of this vehicle chain.

   503

	 * @return the first vehicle of the chain.

   504

	 */

   505

	inline Vehicle *FirstShared() const { return this->first_shared; }

   506

   507

	/**

   508

	 * Check if we share our orders with another vehicle.

   509

	 * @return true if there are other vehicles sharing the same order

   510

	 */

   511

	inline bool IsOrderListShared() const { return this->previous_shared != NULL || this->next_shared != NULL; };

   512

   513

	/**