1

/* $Id$ */

     2

     3

#include "../../stdafx.h"

     4

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

     5

#include "../../debug.h"

     6

#include "../../functions.h"

     7

#include "../../map.h"

     8

#include "../../tile.h"

     9

#include "../../command.h"

    10

#include "trolly.h"

    11

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

    12

#include "../../station.h"

    13

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

    14

#include "../ai.h"

    15

    16

// Build HQ

    17

//  Params:

    18

//    tile : tile where HQ is going to be build

    19

bool AiNew_Build_CompanyHQ(Player *p, TileIndex tile)

    20

{

    21

	if (CmdFailed(AI_DoCommand(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ)))

    22

		return false;

    23

	AI_DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ);

    24

	return true;

    25

}

    26

    27

    28

// Build station

    29

//  Params:

    30

//    type : AI_TRAIN/AI_BUS/AI_TRUCK : indicates the type of station

    31

//    tile : tile where station is going to be build

    32

//    length : in case of AI_TRAIN: length of station

    33

//    numtracks : in case of AI_TRAIN: tracks of station

    34

//    direction : the direction of the station

    35

//    flag : flag passed to DoCommand (normally 0 to get the cost or DC_EXEC to build it)

    36

int AiNew_Build_Station(Player *p, byte type, TileIndex tile, byte length, byte numtracks, byte direction, byte flag)

    37

{

    38

	if (type == AI_TRAIN)

    39

		return AI_DoCommand(tile, direction + (numtracks << 8) + (length << 16), 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_RAILROAD_STATION);

    40

    41

	if (type == AI_BUS)

    42

		return AI_DoCommand(tile, direction, RS_BUS, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP);

    43

    44

	return AI_DoCommand(tile, direction, RS_TRUCK, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP);

    45

}

    46

    47

    48

// Builds a brdige. The second best out of the ones available for this player

    49

//  Params:

    50

//   tile_a : starting point

    51

//   tile_b : end point

    52

//   flag : flag passed to DoCommand

    53

int AiNew_Build_Bridge(Player *p, TileIndex tile_a, TileIndex tile_b, byte flag)

    54

{

    55

	int bridge_type, bridge_len, type, type2;

    56

    57

	// Find a good bridgetype (the best money can buy)

    58

	bridge_len = GetBridgeLength(tile_a, tile_b);

    59

	type = type2 = 0;

    60

	for (bridge_type = MAX_BRIDGES-1; bridge_type >= 0; bridge_type--) {

    61

		if (CheckBridge_Stuff(bridge_type, bridge_len)) {

    62

			type2 = type;

    63

			type = bridge_type;

    64

			// We found two bridges, exit

    65

			if (type2 != 0) break;

    66

		}

    67

	}

    68

	// There is only one bridge that can be build..

    69

	if (type2 == 0 && type != 0) type2 = type;

    70

    71

	// Now, simply, build the bridge!

    72

	if (p->ainew.tbt == AI_TRAIN)

    73

		return AI_DoCommand(tile_a, tile_b, (0<<8) + type2, flag | DC_AUTO, CMD_BUILD_BRIDGE);

    74

    75

	return AI_DoCommand(tile_a, tile_b, (0x80 << 8) + type2, flag | DC_AUTO, CMD_BUILD_BRIDGE);

    76

}

    77

    78

    79

// Build the route part by part

    80

// Basicly what this function do, is build that amount of parts of the route

    81

//  that go in the same direction. It sets 'part' to the last part of the route builded.

    82

//  The return value is the cost for the builded parts

    83

//

    84

//  Params:

    85

//   PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder

    86

//   part : Which part we need to build

    87

//

    88

// TODO: skip already builded road-pieces (e.g.: cityroad)

    89

int AiNew_Build_RoutePart(Player *p, Ai_PathFinderInfo *PathFinderInfo, byte flag)

    90

{

    91

	int part = PathFinderInfo->position;

    92

	byte *route_extra = PathFinderInfo->route_extra;

    93

	TileIndex *route = PathFinderInfo->route;

    94

	int dir;

    95

	int old_dir = -1;

    96

	int cost = 0;

    97

	int res;

    98

	// We need to calculate the direction with the parent of the parent.. so we skip

    99

	//  the first pieces and the last piece

   100

	if (part < 1) part = 1;

   101

	// When we are done, stop it

   102

	if (part >= PathFinderInfo->route_length - 1) { PathFinderInfo->position = -2; return 0; }

   103

   104

   105

	if (PathFinderInfo->rail_or_road) {

   106

		// Tunnel code

   107

		if ((AI_PATHFINDER_FLAG_TUNNEL & route_extra[part]) != 0) {

   108

			cost += AI_DoCommand(route[part], 0, 0, flag, CMD_BUILD_TUNNEL);

   109

			PathFinderInfo->position++;

   110

			// TODO: problems!

   111

			if (CmdFailed(cost)) {

   112

				DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: tunnel could not be build!");

   113

				return 0;

   114

			}

   115

			return cost;

   116

		}

   117

		// Bridge code

   118

		if ((AI_PATHFINDER_FLAG_BRIDGE & route_extra[part]) != 0) {

   119

			cost += AiNew_Build_Bridge(p, route[part], route[part-1], flag);

   120

			PathFinderInfo->position++;

   121

			// TODO: problems!

   122

			if (CmdFailed(cost)) {

   123

				DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: bridge could not be build!");

   124

				return 0;

   125

			}

   126

			return cost;

   127

		}

   128

   129

		// Build normal rail

   130

		// Keep it doing till we go an other way

   131

		if (route_extra[part-1] == 0 && route_extra[part] == 0) {

   132

			while (route_extra[part] == 0) {

   133

				// Get the current direction

   134

				dir = AiNew_GetRailDirection(route[part-1], route[part], route[part+1]);

   135

				// Is it the same as the last one?

   136

				if (old_dir != -1 && old_dir != dir) break;

   137

				old_dir = dir;

   138

				// Build the tile

   139

				res = AI_DoCommand(route[part], 0, dir, flag, CMD_BUILD_SINGLE_RAIL);

   140

				if (CmdFailed(res)) {

   141

					// Problem.. let's just abort it all!

   142

					p->ainew.state = AI_STATE_NOTHING;

   143

					return 0;

   144

				}

   145

				cost += res;

   146

				// Go to the next tile

   147

				part++;

   148

				// Check if it is still in range..

   149

				if (part >= PathFinderInfo->route_length - 1) break;

   150

			}

   151

			part--;

   152

		}

   153

		// We want to return the last position, so we go back one

   154

		PathFinderInfo->position = part;

   155

	} else {

   156

		// Tunnel code

   157

		if ((AI_PATHFINDER_FLAG_TUNNEL & route_extra[part]) != 0) {

   158

			cost += AI_DoCommand(route[part], 0x200, 0, flag, CMD_BUILD_TUNNEL);

   159

			PathFinderInfo->position++;

   160

			// TODO: problems!

   161

			if (CmdFailed(cost)) {

   162

				DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: tunnel could not be build!");

   163

				return 0;

   164

			}

   165

			return cost;

   166

		}

   167

		// Bridge code

   168

		if ((AI_PATHFINDER_FLAG_BRIDGE & route_extra[part]) != 0) {

   169

			cost += AiNew_Build_Bridge(p, route[part], route[part+1], flag);

   170

			PathFinderInfo->position++;

   171

			// TODO: problems!

   172

			if (CmdFailed(cost)) {

   173

				DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: bridge could not be build!");

   174

				return 0;

   175

			}

   176

			return cost;

   177

		}

   178

   179

		// Build normal road

   180

		// Keep it doing till we go an other way

   181

		// EnsureNoVehicle makes sure we don't build on a tile where a vehicle is. This way

   182

		//  it will wait till the vehicle is gone..

   183

		if (route_extra[part-1] == 0 && route_extra[part] == 0 && (flag != DC_EXEC || EnsureNoVehicle(route[part]))) {

   184

			while (route_extra[part] == 0 && (flag != DC_EXEC || EnsureNoVehicle(route[part]))) {

   185

				// Get the current direction

   186

				dir = AiNew_GetRoadDirection(route[part-1], route[part], route[part+1]);

   187

				// Is it the same as the last one?

   188

				if (old_dir != -1 && old_dir != dir) break;

   189

				old_dir = dir;

   190

				// There is already some road, and it is a bridge.. don't build!!!

   191

				if (!IsTileType(route[part], MP_TUNNELBRIDGE)) {

   192

					// Build the tile

   193

					res = AI_DoCommand(route[part], dir, 0, flag | DC_NO_WATER, CMD_BUILD_ROAD);

   194

					// Currently, we ignore CMD_ERRORs!

   195

					if (CmdFailed(res) && flag == DC_EXEC && !IsTileType(route[part], MP_STREET) && !EnsureNoVehicle(route[part])) {

   196

						// Problem.. let's just abort it all!

   197

						DEBUG(ai,0)("Darn, the route could not be builded.. aborting!");

   198

						p->ainew.state = AI_STATE_NOTHING;

   199

						return 0;

   200

					}

   201

   202

					if (!CmdFailed(res)) cost += res;

   203

				}

   204

				// Go to the next tile

   205

				part++;

   206

				// Check if it is still in range..

   207

				if (part >= PathFinderInfo->route_length - 1) break;

   208

			}

   209

			part--;

   210

			// We want to return the last position, so we go back one

   211

		}

   212

		if (!EnsureNoVehicle(route[part]) && flag == DC_EXEC) part--;

   213

		PathFinderInfo->position = part;

   214

	}

   215

   216

	return cost;

   217

}

   218

   219

   220

// This functions tries to find the best vehicle for this type of cargo

   221

// It returns vehicle_id or -1 if not found

   222

int AiNew_PickVehicle(Player *p)

   223

{

   224

	if (p->ainew.tbt == AI_TRAIN) {

   225

		// Not supported yet

   226

		return -1;

   227

	} else {

   228

		int start, count, i, ret = CMD_ERROR;

   229

		start = _cargoc.ai_roadveh_start[p->ainew.cargo];

   230

		count = _cargoc.ai_roadveh_count[p->ainew.cargo];

   231

   232

		// Let's check it backwards.. we simply want to best engine available..

   233

		for (i = start + count - 1; i >= start; i--) {

   234

			// Is it availiable?

   235

			// Also, check if the reliability of the vehicle is above the AI_VEHICLE_MIN_RELIABILTY

   236

			if (!HASBIT(GetEngine(i)->player_avail, _current_player) || GetEngine(i)->reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue;

   237

			// Can we build it?

   238

			ret = AI_DoCommand(0, i, 0, DC_QUERY_COST, CMD_BUILD_ROAD_VEH);

   239

			if (!CmdFailed(ret)) break;

   240

		}

   241

		// We did not find a vehicle :(

   242

		if (CmdFailed(ret)) return -1;

   243

		return i;

   244

	}

   245

}

   246

   247

   248

// Builds the best vehicle possible

   249

int AiNew_Build_Vehicle(Player *p, TileIndex tile, byte flag)

   250

{

   251

	int i = AiNew_PickVehicle(p);

   252

	if (i == -1) return CMD_ERROR;

   253

   254

	if (p->ainew.tbt == AI_TRAIN) return CMD_ERROR;

   255

   256

	return AI_DoCommand(tile, i, 0, flag, CMD_BUILD_ROAD_VEH);

   257

}

   258

   259

int AiNew_Build_Depot(Player *p, TileIndex tile, byte direction, byte flag)

   260

{

   261

	static const byte _roadbits_by_dir[4] = {2,1,8,4};

   262

	int ret, ret2;

   263

	if (p->ainew.tbt == AI_TRAIN)

   264

		return AI_DoCommand(tile, 0, direction, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_TRAIN_DEPOT);

   265

   266

	ret = AI_DoCommand(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_DEPOT);

   267

	if (CmdFailed(ret)) return ret;

   268

	// Try to build the road from the depot

   269

	ret2 = AI_DoCommand(tile + TileOffsByDir(direction), _roadbits_by_dir[direction], 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);

   270

	// If it fails, ignore it..

   271

	if (CmdFailed(ret2)) return ret;

   272

	return ret + ret2;

   273

}