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

    11

#include "engine.h"

    12

#include "station.h"

    13

#include "variables.h"

    14

    15

// Build HQ

    16

//  Params:

    17

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

    18

bool AiNew_Build_CompanyHQ(Player *p, TileIndex tile)

    19

{

    20

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

    21

		return false;

    22

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

    23

	return true;

    24

}

    25

    26

// Build station

    27

//  Params:

    28

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

    29

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

    30

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

    31

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

    32

//    direction : the direction of the station

    33

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

    34

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

    35

{

    36

	if (type == AI_TRAIN)

    37

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

    38

    39

	if (type == AI_BUS)

    40

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

    41

    42

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

    43

}

    44

    45

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

    46

//  Params:

    47

//   tile_a : starting point

    48

//   tile_b : end point

    49

//   flag : flag passed to DoCommand

    50

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

    51

{

    52

	int bridge_type, bridge_len, type, type2;

    53

    54

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

    55

	bridge_len = GetBridgeLength(tile_a, tile_b);

    56

	type = type2 = 0;

    57

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

    58

		if (CheckBridge_Stuff(bridge_type, bridge_len)) {

    59

			type2 = type;

    60

			type = bridge_type;

    61

			// We found two bridges, exit

    62

			if (type2 != 0)

    63

				break;

    64

		}

    65

	}

    66

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

    67

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

    68

    69

	// Now, simply, build the bridge!

    70

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

    71

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

    72

    73

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

    74

}

    75

    76

    77

// Build the route part by part

    78

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

    79

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

    80

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

    81

//

    82

//  Params:

    83

//   PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder

    84

//   part : Which part we need to build

    85

//

    86

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

    87

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

    88

    int part = PathFinderInfo->position;

    89

	byte *route_extra = PathFinderInfo->route_extra;

    90

	TileIndex *route = PathFinderInfo->route;

    91

	int dir;

    92

	int old_dir = -1;

    93

	int cost = 0;

    94

	int res;

    95

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

    96

	//  the first pieces and the last piece

    97

	if (part < 1) part = 1;

    98

	// When we are done, stop it

    99

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

   100

   101

   102

	if (PathFinderInfo->rail_or_road) {

   103

		// Tunnel code

   104

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

   105

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

   106

     		PathFinderInfo->position++;

   107

     		// TODO: problems!

   108

     		if (CmdFailed(cost)) {

   109

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

   110

				return 0;

   111

     		}

   112

     		return cost;

   113

     	}

   114

     	// Bridge code

   115

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

   116

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

   117

     		PathFinderInfo->position++;

   118

     		// TODO: problems!

   119

     		if (CmdFailed(cost)) {

   120

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

   121

				return 0;

   122

     		}

   123

     		return cost;

   124

     	}

   125

   126

     	// Build normal rail

   127

     	// Keep it doing till we go an other way

   128

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

   129

     		while (route_extra[part] == 0) {

   130

	     		// Get the current direction

   131

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

   132

	     		// Is it the same as the last one?

   133

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

   134

	     		old_dir = dir;

   135

	     		// Build the tile

   136

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

   137

	     		if (CmdFailed(res)) {

   138

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

   139

	     			p->ainew.state = AI_STATE_NOTHING;

   140

	     			return 0;

   141

	     		}

   142

	     		cost += res;

   143

	     		// Go to the next tile

   144

	     		part++;

   145

	     		// Check if it is still in range..

   146

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

   147

	     	}

   148

	     	part--;

   149

	    }

   150

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

   151

     	PathFinderInfo->position = part;

   152

    } else {

   153

		// Tunnel code

   154

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

   155

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

   156

     		PathFinderInfo->position++;

   157

     		// TODO: problems!

   158

     		if (CmdFailed(cost)) {

   159

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

   160

				return 0;

   161

     		}

   162

     		return cost;

   163

     	}

   164

     	// Bridge code

   165

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

   166

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

   167

     		PathFinderInfo->position++;

   168

     		// TODO: problems!

   169

     		if (CmdFailed(cost)) {

   170

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

   171

				return 0;

   172

     		}

   173

     		return cost;

   174

     	}

   175

   176

     	// Build normal road

   177

     	// Keep it doing till we go an other way

   178

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

   179

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

   180

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

   181

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

   182

	     		// Get the current direction

   183

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

   184

	     		// Is it the same as the last one?

   185

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

   186

	     		old_dir = dir;

   187

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

   188

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

   189

	     			// Build the tile

   190

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

   191

	     			// Currently, we ignore CMD_ERRORs!

   192

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

   193

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

   194

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

   195

							p->ainew.state = AI_STATE_NOTHING;

   196

							return 0;

   197

						}

   198

   199

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

   200

		     	}

   201

	     		// Go to the next tile

   202

	     		part++;

   203

	     		// Check if it is still in range..

   204

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

   205

	     	}

   206

	     	part--;

   207

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

   208

	    }

   209

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

   210

     	PathFinderInfo->position = part;

   211

    }

   212

   213

    return cost;

   214

}

   215

   216

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

   217

// It returns vehicle_id or -1 if not found

   218

int AiNew_PickVehicle(Player *p) {

   219

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

   220

        // Not supported yet

   221

        return -1;

   222

    } else {

   223

        int start, count, i, ret = CMD_ERROR;

   224

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

   225

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

   226

   227

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

   228

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

   229

        	// Is it availiable?

   230

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

   231

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

   232

        	// Can we build it?

   233

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

   234

        	if (!CmdFailed(ret)) break;

   235

       	}

   236

       	// We did not find a vehicle :(

   237

       	if (CmdFailed(ret)) { return -1; }

   238

       	return i;

   239

    }

   240

}

   241

   242

// Builds the best vehicle possible

   243

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

   244

{

   245

	int i = AiNew_PickVehicle(p);

   246

	if (i == -1) return CMD_ERROR;

   247

   248

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

   249

		return CMD_ERROR;

   250

   251

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

   252

}

   253

   254

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

   255

{

   256

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

   257

	int ret, ret2;

   258

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

   259

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

   260

   261

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

   262

		if (CmdFailed(ret)) return ret;

   263

		// Try to build the road from the depot

   264

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

   265

		// If it fails, ignore it..

   266

		if (CmdFailed(ret2)) return ret;

   267

		return ret + ret2;

   268

}