C_SOURCES += ai_old.c

#include "ai_new.h"

#include "ai_new.h"

#ifndef AI_H

#define AI_H

#include "aystar.h"

/*

 * These defines can be altered to change the behavoir of the AI

 *

 * WARNING:

 *   This can also alter the AI in a negative way. I will never claim these settings

 *   are perfect, but don't change them if you don't know what the effect is.

 */

// How many times it the H multiplied. The higher, the more it will go straight to the

//   end point. The lower, how more it will find the route with the lowest cost.

//   also: the lower, the longer it takes before route is calculated..

#define AI_PATHFINDER_H_MULTIPLER 100

// How many loops may AyStar do before it stops

//   0 = infinite

#define AI_PATHFINDER_LOOPS_PER_TICK 5

// How long may the AI search for one route?

//   0 = infinite

// This number is the number of tiles tested.

//  It takes (AI_PATHFINDER_MAX_SEARCH_NODES / AI_PATHFINDER_LOOPS_PER_TICK) ticks

//  to get here.. with 5000 / 10 = 500. 500 / 74 (one day) = 8 days till it aborts

//   (that is: if the AI is on VERY FAST! :p

#define AI_PATHFINDER_MAX_SEARCH_NODES 5000

// If you enable this, the AI is not allowed to make 90degree turns

#define AI_PATHFINDER_NO_90DEGREES_TURN

// Below are defines for the g-calculation

// Standard penalty given to a tile

#define AI_PATHFINDER_PENALTY 150

// The penalty given to a tile that is going up

#define AI_PATHFINDER_TILE_GOES_UP_PENALTY 450

// The penalty given to a tile which would have to use fundation

#define AI_PATHFINDER_FOUNDATION_PENALTY 100

// Changing direction is a penalty, to prevent curved ways (with that: slow ways)

#define AI_PATHFINDER_DIRECTION_CHANGE_PENALTY 200

// Same penalty, only for when road already exists

#define AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY 50

// A diagonal track cost the same as a straigh, but a diagonal is faster... so give

//  a bonus for using diagonal track

#ifdef AI_PATHFINDER_NO_90DEGREES_TURN

#define AI_PATHFINDER_DIAGONAL_BONUS 95

#else

#define AI_PATHFINDER_DIAGONAL_BONUS 75

#endif

// If a roadblock already exists, it gets a bonus

#define AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS 140

// To prevent 3 direction changes in 3 tiles, this penalty is given in such situation

#define AI_PATHFINDER_CURVE_PENALTY 200

// Penalty a bridge gets per length

#define AI_PATHFINDER_BRIDGE_PENALTY 180

// The penalty for a bridge going up

#define AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY 1000

// Tunnels are expensive...

//  Because of that, every tile the cost is increased with 1/8th of his value

//  This is also true if you are building a tunnel yourself

#define AI_PATHFINDER_TUNNEL_PENALTY 350

/*

 * Ai_New defines

 */

// How long may we search cities and industry for a new route?

#define AI_LOCATE_ROUTE_MAX_COUNTER 200

// How many days must there be between building the first station and the second station

//  within one city. This number is in days and should be more than 4 months.

#define AI_CHECKCITY_DATE_BETWEEN 180

// How many cargo is needed for one station in a city?

#define AI_CHECKCITY_CARGO_PER_STATION 60

// How much cargo must there not be used in a city before we can build a new station?

#define AI_CHECKCITY_NEEDED_CARGO 50

// When there is already a station which takes the same good and the rating of that

//  city is higher then this numer, we are not going to attempt to build anything

//  there

#define AI_CHECKCITY_CARGO_RATING 50

// But, there is a chance of 1 out of this number, that we do ;)

#define AI_CHECKCITY_CARGO_RATING_CHANCE 5

// If a city is too small to contain a station, there is a small chance

//  that we still do so.. just to make the city bigger!

#define AI_CHECKCITY_CITY_CHANCE 5

// This number indicates for every unit of cargo, how many tiles two stations maybe be away

//  from eachother. In other words: if we have 120 units of cargo in one station, and 120 units

//  of the cargo in the other station, both stations can be 96 units away from eachother, if the

//  next number is 0.4.

#define AI_LOCATEROUTE_BUS_CARGO_DISTANCE 0.4

#define AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE 0.7

// In whole tiles, the minimum distance for a truck route

#define AI_LOCATEROUTE_TRUCK_MIN_DISTANCE 30

// The amount of tiles in a square from -X to +X that is scanned for a station spot

//  (so if this number is 10, 20x20 = 400 tiles are scanned for _the_ perfect spot

// Safe values are between 15 and 5

#define AI_FINDSTATION_TILE_RANGE 10

// Building on normal speed goes very fast. Idle this amount of ticks between every

//  building part. It is calculated like this: (4 - competitor_speed) * num + 1

//  where competitor_speed is between 0 (very slow) to 4 (very fast)

#define AI_BUILDPATH_PAUSE 10

// Minimum % of reliabilty a vehicle has to have before the AI buys it

#define AI_VEHICLE_MIN_RELIABILTY 60

// The minimum amount of money a player should always have

#define AI_MINIMUM_MONEY 15000

// If the most cheap route is build, how much is it going to cost..

// This is to prevent the AI from trying to build a route which can not be paid for

#define AI_MINIMUM_BUS_ROUTE_MONEY 25000

#define AI_MINIMUM_TRUCK_ROUTE_MONEY 35000

// The minimum amount of money before we are going to repay any money

#define AI_MINIMUM_LOAN_REPAY_MONEY 40000

// How many repays do we do if we have enough money to do so?

//  Every repay is 10000

#define AI_LOAN_REPAY 2

// How much income must we have before paying back a loan? Month-based (and looked at the last month)

#define AI_MINIMUM_INCOME_FOR_LOAN 7000

// If there is <num> time as much cargo in the station then the vehicle can handle

//  reuse the station instead of building a new one!

#define AI_STATION_REUSE_MULTIPLER 2

// No more than this amount of vehicles per station..

#define AI_CHECK_MAX_VEHICLE_PER_STATION 10

// How many thick between building 2 vehicles

#define AI_BUILD_VEHICLE_TIME_BETWEEN DAY_TICKS

// How many days must there between vehicle checks

//  The more often, the less non-money-making lines there will be

//   but the unfair it may seem to a human player

#define AI_DAYS_BETWEEN_VEHICLE_CHECKS 30

// How money profit does a vehicle needs to make to stay in order

//  This is the profit of this year + profit of last year

//  But also for vehicles that are just one year old. In other words:

//   Vehicles of 2 years do easier meet this setting then vehicles

//   of one year. This is a very good thing. New vehicles are filtered,

//   while old vehicles stay longer, because we do get less in return.

#define AI_MINIMUM_ROUTE_PROFIT 1000

// A vehicle is considered lost when he his cargo is more than 180 days old

#define AI_VEHICLE_LOST_DAYS 180

// How many times may the AI try to find a route before it gives up

#define AI_MAX_TRIES_FOR_SAME_ROUTE 8

/*

 * End of defines

 */

// This stops 90degrees curves

static const byte _illegal_curves[6] = {

    255, 255, // Horz and vert, don't have the effect

    5, // upleft and upright are not valid

    4, // downright and downleft are not valid

    2, // downleft and upleft are not valid

    3, // upright and downright are not valid

};

enum {

    AI_STATE_STARTUP = 0,

    AI_STATE_FIRST_TIME,

    AI_STATE_NOTHING,

    AI_STATE_WAKE_UP,

    AI_STATE_LOCATE_ROUTE,

    AI_STATE_FIND_STATION,

    AI_STATE_FIND_PATH,

    AI_STATE_FIND_DEPOT,

    AI_STATE_VERIFY_ROUTE,

    AI_STATE_BUILD_STATION,

    AI_STATE_BUILD_PATH,

    AI_STATE_BUILD_DEPOT,

    AI_STATE_BUILD_VEHICLE,

    AI_STATE_GIVE_ORDERS,

    AI_STATE_START_VEHICLE,

    AI_STATE_REPAY_MONEY,

	AI_STATE_CHECK_ALL_VEHICLES,

    AI_STATE_ACTION_DONE,

    AI_STATE_STOP, // Temporary function to stop the AI

};

// Used for tbt (train/bus/truck)

enum {

	AI_TRAIN = 0,

	AI_BUS,

	AI_TRUCK,

};

enum {

	AI_ACTION_NONE = 0,

	AI_ACTION_BUS_ROUTE,

	AI_ACTION_TRUCK_ROUTE,

	AI_ACTION_REPAY_LOAN,

	AI_ACTION_CHECK_ALL_VEHICLES,

};

// Used for from_type/to_type

enum {

    AI_NO_TYPE = 0,

	AI_CITY,

	AI_INDUSTRY,

};

// Flags for in the vehicle

enum {

	AI_VEHICLEFLAG_SELL = 1,

	// Remember, flags must be in power of 2

};

#define AI_NO_CARGO 0xFF // Means that there is no cargo defined yet (used for industry)

#define AI_NEED_CARGO 0xFE // Used when the AI needs to find out a cargo for the route

#define AI_STATION_RANGE TileXY(MapMaxX(), MapMaxY())

#define AI_PATHFINDER_NO_DIRECTION (byte)-1

// Flags used in user_data

#define AI_PATHFINDER_FLAG_BRIDGE 1

#define AI_PATHFINDER_FLAG_TUNNEL 2

typedef void AiNew_StateFunction(Player *p);

// ai_new.c

void AiNewDoGameLoop(Player *p);

// ai_pathfinder.c

AyStar *new_AyStar_AiPathFinder(int max_tiles_around, Ai_PathFinderInfo *PathFinderInfo);

void clean_AyStar_AiPathFinder(AyStar *aystar, Ai_PathFinderInfo *PathFinderInfo);

// ai_shared.c

int AiNew_GetRailDirection(TileIndex tile_a, TileIndex tile_b, TileIndex tile_c);

int AiNew_GetRoadDirection(TileIndex tile_a, TileIndex tile_b, TileIndex tile_c);

int AiNew_GetDirection(TileIndex tile_a, TileIndex tile_b);

bool AiNew_SetSpecialVehicleFlag(Player *p, Vehicle *v, uint flag);

uint AiNew_GetSpecialVehicleFlag(Player *p, Vehicle *v);

// ai_build.c

bool AiNew_Build_CompanyHQ(Player *p, TileIndex tile);

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

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

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

int AiNew_PickVehicle(Player *p);

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

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

#endif

#include "stdafx.h"

#include "openttd.h"

#include "map.h"

#include "tile.h"

#include "player.h"

#include "vehicle.h"

#include "engine.h"

#include "command.h"

#include "town.h"

#include "industry.h"

#include "station.h"

#include "pathfind.h"

#include "economy.h"

#include "airport.h"

#include "depot.h"

// remove some day perhaps?

static Player *_cur_ai_player;

static uint _ai_service_interval;

typedef void AiStateAction(Player *p);

enum {

	AIS_0 = 0,

	AIS_1 = 1,

	AIS_VEH_LOOP = 2,

	AIS_VEH_CHECK_REPLACE_VEHICLE = 3,

	AIS_VEH_DO_REPLACE_VEHICLE = 4,

	AIS_WANT_NEW_ROUTE = 5,

	AIS_BUILD_DEFAULT_RAIL_BLOCKS = 6,

	AIS_BUILD_RAIL = 7,

	AIS_BUILD_RAIL_VEH = 8,

	AIS_DELETE_RAIL_BLOCKS = 9,

	AIS_BUILD_DEFAULT_ROAD_BLOCKS = 10,

	AIS_BUILD_ROAD = 11,

	AIS_BUILD_ROAD_VEHICLES = 12,

	AIS_DELETE_ROAD_BLOCKS = 13,

	AIS_AIRPORT_STUFF = 14,

	AIS_BUILD_DEFAULT_AIRPORT_BLOCKS = 15,

	AIS_BUILD_AIRCRAFT_VEHICLES = 16,

	AIS_CHECK_SHIP_STUFF = 17,

	AIS_BUILD_DEFAULT_SHIP_BLOCKS = 18,

	AIS_DO_SHIP_STUFF = 19,

	AIS_SELL_VEHICLE = 20,

	AIS_REMOVE_STATION = 21,

	AIS_REMOVE_TRACK = 22,

	AIS_REMOVE_SINGLE_RAIL_TILE = 23

};

#include "table/ai_rail.h"

static byte GetRailTrackStatus(TileIndex tile) {

	uint32 r = GetTileTrackStatus(tile, TRANSPORT_RAIL);

	return (byte) (r | r >> 8);

}

static void AiCase0(Player *p)

{

	p->ai.state = AIS_REMOVE_TRACK;

	p->ai.state_counter = 0;

}

static void AiCase1(Player *p)

{

	p->ai.cur_veh = NULL;

	p->ai.state = AIS_VEH_LOOP;

}

static void AiStateVehLoop(Player *p)

{

	Vehicle *v;

	uint index;

	index = (p->ai.cur_veh == NULL) ? 0 : p->ai.cur_veh->index + 1;

	FOR_ALL_VEHICLES_FROM(v, index) {

		if (v->type == 0 || v->owner != _current_player)

			continue;

		if ((v->type == VEH_Train && v->subtype==0) ||

				v->type == VEH_Road ||

				(v->type == VEH_Aircraft && v->subtype <= 2) ||

				v->type == VEH_Ship) {

			/* replace engine? */

			if (v->type == VEH_Train && v->engine_type < 3 &&

					(_price.build_railvehicle >> 3) < p->player_money) {

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

				p->ai.cur_veh = v;

				return;

			}

			/* not profitable? */

			if (v->age >= 730 &&

					v->profit_last_year < _price.station_value*5 &&

					v->profit_this_year < _price.station_value*5) {

				p->ai.state_counter = 0;

				p->ai.state = AIS_SELL_VEHICLE;

				p->ai.cur_veh = v;

				return;

			}

			/* not reliable? */

			if ((v->age != 0 &&

					GetEngine(v->engine_type)->reliability < 35389) ||

					v->age >= v->max_age) {

				p->ai.state = AIS_VEH_CHECK_REPLACE_VEHICLE;

				p->ai.cur_veh = v;

				return;

			}

		}

	}

	p->ai.state = AIS_WANT_NEW_ROUTE;

	p->ai.state_counter = 0;

}

static int AiChooseTrainToBuild(byte railtype, int32 money, byte flag, TileIndex tile)

{

	int best_veh_index = -1;

	byte best_veh_score = 0;

	int32 ret;

	int i;

	for (i = 0; i < NUM_TRAIN_ENGINES; i++) {

		const RailVehicleInfo *rvi = RailVehInfo(i);

		const Engine* e = GetEngine(i);

		if (e->railtype != railtype || rvi->flags & RVI_WAGON

		    || !HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D)

			continue;

		ret = DoCommandByTile(tile, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);

		if (!CmdFailed(ret) && (!(_cmd_build_rail_veh_var1&1) || !(flag&1)) && ret <= money &&

				_cmd_build_rail_veh_score >= best_veh_score) {

			best_veh_score = _cmd_build_rail_veh_score;

			best_veh_index = i;

		}

	}

	return best_veh_index;

}

static int AiChooseRoadVehToBuild(byte cargo, int32 money, TileIndex tile)

{

	int best_veh_index = -1;

	int32 best_veh_cost = 0;

	int32 ret;

	int i = _cargoc.ai_roadveh_start[cargo];

	int end = i + _cargoc.ai_roadveh_count[cargo];

	const Engine* e = GetEngine(i);

	do {

		if (!HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D)

			continue;

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

		if (!CmdFailed(ret) && ret <= money && ret >= best_veh_cost) {

			best_veh_cost = ret;

			best_veh_index = i;

		}

	} while (++e, ++i != end);

	return best_veh_index;

}

static int AiChooseAircraftToBuild(int32 money, byte flag)

{

	int best_veh_index = -1;

	int32 best_veh_cost = 0;

	int32 ret;

	int i = AIRCRAFT_ENGINES_INDEX;

	int end = i + NUM_AIRCRAFT_ENGINES;

	const Engine* e = GetEngine(i);

	do {

		if (!HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D)

			continue;

		if (flag&1) {

			if (i<253) continue;

		} else {

			if (i>=253) continue;

		}

		ret = DoCommandByTile(0, i, 0, 0, CMD_BUILD_AIRCRAFT);

		if (!CmdFailed(ret) && ret <= money && ret >= best_veh_cost) {

			best_veh_cost = ret;

			best_veh_index = i;

		}

	} while (++e, ++i != end);

	return best_veh_index;

}

static int32 AiGetBasePrice(Player *p)

{

	int32 base = _price.station_value;

	// adjust base price when more expensive vehicles are available

	if (p->ai.railtype_to_use == 1) base = (base * 3) >> 1;

	else if (p->ai.railtype_to_use == 2) base *= 2;

	return base;

}

#if 0

static int AiChooseShipToBuild(byte cargo, int32 money)

{

	// XXX: not done

	return 0;

}

#endif

static int AiChooseRoadVehToReplaceWith(Player *p, Vehicle *v)

{

	int32 avail_money = p->player_money + v->value;

	return AiChooseRoadVehToBuild(v->cargo_type, avail_money, v->tile);

}

static int AiChooseAircraftToReplaceWith(Player *p, Vehicle *v)

{

	int32 avail_money = p->player_money + v->value;

	return AiChooseAircraftToBuild(avail_money, v->engine_type>=253?1:0);

}

static int AiChooseTrainToReplaceWith(Player *p, Vehicle *v)

{

	int32 avail_money = p->player_money + v->value;

	int num=0;

	Vehicle *u = v;

	while (++num, u->next != NULL) {

		u = u->next;

	}

	// XXX: check if a wagon

	return AiChooseTrainToBuild(v->u.rail.railtype, avail_money, 0, v->tile);

}

static int AiChooseShipToReplaceWith(Player *p, Vehicle *v)

{

	error("!AiChooseShipToReplaceWith");

	/* maybe useless, but avoids compiler warning this way */

	return 0;

}

static void AiHandleGotoDepot(Player *p, int cmd)

{

	if (p->ai.cur_veh->current_order.type != OT_GOTO_DEPOT)

		DoCommandByTile(0, p->ai.cur_veh->index, 0, DC_EXEC, cmd);

	if (++p->ai.state_counter <= 1387) {

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

		return;

	}

	if (p->ai.cur_veh->current_order.type == OT_GOTO_DEPOT) {

		p->ai.cur_veh->current_order.type = OT_DUMMY;

		p->ai.cur_veh->current_order.flags = 0;

		InvalidateWindow(WC_VEHICLE_VIEW, p->ai.cur_veh->index);

	}

}

static void AiRestoreVehicleOrders(Vehicle *v, BackuppedOrders *bak)

{

	int i;

	for (i = 0; bak->order[i].type != OT_NOTHING; i++)

		if (CmdFailed(DoCommandP(0, v->index + (i << 16), PackOrder(&bak->order[i]), NULL, CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK)))

			break;

}

static void AiHandleReplaceTrain(Player *p)

{

	Vehicle *v = p->ai.cur_veh;

	BackuppedOrders orderbak[1];

	int veh;

	// wait until the vehicle reaches the depot.

	if (!IsTileDepotType(v->tile, TRANSPORT_RAIL) || v->u.rail.track != 0x80 || !(v->vehstatus&VS_STOPPED)) {

		AiHandleGotoDepot(p, CMD_TRAIN_GOTO_DEPOT);

		return;

	}

	veh = AiChooseTrainToReplaceWith(p, v);

	if (veh != -1) {

		TileIndex tile;

		BackupVehicleOrders(v, orderbak);

		tile = v->tile;

		if (!CmdFailed(DoCommandByTile(0, v->index, 2, DC_EXEC, CMD_SELL_RAIL_WAGON)) &&

			  !CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE)) ) {

			veh = _new_train_id;

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

			DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_TRAIN);

			DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_TRAIN_SERVICE_INT);

		}

	}

}

static void AiHandleReplaceRoadVeh(Player *p)

{

	Vehicle *v = p->ai.cur_veh;

	BackuppedOrders orderbak[1];

	int veh;

	if (!IsTileDepotType(v->tile, TRANSPORT_ROAD) || v->u.road.state != 254 || !(v->vehstatus&VS_STOPPED)) {

		AiHandleGotoDepot(p, CMD_SEND_ROADVEH_TO_DEPOT);

		return;

	}

	veh = AiChooseRoadVehToReplaceWith(p, v);

	if (veh != -1) {

		TileIndex tile;

		BackupVehicleOrders(v, orderbak);

		tile = v->tile;

		if (!CmdFailed(DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH)) &&

			  !CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH)) ) {

			veh = _new_roadveh_id;

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

			DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_ROADVEH);

			DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_TRAIN_SERVICE_INT);

		}

	}

}

static void AiHandleReplaceAircraft(Player *p)

{

	Vehicle *v = p->ai.cur_veh;

	int veh;

	BackuppedOrders orderbak[1];

	if (!IsAircraftHangarTile(v->tile) && !(v->vehstatus&VS_STOPPED)) {

		AiHandleGotoDepot(p, CMD_SEND_AIRCRAFT_TO_HANGAR);

		return;

	}

	veh = AiChooseAircraftToReplaceWith(p, v);

	if (veh != -1) {

		TileIndex tile;

		BackupVehicleOrders(v, orderbak);

		tile = v->tile;

		if (!CmdFailed(DoCommandByTile(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT)) &&

			  !CmdFailed(DoCommandByTile(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT)) ) {

			veh = _new_aircraft_id;

			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);

			DoCommandByTile(0, veh, 0, DC_EXEC, CMD_START_STOP_AIRCRAFT);

			DoCommandByTile(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_TRAIN_SERVICE_INT);

		}

	}

}

static void AiHandleReplaceShip(Player *p)

{

	error("!AiHandleReplaceShip");

}

typedef int CheckReplaceProc(Player *p, Vehicle *v);

static CheckReplaceProc * const _veh_check_replace_proc[] = {

	AiChooseTrainToReplaceWith,

	AiChooseRoadVehToReplaceWith,

	AiChooseShipToReplaceWith,

	AiChooseAircraftToReplaceWith,

};

typedef void DoReplaceProc(Player *p);

static DoReplaceProc * const _veh_do_replace_proc[] = {

	AiHandleReplaceTrain,

	AiHandleReplaceRoadVeh,

	AiHandleReplaceShip,

	AiHandleReplaceAircraft

};

static void AiStateCheckReplaceVehicle(Player *p)

{

	Vehicle *v = p->ai.cur_veh;

	if (v->type == 0 || v->owner != _current_player || v->type > VEH_Ship || _veh_check_replace_proc[v->type - VEH_Train](p, v) == -1) {

		p->ai.state = AIS_VEH_LOOP;

	} else {

		p->ai.state_counter = 0;

		p->ai.state = AIS_VEH_DO_REPLACE_VEHICLE;

	}

}

static void AiStateDoReplaceVehicle(Player *p)

{

	Vehicle *v = p->ai.cur_veh;

	p->ai.state = AIS_VEH_LOOP;

	// vehicle is not owned by the player anymore, something went very wrong.

	if (v->type == 0 || v->owner != _current_player)

		return;

	_veh_do_replace_proc[v->type - VEH_Train](p);

}

typedef struct FoundRoute {

	int distance;

	byte cargo;

	void *from;

	void *to;

} FoundRoute;

static Town *AiFindRandomTown(void)

{

	Town *t = GetTown(RandomRange(_total_towns));

	return (t->xy != 0) ? t : NULL;

}

static Industry *AiFindRandomIndustry(void)

{

	Industry *i = GetIndustry(RandomRange(_total_industries));

	return (i->xy != 0) ? i : NULL;

}

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)

{

	uint i;

	byte cargo;

	Subsidy *s;

	Industry *from, *to_ind;

	Town *to_tow;

	TileIndex to_xy;

	// initially error

	fr->distance = -1;

	// Randomize subsidy index..

	i = RandomRange(lengthof(_subsidies) * 3);

	if (i >= lengthof(_subsidies))

		return;

	s = &_subsidies[i];

	// Don't want passengers or mail

	cargo = s->cargo_type;

	if (cargo == 0xFF || cargo == CT_PASSENGERS || cargo == CT_MAIL || s->age > 7)

		return;

	fr->cargo = cargo;

	fr->from = from = GetIndustry(s->from);

	if (cargo == CT_GOODS || cargo == CT_FOOD) {

		to_tow = GetTown(s->to);

		if (to_tow->population < (uint32)(cargo == CT_FOOD ? 200 : 900))

			return; // error

		fr->to = to_tow;

		to_xy = to_tow->xy;

	} else {

		to_ind = GetIndustry(s->to);

		fr->to = to_ind;

		to_xy = to_ind->xy;

	}

	fr->distance = DistanceManhattan(from->xy, to_xy);

}

static void AiFindSubsidyPassengerRoute(FoundRoute *fr)

{

	uint i;

	Subsidy *s;

	Town *from,*to;

	// initially error

	fr->distance = -1;

	// Randomize subsidy index..

	i = RandomRange(lengthof(_subsidies) * 3);

	if (i >= lengthof(_subsidies))

		return;

	s = &_subsidies[i];

	// Only want passengers

	if (s->cargo_type != CT_PASSENGERS || s->age > 7)

		return;

	fr->cargo = s->cargo_type;

	fr->from = from = GetTown(s->from);

	fr->to = to = GetTown(s->to);

	// They must be big enough

	if (from->population < 400 || to->population < 400)

		return;

	fr->distance = DistanceManhattan(from->xy, to->xy);

}