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"

    12

    13

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

    14

{

    15

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

    16

}

    17

    18

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

    19

{

    20

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

    21

    22

	static const int len = 64;

    23

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

    24

    25

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

    26

	return engine_name;

    27

}

    28

    29

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

    30

{

    31

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

    32

    33

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

    34

		case VEH_ROAD: {

    35

			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

    36

			return vi->cargo_type;

    37

		} break;

    38

    39

		case VEH_TRAIN: {

    40

			const RailVehicleInfo *vi = RailVehInfo(engine_id);

    41

			return vi->cargo_type;

    42

		} break;

    43

    44

		case VEH_SHIP: {

    45

			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

    46

			return vi->cargo_type;

    47

		} break;

    48

    49

		case VEH_AIRCRAFT: {

    50

			return CT_PASSENGERS;

    51

		} break;

    52

    53

		default: NOT_REACHED();

    54

	}

    55

}

    56

    57

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

    58

{

    59

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

    60

    61

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

    62

		case VEH_ROAD: {

    63

			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

    64

			return vi->capacity;

    65

		} break;

    66

    67

		case VEH_TRAIN: {

    68

			const RailVehicleInfo *vi = RailVehInfo(engine_id);

    69

			return vi->capacity;

    70

		} break;

    71

    72

		case VEH_SHIP: {

    73

			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

    74

			return vi->capacity;

    75

		} break;

    76

    77

		case VEH_AIRCRAFT: {

    78

			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);

    79

			return vi->passenger_capacity;

    80

		} break;

    81

    82

		default: NOT_REACHED();

    83

	}

    84

}

    85

    86

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

    87

{

    88

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

    89

    90

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

    91

}

    92

    93

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

    94

{

    95

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

    96

    97

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

    98

		case VEH_ROAD: {

    99

			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

   100

			return vi->max_speed;

   101

		} break;

   102

   103

		case VEH_TRAIN: {

   104

			const RailVehicleInfo *vi = RailVehInfo(engine_id);

   105

			return vi->max_speed;

   106

		} break;

   107

   108

		case VEH_SHIP: {

   109

			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

   110

			return vi->max_speed;

   111

		} break;

   112

   113

		case VEH_AIRCRAFT: {

   114

			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);

   115

			return vi->max_speed;

   116

		} break;

   117

   118

		default: NOT_REACHED();

   119

	}

   120

}

   121

   122

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

   123

{

   124

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

   125

   126

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

   127

		case VEH_ROAD: {

   128

			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

   129

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

   130

		} break;

   131

   132

		case VEH_TRAIN: {

   133

			const RailVehicleInfo *vi = RailVehInfo(engine_id);

   134

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

   135

		} break;

   136

   137

		case VEH_SHIP: {

   138

			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

   139

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

   140

		} break;

   141

   142

		case VEH_AIRCRAFT: {

   143

			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);

   144

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

   145

		} break;

   146

   147

		default: NOT_REACHED();

   148

	}

   149

}

   150

   151

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

   152

{

   153

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

   154

   155

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

   156

		case VEH_ROAD:     return AIVehicle::VEHICLE_ROAD;

   157

		case VEH_TRAIN:    return AIVehicle::VEHICLE_RAIL;

   158

		case VEH_SHIP:     return AIVehicle::VEHICLE_WATER;

   159

		case VEH_AIRCRAFT: return AIVehicle::VEHICLE_AIR;

   160

		default: NOT_REACHED();

   161

	}

   162

}