1

/* $Id$ */

     2

     3

/** @file articulated_vehicles.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "command.h"

     9

#include "vehicle.h"

    10

#include "articulated_vehicles.h"

    11

#include "engine.h"

    12

#include "train.h"

    13

#include "roadveh.h"

    14

#include "newgrf_callbacks.h"

    15

#include "newgrf_engine.h"

    16

    17

    18

uint CountArticulatedParts(EngineID engine_type, bool purchase_window)

    19

{

    21

    22

	Vehicle *v = NULL;;

    23

	if (!purchase_window) {

    24

		v = new InvalidVehicle();

    25

		v->engine_type = engine_type;

    26

	}

    27

    28

	uint i;

    29

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

    30

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

    31

		if (callback == CALLBACK_FAILED || callback == 0xFF) break;

    32

	}

    33

    34

	delete v;

    35

    36

	return i - 1;

    37

}

    38

    39

void AddArticulatedParts(Vehicle **vl, VehicleType type)

    40

{

    41

	const Vehicle *v = vl[0];

    42

	Vehicle *u = vl[0];

    43

    45

    46

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

    47

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

    48

		if (callback == CALLBACK_FAILED || callback == 0xFF) return;

    49

    50

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

    51

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

    52

		u->SetNext(vl[i]);

    53

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

    54

    55

		Vehicle *previous = u;

    56

		u = u->Next();

    57

    58

		EngineID engine_type = GetFirstEngineOfType(type) + GB(callback, 0, 7);

    60

    61

		/* get common values from first engine */

    62

		u->direction = v->direction;

    63

		u->owner = v->owner;

    64

		u->tile = v->tile;

    65

		u->x_pos = v->x_pos;

    66

		u->y_pos = v->y_pos;

    67

		u->z_pos = v->z_pos;

    68

		u->build_year = v->build_year;

    69

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

    70

    71

		u->cargo_subtype = 0;

    72

		u->max_speed = 0;

    73

		u->max_age = 0;

    74

		u->engine_type = engine_type;

    75

		u->value = 0;

    76

		u->subtype = 0;

    77

		u->cur_image = 0xAC2;

    78

		u->random_bits = VehicleRandomBits();

    79

    80

		switch (type) {

    81

			default: NOT_REACHED();

    82

    83

			case VEH_TRAIN: {

    84

				const RailVehicleInfo *rvi_artic = RailVehInfo(engine_type);

    85

    86

				u = new (u) Train();

    87

				previous->SetNext(u);

    88

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

    89

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

    90

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

    91

    92

				u->spritenum = rvi_artic->image_index;

    93

				u->cargo_type = rvi_artic->cargo_type;

    94

				u->cargo_cap = rvi_artic->capacity;

    95

    96

				SetArticulatedPart(u);

    97

			} break;

    98

    99

			case VEH_ROAD: {

   100

				const RoadVehicleInfo *rvi_artic = RoadVehInfo(engine_type);

   101

   102

				u = new (u) RoadVehicle();

   103

				previous->SetNext(u);

   104

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

   105

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

   106

				u->u.road.state = RVSB_IN_DEPOT;

   107

   108

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

   109

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

   110

   111

				u->spritenum = rvi_artic->image_index;

   112

				u->cargo_type = rvi_artic->cargo_type;

   113

				u->cargo_cap = rvi_artic->capacity;

   114

   115

				SetRoadVehArticPart(u);

   116

			} break;

   117

		}

   118

   119

		if (flip_image) u->spritenum++;

   120

   121

		VehiclePositionChanged(u);

   122

	}

   123

}