static void AiNew_State_FirstTime(Player *p) {

    // This assert is used to protect those function from misuse

    //   You have quickly a small mistake in the state-array

    //   With that, everything would go wrong. Finding that, is almost impossible

    //   With this assert, that problem can never happen.

    assert(p->ainew.state == AI_STATE_FIRST_TIME);

    p->ainew.path_info.start_tile_tl = 0;

    p->ainew.path_info.start_tile_br = 0;

    p->ainew.path_info.end_tile_tl = 0;

    p->ainew.path_info.end_tile_br = 0;

static void AiNew_State_Nothing(Player *p) {

    assert(p->ainew.state == AI_STATE_NOTHING);

    // If we are done idling, start over again

static void AiNew_State_WakeUp(Player *p) {

		if (p->current_loan > 0 && p->old_economy[1].income > AI_MINIMUM_INCOME_FOR_LOAN &&

  			c < 10) {

  			p->ainew.action = AI_ACTION_REPAY_LOAN;

				if (c < 85) p->ainew.action = AI_ACTION_TRUCK_ROUTE;

				else p->ainew.action = AI_ACTION_BUS_ROUTE;

		p->ainew.action == AI_ACTION_BUS_ROUTE || p->ainew.action == AI_ACTION_TRUCK_ROUTE)) {

		p->ainew.action == AI_ACTION_BUS_ROUTE || p->ainew.action == AI_ACTION_TRUCK_ROUTE)) {

	if (p->ainew.action == AI_ACTION_REPAY_LOAN && money > AI_MINIMUM_LOAN_REPAY_MONEY) {

	if (p->ainew.action == AI_ACTION_BUS_ROUTE && money > AI_MINIMUM_BUS_ROUTE_MONEY) {

	if (p->ainew.action == AI_ACTION_TRUCK_ROUTE && money > AI_MINIMUM_TRUCK_ROUTE_MONEY) {

static void AiNew_State_ActionDone(Player *p) {

static bool AiNew_Check_City_or_Industry(Player *p, int ic, byte type) {

static void AiNew_State_LocateRoute(Player *p) {

    assert(p->ainew.state == AI_STATE_LOCATE_ROUTE);

    // For now, we only support PASSENGERS, CITY and BUSSES

    // We don't have a route yet

    if (p->ainew.cargo == AI_NEED_CARGO) {

    	p->ainew.new_cost = 0; // No cost yet

    	p->ainew.temp = -1;

    	// Reset the counter

    	p->ainew.counter = 0;

    	p->ainew.from_ic = -1;

    	p->ainew.to_ic = -1;

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

   	    	// For now we only have a passenger route

   	    	p->ainew.cargo = CT_PASSENGERS;

	    	// Find a route to cities

	    	p->ainew.from_type = AI_CITY;

	    	p->ainew.to_type = AI_CITY;

   	    	p->ainew.cargo = AI_NO_CARGO;

	    	p->ainew.from_type = AI_INDUSTRY;

	    	p->ainew.to_type = AI_INDUSTRY;

    	// Now we are doing initing, we wait one tick

    	return;

    }

    // Increase the counter and abort if it is taking too long!

    p->ainew.counter++;

    if (p->ainew.counter > AI_LOCATE_ROUTE_MAX_COUNTER) {

        // Switch back to doing nothing!

    	p->ainew.state = AI_STATE_NOTHING;

    	return;

    }

    // We are going to locate a city from where we are going to connect

    if (p->ainew.from_ic == -1) {

        if (p->ainew.temp == -1) {

        	// First, we pick a random spot to search from

        	if (p->ainew.from_type == AI_CITY)

        		p->ainew.temp = RandomRange(_total_towns);

       		else

        		p->ainew.temp = RandomRange(_total_industries);

        }

    	if (!AiNew_Check_City_or_Industry(p, p->ainew.temp, p->ainew.from_type)) {

    		// It was not a valid city

    		//  increase the temp with one, and return. We will come back later here

    		//  to try again

    		p->ainew.temp++;

				if (p->ainew.from_type == AI_CITY) {

					if (p->ainew.temp >= (int)_total_towns) p->ainew.temp = 0;

				} else {

					if (p->ainew.temp >= _total_industries) p->ainew.temp = 0;

				}

        	// Don't do an attempt if we are trying the same id as the last time...

        	if (p->ainew.last_id == p->ainew.temp) return;

        	p->ainew.last_id = p->ainew.temp;

    		return;

    	}

    	// We found a good city/industry, save the data of it

    	p->ainew.from_ic = p->ainew.temp;

    	// Start the next tick with finding a to-city

    	p->ainew.temp = -1;

    	return;

    }

    // Find a to-city

    if (p->ainew.temp == -1) {

       	// First, we pick a random spot to search to

       	if (p->ainew.to_type == AI_CITY)

       		p->ainew.temp = RandomRange(_total_towns);

       	else

       		p->ainew.temp = RandomRange(_total_industries);

   	if (p->ainew.temp != p->ainew.from_ic && AiNew_Check_City_or_Industry(p, p->ainew.temp, p->ainew.to_type)) {

   		// Maybe it is valid..

   		// We need to know if they are not to far apart from eachother..

   		// We do that by checking how much cargo we have to move and how long the route

   		//   is.

   		if (p->ainew.from_type == AI_CITY && p->ainew.tbt == AI_BUS) {

   			int max_cargo = GetTown(p->ainew.from_ic)->max_pass + GetTown(p->ainew.temp)->max_pass;

   			max_cargo -= GetTown(p->ainew.from_ic)->act_pass + GetTown(p->ainew.temp)->act_pass;

   			// max_cargo is now the amount of cargo we can move between the two cities

   			// If it is more than the distance, we allow it

   			if (DistanceManhattan(GetTown(p->ainew.from_ic)->xy, GetTown(p->ainew.temp)->xy) <= max_cargo * AI_LOCATEROUTE_BUS_CARGO_DISTANCE) {

   				// We found a good city/industry, save the data of it

   				p->ainew.to_ic = p->ainew.temp;

   				p->ainew.state = AI_STATE_FIND_STATION;

   				DEBUG(ai,1)(

						"[AiNew - LocateRoute] Found bus-route of %d tiles long (from %d to %d)",

						DistanceManhattan(GetTown(p->ainew.from_ic)->xy, GetTown(p->ainew.temp)->xy),

						p->ainew.from_ic,

						p->ainew.temp

					);

   				p->ainew.from_tile = 0;

   				p->ainew.to_tile = 0;

   				return;

   			}

   		} else if (p->ainew.tbt == AI_TRUCK) {

         	bool found = false;

         	int max_cargo = 0;

         	int i;

         	// TODO: in max_cargo, also check other cargo (beside [0])

         	// First we check if the from_ic produces cargo that this ic accepts

         	if (GetIndustry(p->ainew.from_ic)->produced_cargo[0] != 0xFF && GetIndustry(p->ainew.from_ic)->total_production[0] != 0) {

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

	         		if (GetIndustry(p->ainew.temp)->accepts_cargo[i] == 0xFF) break;

	   					p->ainew.from_deliver = true;

	   					p->ainew.to_deliver = false;

	       				break;

	       			}

	       		}

   			}

   			if (!found && GetIndustry(p->ainew.temp)->produced_cargo[0] != 0xFF && GetIndustry(p->ainew.temp)->total_production[0] != 0) {

   				// If not check if the current ic produces cargo that the from_ic accepts

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

	         		if (GetIndustry(p->ainew.from_ic)->accepts_cargo[i] == 0xFF) break;

	   					p->ainew.from_deliver = false;

	   					p->ainew.to_deliver = true;

	       				break;

	       			}

	   			}

   			}

   			if (found) {

   				// Yeah, they are compatible!!!

   				// Check the length against the amount of goods

   				if (DistanceManhattan(GetIndustry(p->ainew.from_ic)->xy, GetIndustry(p->ainew.temp)->xy) > AI_LOCATEROUTE_TRUCK_MIN_DISTANCE &&

       				DistanceManhattan(GetIndustry(p->ainew.from_ic)->xy, GetIndustry(p->ainew.temp)->xy) <= max_cargo * AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE) {

	   				p->ainew.to_ic = p->ainew.temp;

	   				if (p->ainew.from_deliver) {

	   					p->ainew.cargo = GetIndustry(p->ainew.from_ic)->produced_cargo[0];

	   				} else {

   						p->ainew.cargo = GetIndustry(p->ainew.temp)->produced_cargo[0];

   					}

	   				p->ainew.state = AI_STATE_FIND_STATION;

	   				DEBUG(ai,1)(

							"[AiNew - LocateRoute] Found truck-route of %d tiles long (from %d to %d)",

							DistanceManhattan(GetIndustry(p->ainew.from_ic)->xy, GetIndustry(p->ainew.temp)->xy),

							p->ainew.from_ic,

							p->ainew.temp

						);

	   				p->ainew.from_tile = 0;

	   				p->ainew.to_tile = 0;

	   				return;

	   			}

   			}

   		}

   	}

   	// Don't do an attempt if we are trying the same id as the last time...

   	if (p->ainew.last_id == p->ainew.temp) return;

   	p->ainew.last_id = p->ainew.temp;

static bool AiNew_CheckVehicleStation(Player *p, Station *st) {

static void AiNew_State_FindStation(Player *p) {

    TileIndex tile;

    Station *st;

    int i, count = 0;

    TileIndex new_tile = 0;

    byte direction = 0;

    Town *town = NULL;

    Industry *industry = NULL;

    assert(p->ainew.state == AI_STATE_FIND_STATION);

    if (p->ainew.from_tile == 0) {

        // First we scan for a station in the from-city

        if (p->ainew.from_type == AI_CITY) {

        	town = GetTown(p->ainew.from_ic);

        	tile = town->xy;

        } else {

        	industry = GetIndustry(p->ainew.from_ic);

        	tile = industry->xy;

        }

    } else if (p->ainew.to_tile == 0) {

    	// Second we scan for a station in the to-city

        if (p->ainew.to_type == AI_CITY) {

        	town = GetTown(p->ainew.to_ic);

        	tile = town->xy;

        } else {

        	industry = GetIndustry(p->ainew.to_ic);

        	tile = industry->xy;

        }

    } else {

    	// Unsupported request

    	// Go to FIND_PATH

        p->ainew.temp = -1;

        p->ainew.state = AI_STATE_FIND_PATH;

    	return;

    }

    // First, we are going to look at the stations that already exist inside the city

    //  If there is enough cargo left in the station, we take that station

    //  If that is not possible, and there are more than 2 stations in the city, abort

    if (new_tile == 0 && p->ainew.tbt == AI_BUS) {

	    uint x, y, i = 0;

	    int r;

	    uint best;

	    uint accepts[NUM_CARGO];

	    TileIndex found_spot[AI_FINDSTATION_TILE_RANGE*AI_FINDSTATION_TILE_RANGE*4];

	    uint found_best[AI_FINDSTATION_TILE_RANGE*AI_FINDSTATION_TILE_RANGE*4];

	    // To find a good spot we scan a range from the center, a get the point

	    //  where we get the most cargo and where it is buildable.

	    // TODO: also check for station of myself and make sure we are not

	    //   taking eachothers passangers away (bad result when it does not)

	    for (x = TileX(tile) - AI_FINDSTATION_TILE_RANGE; x <= TileX(tile) + AI_FINDSTATION_TILE_RANGE; x++) {

	    	for (y = TileY(tile) - AI_FINDSTATION_TILE_RANGE; y <= TileY(tile) + AI_FINDSTATION_TILE_RANGE; y++) {

	    		new_tile = TileXY(x, y);

	    		if (IsTileType(new_tile, MP_CLEAR) || IsTileType(new_tile, MP_TREES)) {

	    			// This tile we can build on!

	    			// Check acceptance

						// XXX - Get the catchment area

	    			GetAcceptanceAroundTiles(accepts, new_tile, 1, 1, 4);

	    			// >> 3 == 0 means no cargo

	    			if (accepts[p->ainew.cargo] >> 3 == 0) continue;

	    			// See if we can build the station

   	    			r = AiNew_Build_Station(p, p->ainew.tbt, new_tile, 0, 0, 0, DC_QUERY_COST);

   	    			if (r == CMD_ERROR) continue;

	    			// We can build it, so add it to found_spot

	    			found_spot[i] = new_tile;

	    			found_best[i++] = accepts[p->ainew.cargo];

	    		}

	    	}

	    }

	    // If i is still zero, we did not found anything :(

	    if (i == 0) {

	    	p->ainew.state = AI_STATE_NOTHING;

	    	return;

	    }

	    // Go through all the found_best and check which has the highest value

	    best = 0;

	    new_tile = 0;

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

	    	if (found_best[x] > best ||

	     		(found_best[x] == best && DistanceManhattan(tile, new_tile) > DistanceManhattan(tile, found_spot[x]))) {

	     		new_tile = found_spot[x];

	     		best = found_best[x];

	    	}

	    }

	   	p->ainew.from_tile = new_tile;

	   	p->ainew.from_direction = direction;

	   	// Now we found thisone, go in for to_tile

	   	return;

        p->ainew.to_tile = new_tile;

        p->ainew.to_direction = direction;

        // K, done placing stations!

        p->ainew.temp = -1;

        p->ainew.state = AI_STATE_FIND_PATH;

        return;

    }