1

/* $Id$ */

     2

     3

/** @file ai_engine.cpp Implementation of AIEngine. */

     4

     5

#include "ai_engine.hpp"

     6

#include "ai_cargo.hpp"

     7

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

     8

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

     9

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

    10

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

    11

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

    12

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

    13

#include "../../cargotype.h"

    14

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

    15

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

    16

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

    17

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

    18

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

    19

#include "table/strings.h"

    20

    21

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

    22

{

    23

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

    24

}

    25

    26

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

    27

{

    28

	if (!IsValidEngine(engine_id)) return NULL;

    29

    30

	static const int len = 64;

    31

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

    32

    33

	::SetDParam(0, engine_id);

    34

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

    35

	return engine_name;

    36

}

    37

    38

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

    39

{

    40

	if (!IsValidEngine(engine_id)) return 0;

    41

    42

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

    43

		case VEH_ROAD: {

    44

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

    45

			return vi->cargo_type;

    46

		} break;

    47

    48

		case VEH_TRAIN: {

    49

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

    50

			return vi->cargo_type;

    51

		} break;

    52

    53

		case VEH_SHIP: {

    54

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

    55

			return vi->cargo_type;

    56

		} break;

    57

    58

		case VEH_AIRCRAFT: {

    59

			return CT_PASSENGERS;

    60

		} break;

    61

    62

		default: NOT_REACHED();

    63

	}

    64

}

    65

    66

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

    67

{

    68

	if (!IsValidEngine(engine_id)) return false;

    69

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

    70

    71

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

    72

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

    73

	return ::CanRefitTo(engine_id, cargo_id);

    74

}

    75

    76

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

    77

{

    78

	if (!IsValidEngine(engine_id)) return 0;

    79

    80

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

    81

		case VEH_ROAD: {

    82

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

    83

			return vi->capacity;

    84

		} break;

    85

    86

		case VEH_TRAIN: {

    87

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

    88

			return vi->capacity;

    89

		} break;

    90

    91

		case VEH_SHIP: {

    92

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

    93

			return vi->capacity;

    94

		} break;

    95

    96

		case VEH_AIRCRAFT: {

    97

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

    98

			return vi->passenger_capacity;

    99

		} break;

   100

   101

		default: NOT_REACHED();

   102

	}

   103

}

   104

   105

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

   106

{

   107

	if (!IsValidEngine(engine_id)) return 0;

   108

   109

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

   110

}

   111

   112

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

   113

{

   114

	if (!IsValidEngine(engine_id)) return 0;

   115

   116

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

   117

		case VEH_ROAD: {

   118

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

   119

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

   120

			return vi->max_speed / 2;

   121

		} break;

   122

   123

		case VEH_TRAIN: {

   124

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

   125

			return vi->max_speed;

   126

		} break;

   127

   128

		case VEH_SHIP: {

   129

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

   130

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

   131

			return vi->max_speed / 2;

   132

		} break;

   133

   134

		case VEH_AIRCRAFT: {

   135

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

   136

			return vi->max_speed / _patches.plane_speed;

   137

		} break;

   138

   139

		default: NOT_REACHED();

   140

	}

   141

}

   142

   143

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

   144

{

   145

	if (!IsValidEngine(engine_id)) return 0;

   146

   147

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

   148

		case VEH_ROAD: {

   149

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

   150

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

   151

		} break;

   152

   153

		case VEH_TRAIN: {

   154

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

   155

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

   156

		} break;

   157

   158

		case VEH_SHIP: {

   159

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

   160

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

   161

		} break;

   162

   163

		case VEH_AIRCRAFT: {

   164

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

   165

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

   166

		} break;

   167

   168

		default: NOT_REACHED();

   169

	}

   170

}

   171

   172

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

   173

{

   174

	if (!IsValidEngine(engine_id)) return 0;

   175

   176

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

   177

}

   178

   179

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

   180

{

   181

	if (!IsValidEngine(engine_id)) return 0;

   182

   183

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

   184

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

   185

	 *  there is no other way.. */

   186

	Vehicle *vehicle;

   187

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

   188

		case VEH_ROAD: {

   189

			vehicle = new RoadVehicle();

   190

		} break;

   191

   192

		case VEH_TRAIN: {

   193

			vehicle = new Train();

   194

		} break;

   195

   196

		case VEH_SHIP: {

   197

			vehicle = new Ship();

   198

		} break;

   199

   200

		case VEH_AIRCRAFT: {

   201

			vehicle = new Aircraft();

   202

		} break;

   203

   204

		default: NOT_REACHED();

   205

	}

   206

   207

	vehicle->engine_type = engine_id;

   208

	Money runningCost = vehicle->GetRunningCost();

   209

	delete vehicle;

   210

	return runningCost >> 8;

   211

}

   212

   213

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

   214

{

   215

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

   216

   217

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

   218

		case VEH_ROAD:     return AIVehicle::VEHICLE_ROAD;

   219

		case VEH_TRAIN:    return AIVehicle::VEHICLE_RAIL;

   220

		case VEH_SHIP:     return AIVehicle::VEHICLE_WATER;

   221

		case VEH_AIRCRAFT: return AIVehicle::VEHICLE_AIR;

   222

		default: NOT_REACHED();

   223

	}

   224

}