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"

    11

#include "road.h"

    12

#include "cargopacket.h"

    13

#include "texteff.hpp"

    14

    15

/** The returned bits of VehicleEnterTile. */

    16

enum VehicleEnterTileStatus {

    17

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

    18

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

    19

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

    20

    21

	/**

    22

	 * Shift the VehicleEnterTileStatus this many bits

    23

	 * to the right to get the station ID when

    24

	 * VETS_ENTERED_STATION is set

    25

	 */

    26

	VETS_STATION_ID_OFFSET = 8,

    27

    28

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

    29

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

    30

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

    31

	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)

    32

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

    33

};

    34

    35

/** Road vehicle states */

    36

enum RoadVehicleStates {

    37

	/*

    38

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

    39

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

    40

	 * track direction of the entry to the road stop.

    41

	 * As the entry direction will always be a diagonal

    42

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

    43

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

    44

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

    45

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

    46

	 * is stopping at this road stop.

    47

	 */

    48

    49

	/* Numeric values */

    50

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

    51

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

    52

    53

	/* Bit numbers */

    54

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

    55

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

    56

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

    57

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

    58

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

    59

    60

	/* Bit sets of the above specified bits */

    61

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

    62

	RVSB_IN_ROAD_STOP_END        = RVSB_IN_ROAD_STOP + TRACKDIR_END,

    63

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

    64

	RVSB_IN_DT_ROAD_STOP_END     = RVSB_IN_DT_ROAD_STOP + TRACKDIR_END,

    65

    66

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

    67

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

    68

};

    69

    70

enum VehicleType {

    71

	VEH_TRAIN,

    72

	VEH_ROAD,

    73

	VEH_SHIP,

    74

	VEH_AIRCRAFT,

    75

	VEH_SPECIAL,

    76

	VEH_DISASTER,

    77

	VEH_END,

    78

	VEH_INVALID = 0xFF,

    79

};

    80

DECLARE_POSTFIX_INCREMENT(VehicleType);

    81

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

    82

typedef TinyEnumT<VehicleType> VehicleTypeByte;

    83

    84

enum VehStatus {

    85

	VS_HIDDEN          = 0x01,

    86

	VS_STOPPED         = 0x02,

    87

	VS_UNCLICKABLE     = 0x04,

    88

	VS_DEFPAL          = 0x08,

    89

	VS_TRAIN_SLOWING   = 0x10,

    90

	VS_SHADOW          = 0x20,

    91

	VS_AIRCRAFT_BROKEN = 0x40,

    92

	VS_CRASHED         = 0x80,

    93

};

    94

    95

enum VehicleFlags {

    96

	VF_LOADING_FINISHED,

    97

	VF_CARGO_UNLOADING,

    98

	VF_BUILT_AS_PROTOTYPE,

    99

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

   100

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

   101

};

   102

   103

/* Effect vehicle types */

   104

enum EffectVehicle {

   105

	EV_CHIMNEY_SMOKE   = 0,

   106

	EV_STEAM_SMOKE     = 1,

   107

	EV_DIESEL_SMOKE    = 2,

   108

	EV_ELECTRIC_SPARK  = 3,

   109

	EV_SMOKE           = 4,

   110

	EV_EXPLOSION_LARGE = 5,

   111

	EV_BREAKDOWN_SMOKE = 6,

   112

	EV_EXPLOSION_SMALL = 7,

   113

	EV_BULLDOZER       = 8,

   114

	EV_BUBBLE          = 9

   115

};

   116

   117

struct VehicleRail {

   118

	uint16 last_speed; // NOSAVE: only used in UI

   119

	uint16 crash_anim_pos;

   120

   121

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

   122

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

   123

	uint32 cached_power;      // total power of the consist.

   124

	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

   125

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

   126

   127

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

   128

	uint32 cached_weight;     // total weight of the consist.

   129

	uint32 cached_veh_weight; // weight of the vehicle.

   130

	uint32 cached_max_te;     // max tractive effort of consist

   131

	/**

   132

	 * Position/type of visual effect.

   133

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

   134

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

   135

	 * bit     6 = disable visual effect.

   136

	 * bit     7 = disable powered wagons.

   137

	 */

   138

	byte cached_vis_effect;

   139

   140

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

   141

	 * 0xffff == not in train */

   142

	EngineID first_engine;

   143

   144

	TrackBitsByte track;

   145

	byte force_proceed;

   146

	RailTypeByte railtype;

   147

	RailTypeMask compatible_railtypes;

   148

   149

	byte flags;

   150

   151

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

   152

	Vehicle *other_multiheaded_part;

   153

   154

	/* Cached wagon override spritegroup */

   155

	const struct SpriteGroup *cached_override;

   156

};

   157

   158

enum {

   159

	VRF_REVERSING         = 0,

   160

   161

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

   162

	VRF_GOINGUP           = 1,

   163

	VRF_GOINGDOWN         = 2,

   164

   165

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

   166

	VRF_POWEREDWAGON      = 3,

   167

   168

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

   169

	VRF_REVERSE_DIRECTION = 4,

   170

   171

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

   172

	VRF_NO_PATH_TO_DESTINATION = 5,

   173

   174

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

   175

	VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL = 6,

   176

};

   177

   178

struct VehicleAir {

   179

	uint16 crashed_counter;

   180

	uint16 cached_max_speed;

   181

	byte pos;

   182

	byte previous_pos;

   183

	StationID targetairport;

   184

	byte state;

   185

};

   186

   187

struct VehicleRoad {

   188

	byte state;             ///< @see RoadVehicleStates

   189

	byte frame;

   190

	uint16 blocked_ctr;

   191

	byte overtaking;

   192

	byte overtaking_ctr;

   193

	uint16 crashed_ctr;

   194

	byte reverse_ctr;

   195

	struct RoadStop *slot;

   196

	byte slot_age;

   197

	EngineID first_engine;

   198

	byte cached_veh_length;

   199

   200

	RoadType roadtype;

   201

	RoadTypes compatible_roadtypes;

   202

};

   203

   204

struct VehicleSpecial {

   205

	uint16 animation_state;

   206

	byte animation_substate;

   207

};

   208

   209

struct VehicleDisaster {

   210

	uint16 image_override;

   211

	VehicleID big_ufo_destroyer_target;

   212

};

   213

   214

struct VehicleShip {

   215

	TrackBitsByte state;

   216

};

   217

   218

struct Vehicle;

   219

DECLARE_OLD_POOL(Vehicle, Vehicle, 9, 125)

   220

   221

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

   222

struct SaveLoad;

   223

extern const SaveLoad *GetVehicleDescription(VehicleType vt);

   224

extern void AfterLoadVehicles();

   225

struct LoadgameState;

   226

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

   227

   228

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

   229

	VehicleTypeByte type;    ///< Type of vehicle

   230

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

   231

   232

private:

   233

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

   234

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

   235

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

   236

public:

   237

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

   238

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

   239

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

   240

   241

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

   242

   243

	StringID string_id;      // Displayed string

   244

   245

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

   246

	PlayerByte owner;        // which player owns the vehicle?

   247

   248

	TileIndex tile;          // Current tile index

   249

	TileIndex dest_tile;     // Heading for this tile

   250

   251

	int32 x_pos;             // coordinates

   252

	int32 y_pos;

   253

	byte z_pos;

   254

	DirectionByte direction; // facing

   255

   256

	byte spritenum;          // currently displayed sprite index

   257

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

   258

	                         // 0xff == reserved for another custom sprite

   259

	uint16 cur_image;        // sprite number for this vehicle

   260

	byte sprite_width;       // width of vehicle sprite

   261

	byte sprite_height;      // height of vehicle sprite

   262

	byte z_height;           // z-height of vehicle sprite

   263

	int8 x_offs;             // x offset for vehicle sprite

   264

	int8 y_offs;             // y offset for vehicle sprite

   265

	EngineID engine_type;

   266

   267

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

   268

   269

	/* for randomized variational spritegroups

   270

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

   271

	 * of corresponding spritegroups get matched */

   272

	byte random_bits;

   273

	byte waiting_triggers;   // triggers to be yet matched

   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

	byte progress;

   280

	uint32 motion_counter;

   281

   282

	byte vehstatus;          // Status

   283

	StationID last_station_visited;

   284

   285

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

   286

	uint16 cargo_cap;        // total capacity

   287

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

   288

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

   289

   290

   291

	byte day_counter;        // increased by one for each day

   292

	byte tick_counter;       // increased by one for each tick

   293

   294

	/* Begin Order-stuff */

   295

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

   296

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

   297

   298

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

   299

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

   300

   301

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

   302

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

   303

	/* End Order-stuff */

   304

   305

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

   306

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

   307

	int32 left_coord;

   308

	int32 top_coord;

   309

	int32 right_coord;

   310

	int32 bottom_coord;

   311

	Vehicle *next_hash;

   312

	Vehicle *next_new_hash;

   313

	Vehicle **old_new_hash;

   314

   315

	/* Related to age and service time */

   316

	Date age;     // Age in days

   317

	Date max_age; // Maximum age

   318

	Date date_of_last_service;

   319

	Date service_interval;

   320

	uint16 reliability;

   321

	uint16 reliability_spd_dec;

   322

	byte breakdown_ctr;

   323

	byte breakdown_delay;

   324

	byte breakdowns_since_last_service;

   325

	byte breakdown_chance;

   326

	Year build_year;

   327

   328

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

   329

   330

	uint16 load_unload_time_rem;

   331

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

   332

   333

	Money profit_this_year;

   334

	Money profit_last_year;

   335

	Money value;

   336

   337

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

   338

   339

	/* Used for timetabling. */

   340

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

   341

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

   342

   343

	union {

   344

		VehicleRail rail;

   345

		VehicleAir air;

   346

		VehicleRoad road;

   347

		VehicleSpecial special;

   348

		VehicleDisaster disaster;

   349

		VehicleShip ship;

   350

	} u;

   351

   352

   353

	/**

   354

	 * Allocates a lot of vehicles.

   355

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

   356

	 * @param num number of vehicles to allocate room for

   357

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

   358

	 */

   359

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

   360

   361

	/** Create a new vehicle */

   362

	Vehicle();

   363

   364

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

   365

	void PreDestructor();

   366

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

   367

	virtual ~Vehicle();

   368

   369

	void BeginLoading();

   370

	void LeaveStation();

   371

   372

	/**

   373

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

   374

	 * orders and does nothing in all other cases.

   375

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

   376

	 */

   377

	void HandleLoading(bool mode = false);

   378

   379

	/**

   380

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

   381

	 * @return the string representation.

   382

	 */

   383

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

   384

   385

	/**

   386

	 * Marks the vehicles to be redrawn and updates cached variables

   392

	 */

   393

	virtual void MarkDirty() {}

   394

   395

	/**

   396

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

   397

	 * for this vehicle.

   398

	 * @param direction the direction the vehicle is facing

   399

	 */

   400

	virtual void UpdateDeltaXY(Direction direction) {}

   401

   402

	/**

   403

	 * Sets the expense type associated to this vehicle type

   404

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

   405

	 */

   406

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

   407

   408

	/**

   409

	 * Invalidates the vehicle list window of this type of vehicle

   410

	 */

   411

	virtual WindowClass GetVehicleListWindowClass() const { return WC_NONE; }

   412

   413

	/**

   414

	 * Play the sound associated with leaving the station

   415

	 */

   416

	virtual void PlayLeaveStationSound() const {}

   417

   418

	/**

   419

	 * Whether this is the primary vehicle in the chain.

   420

	 */

   421

	virtual bool IsPrimaryVehicle() const { return false; }

   422

   423

	/**

   424

	 * Whether this vehicle understands the concept of a front engine, so

   425

	 * basically, if GetFirstVehicleInChain() can be called for it.

   426

	 */

   427

	virtual bool HasFront() const { return false; }

   428

   429

	/**

   430

	 * Gets the sprite to show for the given direction

   431

	 * @param direction the direction the vehicle is facing

   432

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

   433

	 */

   434

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

   435

   436

	/**

   437

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

   438

	 * @return the vehicle's speed

   439

	 */

   440

	virtual int GetDisplaySpeed() const { return 0; }

   441

   442

	/**

   443

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

   444

	 * @return the vehicle's maximum speed

   445

	 */

   446

	virtual int GetDisplayMaxSpeed() const { return 0; }

   447

   448

	/**

   449

	 * Gets the running cost of a vehicle

   450

	 * @return the vehicle's running cost

   451

	 */

   452

	virtual Money GetRunningCost() const { return 0; }

   453

   454

	/**

   455

	 * Check whether the vehicle is in the depot.

   456

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

   457

	 */

   458

	virtual bool IsInDepot() const { return false; }

   459

   460

	/**

   461

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

   462

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

   463

	 */

   464

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

   465

   466

	/**

   467

	 * Calls the tick handler of the vehicle

   468

	 */

   469

	virtual void Tick() {};

   470

   471

	/**

   472

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

   473

	 * @return the vehicle's running cost

   474

	 */

   475

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

   476

   477

	/**

   478

	 * Is this vehicle a valid vehicle?

   479

	 * @return true if and only if the vehicle is valid.

   480

	 */

   481

	inline bool IsValid() const { return this->type != VEH_INVALID; }

   482

   483

	/**

   484

	 * Set the next vehicle of this vehicle.

   485

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

   486

	 */