1

/* $Id$ */

     2

     3

/** @file ai_event_types.cpp Implementation of all EventTypes. */

     4

     5

#include "ai_event_types.hpp"

     8

#include "../../strings_func.h"

     9

#include "../../roadveh.h"

    10

#include "../../train.h"

    11

#include "../../ship.h"

    12

#include "../../aircraft.h"

    13

#include "../../settings_type.h"

    14

#include "../../articulated_vehicles.h"

    15

#include "table/strings.h"

    16

    17

bool AIEventVehicleCrash::CloneCrashedVehicle(TileIndex depot)

    18

{

    19

	return false;

    20

}

    21

    22

char *AIEventEnginePreview::GetName()

    23

{

    24

	static const int len = 64;

    25

	char *engine_name = MallocT<char>(len);

    26

    27

	::SetDParam(0, engine);

    28

	::GetString(engine_name, STR_ENGINE_NAME, &engine_name[len - 1]);

    29

	return engine_name;

    30

}

    31

    32

CargoID AIEventEnginePreview::GetCargoType()

    33

{

    34

	switch (::GetEngine(engine)->type) {

    35

		case VEH_ROAD: {

    36

			const RoadVehicleInfo *vi = ::RoadVehInfo(engine);

    37

			return vi->cargo_type;

    38

		} break;

    39

    40

		case VEH_TRAIN: {

    41

			const RailVehicleInfo *vi = ::RailVehInfo(engine);

    42

			return vi->cargo_type;

    43

		} break;

    44

    45

		case VEH_SHIP: {

    46

			const ShipVehicleInfo *vi = ::ShipVehInfo(engine);

    47

			return vi->cargo_type;

    48

		} break;

    49

    50

		case VEH_AIRCRAFT: {

    51

			return CT_PASSENGERS;

    52

		} break;

    53

    54

		default: NOT_REACHED();

    55

	}

    56

}

    57

    58

int32 AIEventEnginePreview::GetCapacity()

    59

{

    60

	switch (::GetEngine(engine)->type) {

    61

		case VEH_ROAD:

    62

		case VEH_TRAIN: {

    63

			uint16 *capacities = GetCapacityOfArticulatedParts(engine, ::GetEngine(engine)->type);

    64

			for (CargoID c = 0; c < NUM_CARGO; c++) {

    65

				if (capacities[c] == 0) continue;

    66

				return capacities[c];

    67

			}

    68

			return -1;

    69

		} break;

    70

    71

		case VEH_SHIP: {

    72

			const ShipVehicleInfo *vi = ::ShipVehInfo(engine);

    73

			return vi->capacity;

    74

		} break;

    75

    76

		case VEH_AIRCRAFT: {

    77

			const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine);

    78

			return vi->passenger_capacity;

    79

		} break;

    80

    81

		default: NOT_REACHED();

    82

	}

    83

}

    84

    85

int32 AIEventEnginePreview::GetMaxSpeed()

    86

{

    87

	switch (::GetEngine(engine)->type) {

    88

		case VEH_ROAD: {

    89

			const RoadVehicleInfo *vi = ::RoadVehInfo(engine);

    90

			/* Internal speeds are km/h * 2 */

    91

			return vi->max_speed / 2;

    92

		} break;

    93

    94

		case VEH_TRAIN: {

    95

			const RailVehicleInfo *vi = ::RailVehInfo(engine);

    96

			return vi->max_speed;

    97

		} break;

    98

    99

		case VEH_SHIP: {

   100

			const ShipVehicleInfo *vi = ::ShipVehInfo(engine);

   101

			/* Internal speeds are km/h * 2 */

   102

			return vi->max_speed / 2;

   103

		} break;

   104

   105

		case VEH_AIRCRAFT: {

   106

			const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine);

   107

			return vi->max_speed / _patches.plane_speed;

   108

		} break;

   109

   110

		default: NOT_REACHED();

   111

	}

   112

}

   113

   114

Money AIEventEnginePreview::GetPrice()

   115

{

   116

	switch (::GetEngine(engine)->type) {

   117

		case VEH_ROAD: {

   118

			const RoadVehicleInfo *vi = ::RoadVehInfo(engine);

   119

			return (_price.roadveh_base >> 3) * vi->base_cost >> 5;

   120

		} break;

   121

   122

		case VEH_TRAIN: {

   123

			const RailVehicleInfo *vi = ::RailVehInfo(engine);

   124

			return (_price.build_railvehicle >> 3) * vi->base_cost >> 5;

   125

		} break;

   126

   127

		case VEH_SHIP: {

   128

			const ShipVehicleInfo *vi = ::ShipVehInfo(engine);

   129

			return (_price.ship_base >> 3) * vi->base_cost >> 5;

   130

		} break;

   131

   132

		case VEH_AIRCRAFT: {

   133

			const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine);

   134

			return (_price.aircraft_base >> 3) * vi->base_cost >> 5;

   135

		} break;

   136

   137

		default: NOT_REACHED();

   138

	}

   139

}

   140

   141

Money AIEventEnginePreview::GetRunningCost()

   142

{

   143

	/* We need to create an instance in order to obtain GetRunningCost.

   144

	 *  This means we temporary allocate a vehicle in the pool, but

   145

	 *  there is no other way.. */

   146

	Vehicle *vehicle;

   147

	switch (::GetEngine(engine)->type) {

   148

		case VEH_ROAD: {

   149

			vehicle = new RoadVehicle();

   150

		} break;

   151

   152

		case VEH_TRAIN: {

   153

			vehicle = new Train();

   154

		} break;

   155

   156

		case VEH_SHIP: {

   157

			vehicle = new Ship();

   158

		} break;

   159

   160

		case VEH_AIRCRAFT: {

   161

			vehicle = new Aircraft();

   162

		} break;

   163

   164

		default: NOT_REACHED();

   165

	}

   166

   167

	vehicle->engine_type = engine;

   168

	Money runningCost = vehicle->GetRunningCost();

   169

	delete vehicle;

   170

	return runningCost >> 8;

   171

}

   172

   173

AIVehicle::VehicleType AIEventEnginePreview::GetVehicleType()

   174

{

   175

	switch (::GetEngine(engine)->type) {

   176

		case VEH_ROAD:     return AIVehicle::VEHICLE_ROAD;

   177

		case VEH_TRAIN:    return AIVehicle::VEHICLE_RAIL;

   178

		case VEH_SHIP:     return AIVehicle::VEHICLE_WATER;

   179

		case VEH_AIRCRAFT: return AIVehicle::VEHICLE_AIR;

   180

		default: NOT_REACHED();

   181

	}

   182

}

   183

   184

bool AIEventEnginePreview::AcceptPreview()

   185

{

   186

	return AIObject::DoCommand(0, engine, 0, CMD_WANT_ENGINE_PREVIEW);

   187

}