1

/* $Id$ */

     2

     3

/** @file articulated_vehicles.cpp Implementation of articulated vehicles. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "articulated_vehicles.h"

     8

#include "train.h"

     9

#include "roadveh.h"

    10

#include "newgrf_callbacks.h"

    11

#include "newgrf_engine.h"

    12

#include "vehicle_func.h"

    13

    14

static const uint MAX_ARTICULATED_PARTS = 100; ///< Maximum of articulated parts per vehicle, i.e. when to abort calling the articulated vehicle callback.

    15

    16

uint CountArticulatedParts(EngineID engine_type, bool purchase_window)

    17

{

    18

	if (!HasBit(EngInfo(engine_type)->callbackmask, CBM_VEHICLE_ARTIC_ENGINE)) return 0;

    19

    20

	Vehicle *v = NULL;;

    21

	if (!purchase_window) {

    22

		v = new InvalidVehicle();

    23

		v->engine_type = engine_type;

    24

	}

    25

    26

	uint i;

    27

	for (i = 1; i < MAX_ARTICULATED_PARTS; i++) {

    28

		uint16 callback = GetVehicleCallback(CBID_VEHICLE_ARTIC_ENGINE, i, 0, engine_type, v);

    29

		if (callback == CALLBACK_FAILED || GB(callback, 0, 8) == 0xFF) break;

    30

	}

    31

    32

	delete v;

    33

    34

	return i - 1;

    35

}

    36

    37

    38

/**

    39

 * Returns the default (non-refitted) capacity of a specific EngineID.

    40

 * @param engine the EngineID of iterest

    41

 * @param type the type of the engine

    42

 * @param cargo_type returns the default cargo type, if needed

    43

 * @return capacity

    44

 */

    45

static inline uint16 GetVehicleDefaultCapacity(EngineID engine, VehicleType type, CargoID *cargo_type)

    46

{

    47

	switch (type) {

    48

		case VEH_TRAIN: {

    49

			const RailVehicleInfo *rvi = RailVehInfo(engine);

    50

			if (cargo_type != NULL) *cargo_type = rvi->cargo_type;

    51

			return GetEngineProperty(engine, 0x14, rvi->capacity) + (rvi->railveh_type == RAILVEH_MULTIHEAD ? rvi->capacity : 0);

    52

		}

    53

    54

		case VEH_ROAD: {

    55

			const RoadVehicleInfo *rvi = RoadVehInfo(engine);

    56

			if (cargo_type != NULL) *cargo_type = rvi->cargo_type;

    57

			return GetEngineProperty(engine, 0x0F, rvi->capacity);

    58

		}

    59

    60

		case VEH_SHIP: {

    61

			const ShipVehicleInfo *svi = ShipVehInfo(engine);

    62

			if (cargo_type != NULL) *cargo_type = svi->cargo_type;

    63

			return GetEngineProperty(engine, 0x0D, svi->capacity);

    64

		}

    65

    66

		case VEH_AIRCRAFT: {

    67

			const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

    68

			if (cargo_type != NULL) *cargo_type = CT_PASSENGERS;

    69

			return avi->passenger_capacity;

    70

		}

    71

    72

		default: NOT_REACHED();

    73

	}

    74

    75

}

    76

    77

/**

    78

 * Returns all cargos a vehicle can carry.

    79

 * @param engine the EngineID of iterest

    80

 * @param type the type of the engine

    81

 * @param include_initial_cargo_type if true the default cargo type of the vehicle is included; if false only the refit_mask

    82

 * @return bit set of CargoIDs

    83

 */

    84

static inline uint32 GetAvailableVehicleCargoTypes(EngineID engine, VehicleType type, bool include_initial_cargo_type)

    85

{

    86

	uint32 cargos = 0;

    87

	CargoID initial_cargo_type;

    88

    89

	if (GetVehicleDefaultCapacity(engine, type, &initial_cargo_type) > 0) {

    90

		if (type != VEH_SHIP || ShipVehInfo(engine)->refittable) {

    91

			const EngineInfo *ei = EngInfo(engine);

    92

			cargos = ei->refit_mask;

    93

		}

    94

		if (include_initial_cargo_type && initial_cargo_type < NUM_CARGO) SetBit(cargos, initial_cargo_type);

    95

	}

    96

    97

	return cargos;

    98

}

    99

   100

uint16 *GetCapacityOfArticulatedParts(EngineID engine, VehicleType type)

   101

{

   102

	static uint16 capacity[NUM_CARGO];

   103

	memset(capacity, 0, sizeof(capacity));

   104

   105

	CargoID cargo_type;

   106

	uint16 cargo_capacity = GetVehicleDefaultCapacity(engine, type, &cargo_type);

   107

	if (cargo_type < NUM_CARGO) capacity[cargo_type] = cargo_capacity;

   108

   109

	if (type != VEH_TRAIN && type != VEH_ROAD) return capacity;

   110

   111

	if (!HasBit(EngInfo(engine)->callbackmask, CBM_VEHICLE_ARTIC_ENGINE)) return capacity;

   112

   113

	for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) {

   114

		uint16 callback = GetVehicleCallback(CBID_VEHICLE_ARTIC_ENGINE, i, 0, engine, NULL);

   115

		if (callback == CALLBACK_FAILED || GB(callback, 0, 8) == 0xFF) break;

   116

   117

		EngineID artic_engine = GetNewEngineID(GetEngineGRF(engine), type, GB(callback, 0, 7));

   118

   119

		cargo_capacity = GetVehicleDefaultCapacity(artic_engine, type, &cargo_type);

   120

		if (cargo_type < NUM_CARGO) capacity[cargo_type] += cargo_capacity;

   121

	}

   122

   123

	return capacity;

   124

}

   125

   126

/**

   127

 * Ors the refit_masks of all articulated parts.

   128

 * Note: Vehicles with a default capacity of zero are ignored.

   129

 * @param engine the first part

   130

 * @param type the vehicle type

   131

 * @param include_initial_cargo_type if true the default cargo type of the vehicle is included; if false only the refit_mask

   132

 * @return bit mask of CargoIDs which are a refit option for at least one articulated part

   133

 */

   134

uint32 GetUnionOfArticulatedRefitMasks(EngineID engine, VehicleType type, bool include_initial_cargo_type)

   135

{

   136

	uint32 cargos = GetAvailableVehicleCargoTypes(engine, type, include_initial_cargo_type);

   137

   138

	if (type != VEH_TRAIN && type != VEH_ROAD) return cargos;

   139

   140

	if (!HasBit(EngInfo(engine)->callbackmask, CBM_VEHICLE_ARTIC_ENGINE)) return cargos;

   141

   142

	for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) {

   143

		uint16 callback = GetVehicleCallback(CBID_VEHICLE_ARTIC_ENGINE, i, 0, engine, NULL);

   144

		if (callback == CALLBACK_FAILED || GB(callback, 0, 8) == 0xFF) break;

   145

   146

		EngineID artic_engine = GetNewEngineID(GetEngineGRF(engine), type, GB(callback, 0, 7));

   147

		cargos |= GetAvailableVehicleCargoTypes(artic_engine, type, include_initial_cargo_type);

   148

	}

   149

   150

	return cargos;

   151

}

   152

   153

/**

   154

 * Ands the refit_masks of all articulated parts.

   155

 * Note: Vehicles with a default capacity of zero are ignored.

   156

 * @param engine the first part

   157

 * @param type the vehicle type

   158

 * @param include_initial_cargo_type if true the default cargo type of the vehicle is included; if false only the refit_mask

   159

 * @return bit mask of CargoIDs which are a refit option for every articulated part (with default capacity > 0)

   160

 */

   161

uint32 GetIntersectionOfArticulatedRefitMasks(EngineID engine, VehicleType type, bool include_initial_cargo_type)

   162

{

   163

	uint32 cargos = UINT32_MAX;

   164

   165

	uint32 veh_cargos = GetAvailableVehicleCargoTypes(engine, type, include_initial_cargo_type);

   166

	if (veh_cargos != 0) cargos &= veh_cargos;

   167

   168

	if (type != VEH_TRAIN && type != VEH_ROAD) return cargos;

   169

   170

	if (!HasBit(EngInfo(engine)->callbackmask, CBM_VEHICLE_ARTIC_ENGINE)) return cargos;

   171

   172

	for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) {

   173

		uint16 callback = GetVehicleCallback(CBID_VEHICLE_ARTIC_ENGINE, i, 0, engine, NULL);

   174

		if (callback == CALLBACK_FAILED || GB(callback, 0, 8) == 0xFF) break;

   175

   176

		EngineID artic_engine = GetNewEngineID(GetEngineGRF(engine), type, GB(callback, 0, 7));

   177

		veh_cargos = GetAvailableVehicleCargoTypes(artic_engine, type, include_initial_cargo_type);

   178

		if (veh_cargos != 0) cargos &= veh_cargos;

   179

	}

   180

   181

	return cargos;

   182

}

   183

   184

   185

/**

   186

 * Tests if all parts of an articulated vehicle are refitted to the same cargo.

   187

 * Note: Vehicles not carrying anything are ignored

   188

 * @param v the first vehicle in the chain

   189

 * @param cargo_type returns the common CargoID if needed. (CT_INVALID if no part is carrying something or they are carrying different things)

   190

 * @return true if some parts are carrying different cargos, false if all parts are carrying the same (nothing is also the same)

   191

 */

   192

bool IsArticulatedVehicleCarryingDifferentCargos(const Vehicle *v, CargoID *cargo_type)

   193

{

   194

	CargoID first_cargo = CT_INVALID;

   195

   196

	do {

   197

		if (v->cargo_cap > 0 && v->cargo_type != CT_INVALID) {

   198

			if (first_cargo == CT_INVALID) first_cargo = v->cargo_type;

   199

			if (first_cargo != v->cargo_type) {

   200

				if (cargo_type != NULL) *cargo_type = CT_INVALID;

   201

				return true;

   202

			}

   203

		}

   204

   205

		switch (v->type) {

   206

			case VEH_TRAIN:

   207

				v = (EngineHasArticPart(v) ? GetNextArticPart(v) : NULL);

   208

				break;

   209

   210

			case VEH_ROAD:

   211

				v = (RoadVehHasArticPart(v) ? v->Next() : NULL);

   212

				break;

   213

   214

			default:

   215

				v = NULL;

   216

				break;

   217

		}

   218

	} while (v != NULL);

   219

   220

	if (cargo_type != NULL) *cargo_type = first_cargo;

   221

	return false;

   222

}

   223

   224

   225

void AddArticulatedParts(Vehicle **vl, VehicleType type)

   226

{

   227

	const Vehicle *v = vl[0];

   228

	Vehicle *u = vl[0];

   229

   230

	if (!HasBit(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_ARTIC_ENGINE)) return;

   231

   232

	for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) {

   233

		uint16 callback = GetVehicleCallback(CBID_VEHICLE_ARTIC_ENGINE, i, 0, v->engine_type, v);

   234

		if (callback == CALLBACK_FAILED || GB(callback, 0, 8) == 0xFF) return;

   235

   236

		/* Attempt to use pre-allocated vehicles until they run out. This can happen

   237

		 * if the callback returns different values depending on the cargo type. */

   238

		u->SetNext(vl[i]);

   239

		if (u->Next() == NULL) return;

   240

   241

		Vehicle *previous = u;

   242

		u = u->Next();

   243

   244

		EngineID engine_type = GetNewEngineID(GetEngineGRF(v->engine_type), type, GB(callback, 0, 7));

   245

		bool flip_image = HasBit(callback, 7);

   246

   247

		/* get common values from first engine */

   248

		u->direction = v->direction;

   249

		u->owner = v->owner;

   250

		u->tile = v->tile;

   251

		u->x_pos = v->x_pos;

   252

		u->y_pos = v->y_pos;

   253

		u->z_pos = v->z_pos;

   254

		u->build_year = v->build_year;

   255

		u->vehstatus = v->vehstatus & ~VS_STOPPED;

   256

   257

		u->cargo_subtype = 0;

   258

		u->max_speed = 0;

   259

		u->max_age = 0;

   260

		u->engine_type = engine_type;

   261

		u->value = 0;

   262

		u->subtype = 0;

   263

		u->cur_image = 0xAC2;

   264

		u->random_bits = VehicleRandomBits();

   265

   266

		switch (type) {

   267

			default: NOT_REACHED();

   268

   269

			case VEH_TRAIN: {

   270

				const RailVehicleInfo *rvi_artic = RailVehInfo(engine_type);

   271

   272

				u = new (u) Train();

   273

				previous->SetNext(u);

   274

				u->u.rail.track = v->u.rail.track;

   275

				u->u.rail.railtype = v->u.rail.railtype;

   276

				u->u.rail.first_engine = v->engine_type;

   277

   278

				u->spritenum = rvi_artic->image_index;

   279

				u->cargo_type = rvi_artic->cargo_type;

   280

				u->cargo_cap = rvi_artic->capacity;

   281

   282

				SetArticulatedPart(u);

   283

			} break;

   284

   285

			case VEH_ROAD: {

   286

				const RoadVehicleInfo *rvi_artic = RoadVehInfo(engine_type);

   287

   288

				u = new (u) RoadVehicle();

   289

				previous->SetNext(u);

   290

				u->u.road.first_engine = v->engine_type;

   291

				u->u.road.cached_veh_length = GetRoadVehLength(u);

   292

				u->u.road.state = RVSB_IN_DEPOT;

   293

   294

				u->u.road.roadtype = v->u.road.roadtype;

   295

				u->u.road.compatible_roadtypes = v->u.road.compatible_roadtypes;

   296

   297

				u->spritenum = rvi_artic->image_index;

   298

				u->cargo_type = rvi_artic->cargo_type;

   299

				u->cargo_cap = rvi_artic->capacity;

   300

   301

				SetRoadVehArticPart(u);

   302

			} break;

   303

		}

   304

   305

		if (flip_image) u->spritenum++;

   306

   307

		VehiclePositionChanged(u);

   308

	}

   309

}