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

     9

#include "../../variables.h"

    10

#include "../../strings.h"

    11

    12

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

    13

{

    14

	return ::IsEngineIndex(engine_id);

    15

}

    16

    17

EngineID AIEngine::FindBestVehicle(CargoID cargo, uint8 min_reliability, AIVehicle::VehicleType veh_type, uint max_cost)

    18

{

    19

	if (!AICargo::IsValidCargo(cargo) || min_reliability > 100) return INVALID_ENGINE;

    20

    21

	EngineID best_engine = INVALID_ENGINE;

    22

	EngineID engine_id;

    23

	uint best_cargo = 0;

    24

	uint best_speed = 0;

    25

    26

	FOR_ALL_ENGINEIDS_OF_TYPE(engine_id, veh_type) {

    27

		/* Is the vehicle available for this player */

    28

		if (IsEngineBuildable(engine_id, veh_type, _current_player) &&

    29

				GetEngine(engine_id)->reliability * 100 >= min_reliability << 16) {

    30

			uint cspeed, ccargo;

    31

			/* Can this vehicle handle the cargo requested? */

    32

			switch (veh_type) {

    33

				case AIVehicle::VEHICLE_ROAD: {

    34

					const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

    35

					if (vi->cargo_type != cargo && !CanRefitTo(engine_id, cargo)) continue;

    36

					if ((_price.roadveh_base >> 3) * vi->base_cost >> 5 > max_cost) continue;

    37

					ccargo = vi->capacity;

    38

					cspeed = vi->max_speed;

    39

				} break;

    40

    41

				case AIVehicle::VEHICLE_RAIL: {

    42

					const RailVehicleInfo *vi = RailVehInfo(engine_id);

    43

					if (vi->cargo_type != cargo && !CanRefitTo(engine_id, cargo)) continue;

    44

					if ((_price.build_railvehicle >> 3) * vi->base_cost >> 5 > max_cost) continue;

    45

					ccargo = vi->capacity;

    46

					cspeed = vi->max_speed;

    47

				} break;

    48

    49

				case AIVehicle::VEHICLE_WATER: {

    50

					const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

    51

					if (vi->cargo_type != cargo && !CanRefitTo(engine_id, cargo)) continue;

    52

					if ((_price.ship_base >> 3) * vi->base_cost >> 5 > max_cost) continue;

    53

					ccargo = vi->capacity;

    54

					cspeed = vi->max_speed;

    55

				} break;

    56

    57

				case AIVehicle::VEHICLE_AIR: {

    58

					const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);

    59

					if (CT_PASSENGERS != cargo && CT_MAIL != cargo && !CanRefitTo(engine_id, cargo)) continue;

    60

					if ((_price.aircraft_base >> 3) * vi->base_cost >> 5 > max_cost) continue;

    61

					ccargo = vi->passenger_capacity;

    62

					cspeed = vi->max_speed;

    63

				} break;

    64

    65

				default: NOT_REACHED();

    66

			}

    67

    68

			/* Sort on speed, than on cargo, than on order of engine-array */

    69

			if (best_speed > cspeed) continue;

    70

			if (best_cargo > ccargo) continue;

    71

			best_engine = engine_id;

    72

			best_speed = cspeed;

    73

			best_cargo = ccargo;

    74

		}

    75

	}

    76

    77

	return best_engine;

    78

}

    79

    80

EngineID AIEngine::FindBestRoadEngine(CargoID cargo, uint8 min_reliability, uint max_cost)

    81

{

    82

	return this->FindBestVehicle(cargo, min_reliability, AIVehicle::VEHICLE_ROAD, max_cost);

    83

}

    84

    85

EngineID AIEngine::FindBestAirEngine(CargoID cargo, uint8 min_reliability, uint max_cost)

    86

{

    87

	return this->FindBestVehicle(cargo, min_reliability, AIVehicle::VEHICLE_AIR, max_cost);

    88

}

    89

    90

EngineID AIEngine::FindBestWaterEngine(CargoID cargo, uint8 min_reliability, uint max_cost)

    91

{

    92

	return this->FindBestVehicle(cargo, min_reliability, AIVehicle::VEHICLE_WATER, max_cost);

    93

}

    94

    95

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

    96

{

    97

	if (!AIEngine::IsValidEngine(engine_id)) return NULL;

    98

    99

	static const int len = 64;

   100

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

   101

   102

	GetString(engine_name, _engine_name_strings[engine_id], &engine_name[len - 1]);

   103

	return engine_name;

   104

}

   105

   106

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

   107

{

   108

	if (!AIEngine::IsValidEngine(engine_id)) return 0;

   109

   110

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

   111

		case VEH_ROAD: {

   112

			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

   113

			return vi->cargo_type;

   114

		} break;

   115

   116

		case VEH_TRAIN: {

   117

			const RailVehicleInfo *vi = RailVehInfo(engine_id);

   118

			return vi->cargo_type;

   119

		} break;

   120

   121

		case VEH_SHIP: {

   122

			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

   123

			return vi->cargo_type;

   124

		} break;

   125

   126

		case VEH_AIRCRAFT: {

   127

			return CT_PASSENGERS;

   128

		} break;

   129

   130

		default: NOT_REACHED();

   131

	}

   132

}

   133

   134

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

   135

{

   136

	if (!AIEngine::IsValidEngine(engine_id)) return 0;

   137

   138

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

   139

		case VEH_ROAD: {

   140

			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

   141

			return vi->capacity;

   142

		} break;

   143

   144

		case VEH_TRAIN: {

   145

			const RailVehicleInfo *vi = RailVehInfo(engine_id);

   146

			return vi->capacity;

   147

		} break;

   148

   149

		case VEH_SHIP: {

   150

			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

   151

			return vi->capacity;

   152

		} break;

   153

   154

		case VEH_AIRCRAFT: {

   155

			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);

   156

			return vi->passenger_capacity;

   157

		} break;

   158

   159

		default: NOT_REACHED();

   160

	}

   161

}

   162

   163

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

   164

{

   165

	if (!AIEngine::IsValidEngine(engine_id)) return 0;

   166

   167

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

   168

}

   169

   170

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

   171

{

   172

	if (!AIEngine::IsValidEngine(engine_id)) return 0;

   173

   174

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

   175

		case VEH_ROAD: {

   176

			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

   177

			return vi->max_speed;

   178

		} break;

   179

   180

		case VEH_TRAIN: {

   181

			const RailVehicleInfo *vi = RailVehInfo(engine_id);

   182

			return vi->max_speed;

   183

		} break;

   184

   185

		case VEH_SHIP: {

   186

			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

   187

			return vi->max_speed;

   188

		} break;

   189

   190

		case VEH_AIRCRAFT: {

   191

			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);

   192

			return vi->max_speed;

   193

		} break;

   194

   195

		default: NOT_REACHED();

   196

	}

   197

}

   198

   199

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

   200

{

   201

	if (!AIEngine::IsValidEngine(engine_id)) return 0;

   202

   203

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

   204

		case VEH_ROAD: {

   205

			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

   206

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

   207

		} break;

   208

   209

		case VEH_TRAIN: {

   210

			const RailVehicleInfo *vi = RailVehInfo(engine_id);

   211

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

   212

		} break;

   213

   214

		case VEH_SHIP: {

   215

			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

   216

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

   217

		} break;

   218

   219

		case VEH_AIRCRAFT: {

   220

			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);

   221

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

   222

		} break;

   223

   224

		default: NOT_REACHED();

   225

	}

   226

}

   227

   228

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

   229

{

   230

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

   231

   232

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

   233

		case VEH_ROAD:     return AIVehicle::VEHICLE_ROAD;

   234

		case VEH_TRAIN:    return AIVehicle::VEHICLE_RAIL;

   235

		case VEH_SHIP:     return AIVehicle::VEHICLE_WATER;

   236

		case VEH_AIRCRAFT: return AIVehicle::VEHICLE_AIR;

   237

		default: NOT_REACHED();

   238

	}

   239

}