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 "../../cargotype.h"

    15

#include "../../vehicle_func.h"

    16

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

    17

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

    18

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

    19

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

    20

#include "table/strings.h"

    21

    22

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

    23

{

    24

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

    25

}

    26

    27

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

    28

{

    29

	if (!IsValidEngine(engine_id)) return NULL;

    30

    31

	static const int len = 64;

    32

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

    33

    34

	::SetDParam(0, engine_id);

    35

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

    36

	return engine_name;

    37

}

    38

    39

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

    40

{

    41

	if (!IsValidEngine(engine_id)) return 0;

    42

    43

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

    44

		case VEH_ROAD: {

    45

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

    46

			return vi->cargo_type;

    47

		} break;

    48

    49

		case VEH_TRAIN: {

    50

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

    51

			return vi->cargo_type;

    52

		} break;

    53

    54

		case VEH_SHIP: {

    55

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

    56

			return vi->cargo_type;

    57

		} break;

    58

    59

		case VEH_AIRCRAFT: {

    60

			return CT_PASSENGERS;

    61

		} break;

    62

    63

		default: NOT_REACHED();

    64

	}

    65

}

    66

    67

/* static */ bool AIEngine::CanRefitCargo(EngineID engine_id, CargoID cargo_id)

    68

{

    69

	if (!IsValidEngine(engine_id)) return false;

    70

	if (!AICargo::IsValidCargo(cargo_id)) return false;

    71

    72

	if (GetCargoType(engine_id) == cargo_id) return true;

    73

	if (cargo_id == CT_MAIL && ::GetEngine(engine_id)->type == VEH_AIRCRAFT) return true;

    74

	return ::CanRefitTo(engine_id, cargo_id);

    75

}

    76

    77

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

    78

{

    79

	if (!IsValidEngine(engine_id)) return 0;

    80

    81

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

    82

		case VEH_ROAD: {

    83

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

    84

			return vi->capacity;

    85

		} break;

    86

    87

		case VEH_TRAIN: {

    88

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

    89

			return vi->capacity;

    90

		} break;

    91

    92

		case VEH_SHIP: {

    93

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

    94

			return vi->capacity;

    95

		} break;

    96

    97

		case VEH_AIRCRAFT: {

    98

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

    99

			return vi->passenger_capacity;

   100

		} break;

   101

   102

		default: NOT_REACHED();

   103

	}

   104

}

   105

   106

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

   107

{

   108

	if (!IsValidEngine(engine_id)) return 0;

   109

   110

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

   111

}

   112

   113

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

   114

{

   115

	if (!IsValidEngine(engine_id)) return 0;

   116

   117

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

   118

		case VEH_ROAD: {

   119

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

   120

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

   121

			return vi->max_speed / 2;

   122

		} break;

   123

   124

		case VEH_TRAIN: {

   125

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

   126

			return vi->max_speed;

   127

		} break;

   128

   129

		case VEH_SHIP: {

   130

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

   131

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

   132

			return vi->max_speed / 2;

   133

		} break;

   134

   135

		case VEH_AIRCRAFT: {

   136

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

   137

			return vi->max_speed / _patches.plane_speed;

   138

		} break;

   139

   140

		default: NOT_REACHED();

   141

	}

   142

}

   143

   144

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

   145

{

   146

	if (!IsValidEngine(engine_id)) return 0;

   147

   148

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

   149

		case VEH_ROAD: {

   150

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

   151

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

   152

		} break;

   153

   154

		case VEH_TRAIN: {

   155

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

   156

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

   157

		} break;

   158

   159

		case VEH_SHIP: {

   160

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

   161

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

   162

		} break;

   163

   164

		case VEH_AIRCRAFT: {

   165

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

   166

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

   167

		} break;

   168

   169

		default: NOT_REACHED();

   170

	}

   171

}

   172

   173

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

   174

{

   175

	if (!IsValidEngine(engine_id)) return 0;

   176

   177

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

   178

}

   179

   180

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

   181

{

   182

	if (!IsValidEngine(engine_id)) return 0;

   183

   184

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

   185

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

   186

	 *  there is no other way.. */

   187

	Vehicle *vehicle;

   188

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

   189

		case VEH_ROAD: {

   190

			vehicle = new RoadVehicle();

   191

		} break;

   192

   193

		case VEH_TRAIN: {

   194

			vehicle = new Train();

   195

		} break;

   196

   197

		case VEH_SHIP: {

   198

			vehicle = new Ship();

   199

		} break;

   200

   201

		case VEH_AIRCRAFT: {

   202

			vehicle = new Aircraft();

   203

		} break;

   204

   205

		default: NOT_REACHED();

   206

	}

   207

   208

	vehicle->engine_type = engine_id;

   209

	Money runningCost = vehicle->GetRunningCost();

   210

	delete vehicle;

   211

	return runningCost >> 8;

   212

}

   213

   214

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

   215

{

   216

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

   217

   218

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

   219

		case VEH_ROAD:     return AIVehicle::VEHICLE_ROAD;

   220

		case VEH_TRAIN:    return AIVehicle::VEHICLE_RAIL;

   221

		case VEH_SHIP:     return AIVehicle::VEHICLE_WATER;

   222

		case VEH_AIRCRAFT: return AIVehicle::VEHICLE_AIR;

   223

		default: NOT_REACHED();

   224

	}

   225

}