1

/* $Id$ */

     2

     3

/** @file ai_order.cpp Implementation of AIOrder. */

     4

     5

#include "ai_order.hpp"

     6

#include "ai_map.hpp"

     7

#include "ai_vehicle.hpp"

     8

#include "../../openttd.h"

     9

#include "../../vehicle_base.h"

    10

#include "../../depot_base.h"

    11

#include "../../landscape.h"

    12

#include "../../rail_map.h"

    13

#include "../../road_map.h"

    14

#include "../../station_map.h"

    15

#include "../../water_map.h"

    16

#include "../../waypoint.h"

    17

    18

/**

    19

 * Gets the order type given a tile

    20

 * @param t the tile to get the order from

    21

 * @return the order type, or OT_END when there is no order

    22

 */

    23

static OrderType GetOrderTypeByTile(TileIndex t)

    24

{

    25

	if (!::IsValidTile(t)) return OT_END;

    26

    27

	switch (::GetTileType(t)) {

    28

		default: break;

    29

		case MP_STATION: return OT_GOTO_STATION; break;

    30

		case MP_WATER:   if (::IsShipDepot(t)) return OT_GOTO_DEPOT; break;

    31

		case MP_ROAD:    if (::GetRoadTileType(t) == ROAD_TILE_DEPOT) return OT_GOTO_DEPOT; break;

    32

		case MP_RAILWAY:

    33

			switch (::GetRailTileType(t)) {

    34

				case RAIL_TILE_DEPOT:    return OT_GOTO_DEPOT;

    35

				case RAIL_TILE_WAYPOINT: return OT_GOTO_WAYPOINT;

    36

				default: break;

    37

			}

    38

			break;

    39

	}

    40

    41

	return OT_END;

    42

}

    43

    44

/* static */ bool AIOrder::IsValidVehicleOrder(VehicleID vehicle_id, uint32 order_id)

    45

{

    46

	return AIVehicle::IsValidVehicle(vehicle_id) && order_id < ::GetVehicle(vehicle_id)->num_orders;

    47

}

    48

    49

/* static */ bool AIOrder::AreOrderFlagsValid(TileIndex destination, AIOrderFlags order_flags)

    50

{

    51

	switch (::GetOrderTypeByTile(destination)) {

    52

		case OT_GOTO_STATION:

    53

			return ((order_flags & ~(AIOF_NON_STOP_FLAGS | AIOF_UNLOAD_FLAGS | AIOF_LOAD_FLAGS)) == 0) &&

    54

					/* Test the different mutual exclusive flags. */

    55

					(((order_flags & AIOF_TRANSFER)      == 0) || ((order_flags & AIOF_UNLOAD)    == 0)) &&

    56

					(((order_flags & AIOF_TRANSFER)      == 0) || ((order_flags & AIOF_NO_UNLOAD) == 0)) &&

    57

					(((order_flags & AIOF_UNLOAD)        == 0) || ((order_flags & AIOF_NO_UNLOAD) == 0)) &&

    58

					(((order_flags & AIOF_UNLOAD)        == 0) || ((order_flags & AIOF_NO_UNLOAD) == 0)) &&

    59

					(((order_flags & AIOF_NO_UNLOAD)     == 0) || ((order_flags & AIOF_NO_LOAD)   == 0)) &&

    60

					(((order_flags & AIOF_FULL_LOAD_ANY) == 0) || ((order_flags & AIOF_NO_LOAD)   == 0));

    61

    62

		case OT_GOTO_DEPOT:    return (order_flags & ~(AIOF_NON_STOP_FLAGS | AIOF_SERVICE_IF_NEEDED)) == 0;

    63

		case OT_GOTO_WAYPOINT: return (order_flags & ~(AIOF_NON_STOP_FLAGS)) == 0;

    64

		default:               return false;

    65

	}

    66

}

    67

    68

/* static */ int32 AIOrder::GetOrderCount(VehicleID vehicle_id)

    69

{

    70

	return AIVehicle::IsValidVehicle(vehicle_id) ? ::GetVehicle(vehicle_id)->num_orders : -1;

    71

}

    72

    73

/* static */ TileIndex AIOrder::GetOrderDestination(VehicleID vehicle_id, uint32 order_id)

    74

{

    75

	if (!IsValidVehicleOrder(vehicle_id, order_id)) return INVALID_TILE;

    76

    77

	Order *order = ::GetVehicle(vehicle_id)->orders;

    78

	for (uint i = 0; i < order_id; i++) order = order->next;

    79

    80

	switch (order->GetType()) {

    81

		case OT_GOTO_DEPOT:    return ::GetDepot(order->GetDestination())->xy;

    82

		case OT_GOTO_STATION:  return ::GetStation(order->GetDestination())->xy;

    83

		case OT_GOTO_WAYPOINT: return ::GetWaypoint(order->GetDestination())->xy;

    84

		default:               return INVALID_TILE;

    85

	}

    86

}

    87

    88

/* static */ AIOrder::AIOrderFlags AIOrder::GetOrderFlags(VehicleID vehicle_id, uint32 order_id)

    89

{

    90

	if (!IsValidVehicleOrder(vehicle_id, order_id)) return AIOF_INVALID;

    91

    92

	Order *order = ::GetVehicle(vehicle_id)->orders;

    93

	for (uint i = 0; i < order_id; i++) order = order->next;

    94

    95

	AIOrderFlags order_flags = AIOF_NONE;

    96

	order_flags |= (AIOrderFlags)order->GetNonStopType();

    97

	switch (order->GetType()) {

    98

		case OT_GOTO_DEPOT:

    99

			if (order->GetDepotOrderType() & ODTFB_SERVICE) order_flags |= AIOF_SERVICE_IF_NEEDED;

   100

			break;

   101

   102

		case OT_GOTO_STATION:

   103

			order_flags |= (AIOrderFlags)(order->GetLoadType()   << 5);

   104

			order_flags |= (AIOrderFlags)(order->GetUnloadType() << 2);

   105

			break;

   106

   107

		default: break;

   108

	}

   109

   110

	return order_flags;

   111

}

   112

   113

/* static */ bool AIOrder::AppendOrder(VehicleID vehicle_id, TileIndex destination, AIOrderFlags order_flags)

   114

{

   115

	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));

   116

	return InsertOrder(vehicle_id, ::GetVehicle(vehicle_id)->num_orders, destination, order_flags);

   117

}

   118

   119

/* static */ bool AIOrder::InsertOrder(VehicleID vehicle_id, uint32 order_id, TileIndex destination, AIOrder::AIOrderFlags order_flags)

   120

{

   121

	/* IsValidVehicleOrder is not good enough because it does not allow appending. */

   122

	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));

   123

	EnforcePrecondition(false, order_id <= ::GetVehicle(vehicle_id)->num_orders);

   124

	EnforcePrecondition(false, AreOrderFlagsValid(destination, order_flags));

   125

   126

	Order order;

   127

	switch (::GetOrderTypeByTile(destination)) {

   128

		case OT_GOTO_DEPOT:

   129

			order.MakeGoToDepot(::GetDepotByTile(destination)->index, (OrderDepotTypeFlags)(ODTFB_PART_OF_ORDERS | ((order_flags & AIOF_SERVICE_IF_NEEDED) ? ODTFB_SERVICE : 0)));

   130

			break;

   131

   132

		case OT_GOTO_STATION:

   133

			order.MakeGoToStation(::GetStationIndex(destination));

   134

			order.SetLoadType((OrderLoadFlags)GB(order_flags, 5, 3));

   135

			order.SetUnloadType((OrderUnloadFlags)GB(order_flags, 2, 3));

   136

			break;

   137

   138

		case OT_GOTO_WAYPOINT:

   139

			order.MakeGoToWaypoint(::GetWaypointIndex(destination));

   140

			break;

   141

   142

		default:

   143

			return false;

   144

	}

   145

   146

	order.SetNonStopType((OrderNonStopFlags)GB(order_flags, 0, 2));

   147

   148

	return AIObject::DoCommand(0, vehicle_id | (order_id << 16), order.Pack(), CMD_INSERT_ORDER);

   149

}

   150

   151

/* static */ bool AIOrder::RemoveOrder(VehicleID vehicle_id, uint32 order_id)

   152

{

   153

	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_id));

   154

   155

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

   156

}

   157

   158

/* static */ bool AIOrder::ChangeOrder(VehicleID vehicle_id, uint32 order_id, AIOrder::AIOrderFlags order_flags)

   159

{

   160

	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_id));

   161

	EnforcePrecondition(false, AreOrderFlagsValid(GetOrderDestination(vehicle_id, order_id), order_flags));

   162

   163

	Order *order = ::GetVehicle(vehicle_id)->orders;

   164

	for (uint i = 0; i < order_id; i++) order = order->next;

   165

   166

	AIOrderFlags current = GetOrderFlags(vehicle_id, order_id);

   167

   168

	if ((current & AIOF_NON_STOP_FLAGS) != (order_flags & AIOF_NON_STOP_FLAGS)) {

   169

		bool res = AIObject::DoCommand(0, vehicle_id | (order_id << 16), (order_flags & AIOF_NON_STOP_FLAGS) << 4 | MOF_NON_STOP, CMD_MODIFY_ORDER);

   170

		if (!res) return false;

   171

	}

   172

   173

	switch (order->GetType()) {

   174

		case OT_GOTO_DEPOT:

   175

			if ((current & AIOF_SERVICE_IF_NEEDED) != (order_flags & AIOF_SERVICE_IF_NEEDED)) {

   176

				bool res = AIObject::DoCommand(0, vehicle_id | (order_id << 16), MOF_DEPOT_ACTION, CMD_MODIFY_ORDER);

   177

				if (!res) return false;

   178

			}

   179

			break;

   180

   181

		case OT_GOTO_STATION:

   182

			if ((current & AIOF_UNLOAD_FLAGS) != (order_flags & AIOF_UNLOAD_FLAGS)) {

   183

				bool res = AIObject::DoCommand(0, vehicle_id | (order_id << 16), (order_flags & AIOF_UNLOAD_FLAGS) << 2 | MOF_UNLOAD, CMD_MODIFY_ORDER);

   184

				if (!res) return false;

   185

			}

   186

			if ((current & AIOF_LOAD_FLAGS) != (order_flags & AIOF_LOAD_FLAGS)) {

   187

				bool res = AIObject::DoCommand(0, vehicle_id | (order_id << 16), (order_flags & AIOF_LOAD_FLAGS) >> 1 | MOF_LOAD, CMD_MODIFY_ORDER);

   188

				if (!res) return false;

   189

			}

   190

			break;

   191

   192

		default: break;

   193

	}

   194

   195

	assert(GetOrderFlags(vehicle_id, order_id) == order_flags);

   196

   197

	return true;

   198

}

   199

   200

/* static */ bool AIOrder::MoveOrder(VehicleID vehicle_id, uint32 order_id_move, uint32 order_id_target)

   201

{

   202

	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_id_move));

   203

	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_id_target));

   204

   205

	return AIObject::DoCommand(0, vehicle_id, order_id_move | (order_id_target << 16), CMD_MOVE_ORDER);

   206

}

   207

   208

/* static */ bool AIOrder::CopyOrders(VehicleID vehicle_id, VehicleID main_vehicle_id)

   209

{

   210

	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));

   211

	EnforcePrecondition(false, AIVehicle::IsValidVehicle(main_vehicle_id));

   212

   213

	return AIObject::DoCommand(0, vehicle_id | (main_vehicle_id << 16), CO_COPY, CMD_CLONE_ORDER);

   214

}

   215

   216

/* static */ bool AIOrder::ShareOrders(VehicleID vehicle_id, VehicleID main_vehicle_id)

   217

{

   218

	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));

   219

	EnforcePrecondition(false, AIVehicle::IsValidVehicle(main_vehicle_id));

   220

   221

	return AIObject::DoCommand(0, vehicle_id | (main_vehicle_id << 16), CO_SHARE, CMD_CLONE_ORDER);

   222

}

   223

   224

/* static */ bool AIOrder::UnshareOrders(VehicleID vehicle_id)

   225

{

   226

	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));

   227

   228

	return AIObject::DoCommand(0, vehicle_id, CO_UNSHARE, CMD_CLONE_ORDER);

   229

}