1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "command.h"

     7

#include "ai.h"

     8

#include "engine.h"

     9

#include "station.h"

    10

    11

// Build HQ

    12

//  Params:

    13

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

    14

bool AiNew_Build_CompanyHQ(Player *p, uint tile) {

    15

	if (DoCommandByTile(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ) == CMD_ERROR)

    16

		return false;

    17

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

    18

	return true;

    19

}

    20

    21

// Build station

    22

//  Params:

    23

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

    24

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

    25

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

    26

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

    27

//    direction : the direction of the station

    28

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

    29

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

    30

	if (type == AI_TRAIN)

    31

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

    32

	else if (type == AI_BUS)

    33

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

    34

	else

    35

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

    36

}

    37

    38

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

    39

//  Params:

    40

//   tile_a : starting point

    41

//   tile_b : end point

    42

//   flag : flag passed to DoCommand

    43

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

    44

	int bridge_type, bridge_len, type, type2;

    45

    46

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

    47

	bridge_len = GetBridgeLength(tile_a, tile_b);

    48

	type = type2 = 0;

    49

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

    50

		if (CheckBridge_Stuff(bridge_type, bridge_len)) {

    51

			type2 = type;

    52

			type = bridge_type;

    53

			// We found two bridges, exit

    54

			if (type2 != 0)

    55

				break;

    56

		}

    57

	}

    58

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

    59

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

    60

    61

	// Now, simply, build the bridge!

    62

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

    63

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

    64

	else

    65

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

    66

}

    67

    68

    69

// Build the route part by part

    70

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

    71

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

    72

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

    73

//

    74

//  Params:

    75

//   PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder

    76

//   part : Which part we need to build

    77

//

    78

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

    79

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

    80

    int part = PathFinderInfo->position;

    81

	byte *route_extra = PathFinderInfo->route_extra;

    82

	TileIndex *route = PathFinderInfo->route;

    83

	int dir;

    84

	int old_dir = -1;

    85

	int cost = 0;

    86

	int res;

    87

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

    88

	//  the first pieces and the last piece

    89

	if (part < 1) part = 1;

    90

	// When we are done, stop it

    91

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

    92

    93

    94

	if (PathFinderInfo->rail_or_road) {

    95

		// Tunnel code

    96

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

    97

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

    98

     		PathFinderInfo->position++;

    99

     		// TODO: problems!

   100

     		if (cost == CMD_ERROR) {

   101

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

   102

				return 0;

   103

     		}

   104

     		return cost;

   105

     	}

   106

     	// Bridge code

   107

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

   108

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

   109

     		PathFinderInfo->position++;

   110

     		// TODO: problems!

   111

     		if (cost == CMD_ERROR) {

   112

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

   113

				return 0;

   114

     		}

   115

     		return cost;

   116

     	}

   117

   118

     	// Build normal rail

   119

     	// Keep it doing till we go an other way

   120

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

   121

     		while (route_extra[part] == 0) {

   122

	     		// Get the current direction

   123

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

   124

	     		// Is it the same as the last one?

   125

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

   126

	     		old_dir = dir;

   127

	     		// Build the tile

   128

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

   129

	     		if (res == CMD_ERROR) {

   130

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

   131

	     			p->ainew.state = AI_STATE_NOTHING;

   132

	     			return 0;

   133

	     		}

   134

	     		cost += res;

   135

	     		// Go to the next tile

   136

	     		part++;

   137

	     		// Check if it is still in range..

   138

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

   139

	     	}

   140

	     	part--;

   141

	    }

   142

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

   143

     	PathFinderInfo->position = part;

   144

    } else {

   145

		// Tunnel code

   146

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

   147

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

   148

     		PathFinderInfo->position++;

   149

     		// TODO: problems!

   150

     		if (cost == CMD_ERROR) {

   151

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

   152

				return 0;

   153

     		}

   154

     		return cost;

   155

     	}

   156

     	// Bridge code

   157

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

   158

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

   159

     		PathFinderInfo->position++;

   160

     		// TODO: problems!

   161

     		if (cost == CMD_ERROR) {

   162

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

   163

				return 0;

   164

     		}

   165

     		return cost;

   166

     	}

   167

   168

     	// Build normal road

   169

     	// Keep it doing till we go an other way

   170

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

   171

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

   172

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

   173

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

   174

	     		// Get the current direction

   175

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

   176

	     		// Is it the same as the last one?

   177

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

   178

	     		old_dir = dir;

   179

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

   180

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

   181

	     			// Build the tile

   182

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

   183

	     			// Currently, we ignore CMD_ERRORs!

   184

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

   185

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

   186

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

   187

    	     			p->ainew.state = AI_STATE_NOTHING;

   188

    	     			return 0;

   189

    	     		} else {

   190

    	     			if (res != CMD_ERROR)

   191

    	     				cost += res;

   192

    	     		}

   193

		     	}

   194

	     		// Go to the next tile

   195

	     		part++;

   196

	     		// Check if it is still in range..

   197

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

   198

	     	}

   199

	     	part--;

   200

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

   201

	    }

   202

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

   203

     	PathFinderInfo->position = part;

   204

    }

   205

   206

    return cost;

   207

}

   208

   209

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

   210

// It returns vehicle_id or -1 if not found

   211

int AiNew_PickVehicle(Player *p) {

   212

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

   213

        // Not supported yet

   214

        return -1;

   215

    } else {

   216

        int start, count, i, r = CMD_ERROR;

   217

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

   218

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

   219

   220

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

   221

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

   222

        	// Is it availiable?

   223

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

   224

        	if (!HASBIT(_engines[i].player_avail, _current_player) || _engines[i].reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue;

   225

        	// Can we build it?

   226

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

   227

        	if (r != CMD_ERROR) break;

   228

       	}

   229

       	// We did not find a vehicle :(

   230

       	if (r == CMD_ERROR) { return -1; }

   231

       	return i;

   232

    }

   233

}

   234

   235

// Builds the best vehicle possible

   236

int AiNew_Build_Vehicle(Player *p, uint tile, byte flag) {

   237

	int i = AiNew_PickVehicle(p);

   238

	if (i == -1) return CMD_ERROR;

   239

   240

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

   241

		return CMD_ERROR;

   242

	} else {

   243

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

   244

	}

   245

}

   246

   247

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

   248

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

   249

	int r, r2;

   250

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

   251

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

   252

    } else {

   253

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

   254

    	if (r == CMD_ERROR) return r;

   255

    	// Try to build the road from the depot

   256

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

   257

    	// If it fails, ignore it..

   258

    	if (r2 == CMD_ERROR) return r;

   259

    	return r + r2;

   260

    }

   261

}