1

/* $Id$ */

     2

     3

/** @file ai_engine.cpp handles the functions of the AIEngine class */

     4

     5

#include "ai_engine.hpp"

     6

#include "ai_cargo.hpp"

     7

#include "../../engine.h"

     8

#include "../../player_func.h"

     9

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

    10

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

    11

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

    12

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

    13

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

    14

#include "../../core/alloc_func.hpp"

    15

#include "../../economy_func.h"

    16

#include "../../core/bitmath_func.hpp"

    17

#include "table/strings.h"

    18

    19

/* static */ bool AIEngine::IsValidEngine(EngineID engine_id)

    20

{

    21

	return ::IsEngineIndex(engine_id) && HasBit(::GetEngine(engine_id)->player_avail, _current_player);

    22

}

    23

    24

/* static */ char *AIEngine::GetName(EngineID engine_id)

    25

{

    26

	if (!IsValidEngine(engine_id)) return NULL;

    27

    28

	static const int len = 64;

    29

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

    30

    31

	::SetDParam(0, engine_id);

    32

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

    33

	return engine_name;

    34

}

    35

    36

/* static */ CargoID AIEngine::GetCargoType(EngineID engine_id)

    37

{

    38

	if (!IsValidEngine(engine_id)) return 0;

    39

    40

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

    41

		case VEH_ROAD: {

    42

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

    43

			return vi->cargo_type;

    44

		} break;

    45

    46

		case VEH_TRAIN: {

    47

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

    48

			return vi->cargo_type;

    49

		} break;

    50

    51

		case VEH_SHIP: {

    52

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

    53

			return vi->cargo_type;

    54

		} break;

    55

    56

		case VEH_AIRCRAFT: {

    57

			return CT_PASSENGERS;

    58

		} break;

    59

    60

		default: NOT_REACHED();

    61

	}

    62

}

    63

    64

/* static */ uint32 AIEngine::GetCapacity(EngineID engine_id)

    65

{

    66

	if (!IsValidEngine(engine_id)) return 0;

    67

    68

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

    69

		case VEH_ROAD: {

    70

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

    71

			return vi->capacity;

    72

		} break;

    73

    74

		case VEH_TRAIN: {

    75

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

    76

			return vi->capacity;

    77

		} break;

    78

    79

		case VEH_SHIP: {

    80

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

    81

			return vi->capacity;

    82

		} break;

    83

    84

		case VEH_AIRCRAFT: {

    85

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

    86

			return vi->passenger_capacity;

    87

		} break;

    88

    89

		default: NOT_REACHED();

    90

	}

    91

}

    92

    93

/* static */ uint32 AIEngine::GetReliability(EngineID engine_id)

    94

{

    95

	if (!IsValidEngine(engine_id)) return 0;

    96

    97

	return (::GetEngine(engine_id)->reliability * 100 >> 16);

    98

}

    99

   100

/* static */ uint32 AIEngine::GetMaxSpeed(EngineID engine_id)

   101

{

   102

	if (!IsValidEngine(engine_id)) return 0;

   103

   104

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

   105

		case VEH_ROAD: {

   106

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

   107

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

   108

			return vi->max_speed / 2;

   109

		} break;

   110

   111

		case VEH_TRAIN: {

   112

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

   113

			return vi->max_speed;

   114

		} break;

   115

   116

		case VEH_SHIP: {

   117

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

   118

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

   119

			return vi->max_speed / 2;

   120

		} break;

   121

   122

		case VEH_AIRCRAFT: {

   123

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

   124

			return vi->max_speed;

   125

		} break;

   126

   127

		default: NOT_REACHED();

   128

	}

   129

}

   130

   131

/* static */ uint32 AIEngine::GetPrice(EngineID engine_id)

   132

{

   133

	if (!IsValidEngine(engine_id)) return 0;

   134

   135

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

   136

		case VEH_ROAD: {

   137

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

   138

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

   139

		} break;

   140

   141

		case VEH_TRAIN: {

   142

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

   143

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

   144

		} break;

   145

   146

		case VEH_SHIP: {

   147

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

   148

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

   149

		} break;

   150

   151

		case VEH_AIRCRAFT: {

   152

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

   153

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

   154

		} break;

   155

   156

		default: NOT_REACHED();

   157

	}

   158

}

   159

   160

/* static */ uint32 AIEngine::GetMaxAge(EngineID engine_id)

   161

{

   162

	if (!IsValidEngine(engine_id)) return 0;

   163

   164

	return ::GetEngine(engine_id)->lifelength * 366;

   165

}

   166

   167

/* static */ Money AIEngine::GetRunningCost(EngineID engine_id)

   168

{

   169

	if (!IsValidEngine(engine_id)) return 0;

   170

   171

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

   172

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

   173

	 *  there is no other way.. */

   174

	Vehicle *vehicle;

   175

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

   176

		case VEH_ROAD: {

   177

			vehicle = new RoadVehicle();

   178

		} break;

   179

   180

		case VEH_TRAIN: {

   181

			vehicle = new Train();

   182

		} break;

   183

   184

		case VEH_SHIP: {

   185

			vehicle = new Ship();

   186

		} break;

   187

   188

		case VEH_AIRCRAFT: {

   189

			vehicle = new Aircraft();

   190

		} break;

   191

   192

		default: NOT_REACHED();

   193

	}

   194

   195

	vehicle->engine_type = engine_id;

   196

	Money runningCost = vehicle->GetRunningCost();

   197

	delete vehicle;

   198

	return runningCost >> 8;

   199

}

   200

   201

/* static */ AIVehicle::VehicleType AIEngine::GetVehicleType(EngineID engine_id)

   202

{

   203

	if (!IsValidEngine(engine_id)) return AIVehicle::VEHICLE_INVALID;

   204

   205

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

   206

		case VEH_ROAD:     return AIVehicle::VEHICLE_ROAD;

   207

		case VEH_TRAIN:    return AIVehicle::VEHICLE_RAIL;

   208

		case VEH_SHIP:     return AIVehicle::VEHICLE_WATER;

   209

		case VEH_AIRCRAFT: return AIVehicle::VEHICLE_AIR;

   210

		default: NOT_REACHED();

   211

	}

   212

}