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

uint CountArticulatedParts(EngineID engine_type, bool purchase_window)

    15

{

    16

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

    17

    18

	Vehicle *v = NULL;;

    19

	if (!purchase_window) {

    20

		v = new InvalidVehicle();

    21

		v->engine_type = engine_type;

    22

	}

    23

    24

	uint i;

    25

	for (i = 1; i < MAX_UVALUE(EngineID); i++) {

    26

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

    27

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

    28

	}

    29

    30

	delete v;

    31

    32

	return i - 1;

    33

}

    34

    35

    36

uint16 *GetCapacityOfArticulatedParts(EngineID engine, VehicleType type)

    37

{

    38

	static uint16 capacity[NUM_CARGO];

    39

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

    40

    41

	if (type == VEH_TRAIN) {

    42

		const RailVehicleInfo *rvi = RailVehInfo(engine);

    44

		if (rvi->railveh_type == RAILVEH_MULTIHEAD) capacity[rvi->cargo_type] += rvi->capacity;

    45

	} else if (type == VEH_ROAD) {

    46

		const RoadVehicleInfo *rvi = RoadVehInfo(engine);

    48

	}

    49

    50

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

    51

    52

	for (uint i = 1; i < MAX_UVALUE(EngineID); i++) {

    53

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

    54

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

    55

    56

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

    57

    58

		if (type == VEH_TRAIN) {

    59

			const RailVehicleInfo *rvi = RailVehInfo(artic_engine);

    60

			capacity[rvi->cargo_type] += GetEngineProperty(artic_engine, 0x14, rvi->capacity);

    61

		} else if (type == VEH_ROAD) {

    62

			const RoadVehicleInfo *rvi = RoadVehInfo(artic_engine);

    63

			capacity[rvi->cargo_type] += GetEngineProperty(artic_engine, 0x0F, rvi->capacity);

    64

		}

    65

	}

    66

    67

	return capacity;

    68

}

    69

    70

    71

void AddArticulatedParts(Vehicle **vl, VehicleType type)

    72

{

    73

	const Vehicle *v = vl[0];

    74

	Vehicle *u = vl[0];

    75

    76

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

    77

    78

	for (uint i = 1; i < MAX_UVALUE(EngineID); i++) {

    79

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

    80

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

    81

    82

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

    83

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

    84

		u->SetNext(vl[i]);

    85

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

    86

    87

		Vehicle *previous = u;

    88

		u = u->Next();

    89

    90

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

    91

		bool flip_image = HasBit(callback, 7);

    92

    93

		/* get common values from first engine */

    94

		u->direction = v->direction;

    95

		u->owner = v->owner;

    96

		u->tile = v->tile;

    97

		u->x_pos = v->x_pos;

    98

		u->y_pos = v->y_pos;

    99

		u->z_pos = v->z_pos;

   100

		u->build_year = v->build_year;

   101

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

   102

   103

		u->cargo_subtype = 0;

   104

		u->max_speed = 0;

   105

		u->max_age = 0;

   106

		u->engine_type = engine_type;

   107

		u->value = 0;

   108

		u->subtype = 0;

   109

		u->cur_image = 0xAC2;

   110

		u->random_bits = VehicleRandomBits();

   111

   112

		switch (type) {

   113

			default: NOT_REACHED();

   114

   115

			case VEH_TRAIN: {

   116

				const RailVehicleInfo *rvi_artic = RailVehInfo(engine_type);

   117

   118

				u = new (u) Train();

   119

				previous->SetNext(u);

   120

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

   121

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

   122

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

   123

   124

				u->spritenum = rvi_artic->image_index;

   125

				u->cargo_type = rvi_artic->cargo_type;

   126

				u->cargo_cap = rvi_artic->capacity;

   127

   128

				SetArticulatedPart(u);

   129

			} break;

   130

   131

			case VEH_ROAD: {

   132

				const RoadVehicleInfo *rvi_artic = RoadVehInfo(engine_type);

   133

   134

				u = new (u) RoadVehicle();

   135

				previous->SetNext(u);

   136

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

   137

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

   138

				u->u.road.state = RVSB_IN_DEPOT;

   139

   140

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

   141

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

   142

   143

				u->spritenum = rvi_artic->image_index;

   144

				u->cargo_type = rvi_artic->cargo_type;

   145

				u->cargo_cap = rvi_artic->capacity;

   146

   147

				SetRoadVehArticPart(u);

   148

			} break;

   149

		}

   150

   151

		if (flip_image) u->spritenum++;

   152

   153

		VehiclePositionChanged(u);

   154

	}

   155

}