1

/* $Id$ */

     2

     3

/** @file ai_vehicle.cpp handles the functions of the AIVehicle class */

     4

     5

#include "ai_vehicle.hpp"

     6

#include "ai_engine.hpp"

     7

#include "ai_cargo.hpp"

     8

#include "ai_order.hpp"

     9

#include "../../command_func.h"

    10

#include "../../depot.h"

    11

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

    12

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

    13

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

    14

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

    15

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

    16

#include "../../command_type.h"

    17

#include "../../command_func.h"

    18

#include "table/strings.h"

    19

    20

/* static */ bool AIVehicle::IsValidVehicle(VehicleID vehicle_id)

    21

{

    22

	return ::IsValidVehicleID(vehicle_id) && ::GetVehicle(vehicle_id)->owner == _current_player && ::GetVehicle(vehicle_id)->IsPrimaryVehicle();

    23

}

    24

    25

/* static */ VehicleID AIVehicle::BuildVehicle(TileIndex depot, EngineID engine_id)

    26

{

    27

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

    28

    29

	/* Reset the internal NewVehicleID in case we are in TestMode */

    30

	AIObject::SetNewVehicleID(0);

    31

    32

	bool ret;

    33

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

    34

		case VEH_ROAD: ret = AIObject::DoCommand(depot, engine_id, 0, CMD_BUILD_ROAD_VEH); break;

    35

		case VEH_TRAIN: ret = AIObject::DoCommand(depot, engine_id, 0, CMD_BUILD_RAIL_VEHICLE); break;

    36

		case VEH_SHIP: ret = AIObject::DoCommand(depot, engine_id, 0, CMD_BUILD_SHIP); break;

    37

		case VEH_AIRCRAFT: ret = AIObject::DoCommand(depot, engine_id, 0, CMD_BUILD_AIRCRAFT); break;

    38

		default: NOT_REACHED(); return INVALID_VEHICLE;

    39

	}

    40

    41

	return ret ? AIObject::GetNewVehicleID() : INVALID_VEHICLE;

    42

}

    43

    44

/* static */ VehicleID AIVehicle::CloneVehicle(TileIndex depot, VehicleID vehicle_id, bool share_orders)

    45

{

    46

	if (!IsValidVehicle(vehicle_id)) return false;

    47

    48

	/* Reset the internal NewVehicleID in case we are in TestMode */

    49

	AIObject::SetNewVehicleID(0);

    50

    51

	bool ret = AIObject::DoCommand(depot, vehicle_id, share_orders, CMD_CLONE_VEHICLE);

    52

	return ret ? AIObject::GetNewVehicleID() : INVALID_VEHICLE;

    53

}

    54

    55

/* static */ bool AIVehicle::RefitVehicle(VehicleID vehicle_id, CargoID cargo)

    56

{

    57

	if (!IsValidVehicle(vehicle_id) || !AICargo::IsValidCargo(cargo)) return false;

    58

    59

	switch (::GetVehicle(vehicle_id)->type) {

    60

		case VEH_ROAD: return AIObject::DoCommand(0, vehicle_id, cargo, CMD_REFIT_ROAD_VEH);

    61

		case VEH_TRAIN: return AIObject::DoCommand(0, vehicle_id, cargo, CMD_REFIT_RAIL_VEHICLE);

    62

		case VEH_SHIP: return AIObject::DoCommand(0, vehicle_id, cargo, CMD_REFIT_SHIP);

    63

		case VEH_AIRCRAFT: return AIObject::DoCommand(0, vehicle_id, cargo, CMD_REFIT_AIRCRAFT);

    64

		default: return false;

    65

	}

    66

}

    67

    68

    69

/* static */ bool AIVehicle::SellVehicle(VehicleID vehicle_id)

    70

{

    71

	if (!IsValidVehicle(vehicle_id)) return false;

    72

    73

	switch (::GetVehicle(vehicle_id)->type) {

    74

		case VEH_ROAD: return AIObject::DoCommand(0, vehicle_id, 0, CMD_SELL_ROAD_VEH);

    75

		case VEH_TRAIN: return AIObject::DoCommand(0, vehicle_id, 0, CMD_SELL_RAIL_WAGON);

    76

		case VEH_SHIP: return AIObject::DoCommand(0, vehicle_id, 0, CMD_SELL_SHIP);

    77

		case VEH_AIRCRAFT: return AIObject::DoCommand(0, vehicle_id, 0, CMD_SELL_AIRCRAFT);

    78

		default: return false;

    79

	}

    80

}

    81

    82

/* static */ bool AIVehicle::SendVehicleToDepot(VehicleID vehicle_id)

    83

{

    84

	if (!IsValidVehicle(vehicle_id)) return false;

    85

    86

	switch (::GetVehicle(vehicle_id)->type) {

    87

		case VEH_ROAD: return AIObject::DoCommand(0, vehicle_id, 0, CMD_SEND_ROADVEH_TO_DEPOT);

    88

		case VEH_TRAIN: return AIObject::DoCommand(0, vehicle_id, 0, CMD_SEND_TRAIN_TO_DEPOT);

    89

		case VEH_SHIP: return AIObject::DoCommand(0, vehicle_id, 0, CMD_SEND_SHIP_TO_DEPOT);

    90

		case VEH_AIRCRAFT: return AIObject::DoCommand(0, vehicle_id, 0, CMD_SEND_AIRCRAFT_TO_HANGAR);

    91

		default: return false;

    92

	}

    93

}

    94

    95

/* static */ bool AIVehicle::IsInDepot(VehicleID vehicle_id)

    96

{

    97

	if (!IsValidVehicle(vehicle_id)) return false;

    98

	return ::GetVehicle(vehicle_id)->IsInDepot();

    99

}

   100

   101

/* static */ bool AIVehicle::IsStoppedInDepot(VehicleID vehicle_id)

   102

{

   103

	if (!IsValidVehicle(vehicle_id)) return false;

   104

	return ::GetVehicle(vehicle_id)->IsStoppedInDepot();

   105

}

   106

   107

/* static */ bool AIVehicle::StartStopVehicle(VehicleID vehicle_id)

   108

{

   109

	if (!IsValidVehicle(vehicle_id)) return false;

   110

   111

	switch (::GetVehicle(vehicle_id)->type) {

   112

		case VEH_ROAD: return AIObject::DoCommand(0, vehicle_id, 0, CMD_START_STOP_ROADVEH);

   113

		case VEH_TRAIN: return AIObject::DoCommand(0, vehicle_id, 0, CMD_START_STOP_TRAIN);

   114

		case VEH_SHIP: return AIObject::DoCommand(0, vehicle_id, 0, CMD_START_STOP_SHIP);

   115

		case VEH_AIRCRAFT: return AIObject::DoCommand(0, vehicle_id, 0, CMD_START_STOP_AIRCRAFT);

   116

		default: return false;

   117

	}

   118

}

   119

   120

/* static */ bool AIVehicle::SkipToVehicleOrder(VehicleID vehicle_id, uint32 order_id)

   121

{

   122

	if (!AIOrder::IsValidVehicleOrder(vehicle_id, order_id)) return false;

   123

   124

	return AIObject::DoCommand(0, vehicle_id, order_id, CMD_SKIP_TO_ORDER);

   125

}

   126

   127

/* static */ bool AIVehicle::SetName(VehicleID vehicle_id, const char *name)

   128

{

   129

	if (!IsValidVehicle(vehicle_id)) return false;

   130

	if (name == NULL) return false;

   131

   132

	_cmd_text = name;

   133

	return AIObject::DoCommand(0, vehicle_id, 0, CMD_NAME_VEHICLE);

   134

}

   135

   136

/* static */ TileIndex AIVehicle::GetLocation(VehicleID vehicle_id)

   137

{

   138

	if (!IsValidVehicle(vehicle_id)) return INVALID_TILE;

   139

   140

	return ::GetVehicle(vehicle_id)->tile;

   141

}

   142

   143

/* static */ EngineID AIVehicle::GetEngineType(VehicleID vehicle_id)

   144

{

   145

	if (!IsValidVehicle(vehicle_id)) return INVALID_ENGINE;

   146

   147

	return ::GetVehicle(vehicle_id)->engine_type;

   148

}

   149

   150

/* static */ int32 AIVehicle::GetUnitNumber(VehicleID vehicle_id)

   151

{

   152

	if (!IsValidVehicle(vehicle_id)) return -1;

   153

   154

	return ::GetVehicle(vehicle_id)->unitnumber;

   155

}

   156

   157

/* static */ char *AIVehicle::GetName(VehicleID vehicle_id)

   158

{

   159

	if (!IsValidVehicle(vehicle_id)) return NULL;

   160

   161

	static const int len = 64;

   162

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

   163

   164

	::SetDParam(0, vehicle_id);

   165

	::GetString(vehicle_name, STR_VEHICLE_NAME, &vehicle_name[len - 1]);

   166

	return vehicle_name;

   167

}

   168

   169

/* static */ int32 AIVehicle::GetAge(VehicleID vehicle_id)

   170

{

   171

	if (!IsValidVehicle(vehicle_id)) return -1;

   172

   173

	return ::GetVehicle(vehicle_id)->age;

   174

}

   175

   176

/* static */ int32 AIVehicle::GetMaxAge(VehicleID vehicle_id)

   177

{

   178

	if (!IsValidVehicle(vehicle_id)) return -1;

   179

   180

	return ::GetVehicle(vehicle_id)->max_age;

   181

}

   182

   183

/* static */ Money AIVehicle::GetRunningCost(VehicleID vehicle_id)

   184

{

   185

	if (!IsValidVehicle(vehicle_id)) return -1;

   186

   187

	return ::GetVehicle(vehicle_id)->GetRunningCost() >> 8;

   188

}

   189

   190

/* static */ int32 AIVehicle::GetAgeLeft(VehicleID vehicle_id)

   191

{

   192

	if (!IsValidVehicle(vehicle_id)) return -1;

   193

   194

	return ::GetVehicle(vehicle_id)->max_age - ::GetVehicle(vehicle_id)->age;

   195

}

   196

   197

/* static */ int32 AIVehicle::GetProfitThisYear(VehicleID vehicle_id)

   198

{

   199

	if (!IsValidVehicle(vehicle_id)) return -1;

   200

   201

	return ::GetVehicle(vehicle_id)->GetDisplayProfitThisYear();

   202

}

   203

   204

/* static */ int32 AIVehicle::GetProfitLastYear(VehicleID vehicle_id)

   205

{

   206

	if (!IsValidVehicle(vehicle_id)) return -1;

   207

   208

	return ::GetVehicle(vehicle_id)->GetDisplayProfitLastYear();

   209

}

   210

   211

/* static */ AIVehicle::VehicleType AIVehicle::GetVehicleType(VehicleID vehicle_id)

   212

{

   213

	if (!IsValidVehicle(vehicle_id)) return VEHICLE_INVALID;

   214

   215

	switch (::GetVehicle(vehicle_id)->type) {

   216

		case VEH_ROAD:     return VEHICLE_ROAD;

   217

		case VEH_TRAIN:    return VEHICLE_RAIL;

   218

		case VEH_SHIP:     return VEHICLE_WATER;

   219

		case VEH_AIRCRAFT: return VEHICLE_AIR;

   220

		default:           return VEHICLE_INVALID;

   221

	}

   222

}

   223