default.cpp

Go to the documentation of this file.

/* $Id: default.cpp 14464 2008-10-14 18:38:51Z rubidium $ */

#include "../../stdafx.h"
#include "../../openttd.h"
#include "../../aircraft.h"
#include "../../bridge_map.h"
#include "../../tile_cmd.h"
#include "../../landscape.h"
#include "../../rail_map.h"
#include "../../road_map.h"
#include "../../roadveh.h"
#include "../../station_map.h"
#include "../../tunnel_map.h"
#include "../../command_func.h"
#include "../../town.h"
#include "../../industry.h"
#include "../../pathfind.h"
#include "../../airport.h"
#include "../../variables.h"
#include "../../bridge.h"
#include "../../date_func.h"
#include "../../tunnelbridge_map.h"
#include "../../window_func.h"
#include "../../vehicle_func.h"
#include "../../functions.h"
#include "../../saveload.h"
#include "../../company_func.h"
#include "../../company_base.h"
#include "../../settings_type.h"
#include "default.h"
#include "../../tunnelbridge.h"
#include "../../order_func.h"

#include "../../table/ai_rail.h"

// remove some day perhaps?
static uint _ai_service_interval;
CompanyAI _companies_ai[MAX_COMPANIES];

typedef void AiStateAction(Company *c);

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
};


static inline TrackBits GetRailTrackStatus(TileIndex tile)
{
  return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0));
}


static void AiCase0(Company *c)
{
  _companies_ai[c->index].state = AIS_REMOVE_TRACK;
  _companies_ai[c->index].state_counter = 0;
}

static void AiCase1(Company *c)
{
  _companies_ai[c->index].cur_veh = NULL;
  _companies_ai[c->index].state = AIS_VEH_LOOP;
}

static void AiStateVehLoop(Company *c)
{
  Vehicle *v;
  uint index;

  index = (_companies_ai[c->index].cur_veh == NULL) ? 0 : _companies_ai[c->index].cur_veh->index + 1;

  FOR_ALL_VEHICLES_FROM(v, index) {
    if (v->owner != _current_company) continue;

    if ((v->type == VEH_TRAIN && v->subtype == 0) ||
        v->type == VEH_ROAD ||
        (v->type == VEH_AIRCRAFT && IsNormalAircraft(v)) ||
        v->type == VEH_SHIP) {
      /* replace engine? */
      if (v->type == VEH_TRAIN && v->engine_type < 3 &&
          (_price.build_railvehicle >> 3) < c->money) {
        _companies_ai[c->index].state = AIS_VEH_CHECK_REPLACE_VEHICLE;
        _companies_ai[c->index].cur_veh = v;
        return;
      }

      /* not profitable? */
      if (v->age >= 730 &&
          v->profit_last_year < _price.station_value * 5 * 256 &&
          v->profit_this_year < _price.station_value * 5 * 256) {
        _companies_ai[c->index].state_counter = 0;
        _companies_ai[c->index].state = AIS_SELL_VEHICLE;
        _companies_ai[c->index].cur_veh = v;
        return;
      }

      /* not reliable? */
      if (v->age >= v->max_age || (
            v->age != 0 &&
            GetEngine(v->engine_type)->reliability < 35389
          )) {
        _companies_ai[c->index].state = AIS_VEH_CHECK_REPLACE_VEHICLE;
        _companies_ai[c->index].cur_veh = v;
        return;
      }
    }
  }

  _companies_ai[c->index].state = AIS_WANT_NEW_ROUTE;
  _companies_ai[c->index].state_counter = 0;
}

static EngineID AiChooseTrainToBuild(RailType railtype, Money money, byte flag, TileIndex tile)
{
  EngineID best_veh_index = INVALID_ENGINE;
  byte best_veh_score = 0;
  const Engine *e;

  FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
    EngineID i = e->index;
    const RailVehicleInfo *rvi = &e->u.rail;

    if (!IsCompatibleRail(rvi->railtype, railtype) ||
        rvi->railveh_type == RAILVEH_WAGON ||
        (rvi->railveh_type == RAILVEH_MULTIHEAD && flag & 1) ||
        !HasBit(e->company_avail, _current_company) ||
        e->reliability < 0x8A3D) {
      continue;
    }

    /* Don't choose an engine designated for passenger use for freight. */
    if (rvi->ai_passenger_only != 0 && flag == 1) continue;

    CommandCost ret = DoCommand(tile, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);
    if (CmdSucceeded(ret) && ret.GetCost() <= money && rvi->ai_rank >= best_veh_score) {
      best_veh_score = rvi->ai_rank;
      best_veh_index = i;
    }
  }

  return best_veh_index;
}

static EngineID AiChooseRoadVehToBuild(CargoID cargo, Money money, TileIndex tile)
{
  EngineID best_veh_index = INVALID_ENGINE;
  int32 best_veh_rating = 0;
  const Engine *e;

  FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {
    EngineID i = e->index;
    const RoadVehicleInfo *rvi = &e->u.road;

    if (!HasBit(e->company_avail, _current_company) || e->reliability < 0x8A3D) {
      continue;
    }

    /* Skip vehicles which can't take our cargo type */
    if (rvi->cargo_type != cargo && !CanRefitTo(i, cargo)) continue;

    /* Rate and compare the engine by speed & capacity */
    int rating = rvi->max_speed * rvi->capacity;
    if (rating <= best_veh_rating) continue;

    CommandCost ret = DoCommand(tile, i, 0, 0, CMD_BUILD_ROAD_VEH);
    if (CmdFailed(ret)) continue;

    /* Add the cost of refitting */
    if (rvi->cargo_type != cargo) ret.AddCost(GetRefitCost(i));
    if (ret.GetCost() > money) continue;

    best_veh_rating = rating;
    best_veh_index = i;
  }

  return best_veh_index;
}

static EngineID AiChooseAircraftToBuild(Money money, byte forbidden)
{
  EngineID best_veh_index = INVALID_ENGINE;
  Money best_veh_cost = 0;
  const Engine *e;

  FOR_ALL_ENGINES_OF_TYPE(e, VEH_AIRCRAFT) {
    EngineID i = e->index;
    const AircraftVehicleInfo *avi = &e->u.air;

    if (!HasBit(e->company_avail, _current_company) || e->reliability < 0x8A3D) {
      continue;
    }

    if ((avi->subtype & forbidden) != 0) continue;

    CommandCost ret = DoCommand(0, i, 0, DC_QUERY_COST, CMD_BUILD_AIRCRAFT);
    if (CmdSucceeded(ret) && ret.GetCost() <= money && ret.GetCost() >= best_veh_cost) {
      best_veh_cost = ret.GetCost();
      best_veh_index = i;
    }
  }

  return best_veh_index;
}

static Money AiGetBasePrice(const Company *c)
{
  Money base = _price.station_value;

  // adjust base price when more expensive vehicles are available
  switch (_companies_ai[c->index].railtype_to_use) {
    default: NOT_REACHED();
    case RAILTYPE_RAIL:     break;
    case RAILTYPE_ELECTRIC: break;
    case RAILTYPE_MONO:     base = (base * 3) >> 1; break;
    case RAILTYPE_MAGLEV:   base *= 2; break;
  }

  return base;
}

static EngineID AiChooseRoadVehToReplaceWith(const Company *c, const Vehicle *v)
{
  Money avail_money = c->money + v->value;
  return AiChooseRoadVehToBuild(v->cargo_type, avail_money, v->tile);
}

static EngineID AiChooseAircraftToReplaceWith(const Company *c, const Vehicle *v)
{
  Money avail_money = c->money + v->value;

  /* determine forbidden aircraft bits */
  byte forbidden = 0;
  const Order *o;

  FOR_VEHICLE_ORDERS(v, o) {
    if (!o->IsValid()) continue;
    if (!IsValidStationID(o->GetDestination())) continue;
    const Station *st = GetStation(o->GetDestination());
    if (!(st->facilities & FACIL_AIRPORT)) continue;

    AirportFTAClass::Flags flags = st->Airport()->flags;
    if (!(flags & AirportFTAClass::AIRPLANES)) forbidden |= AIR_CTOL | AIR_FAST; // no planes for heliports / oil rigs
    if (flags & AirportFTAClass::SHORT_STRIP) forbidden |= AIR_FAST; // no fast planes for small airports
  }

  return AiChooseAircraftToBuild(
    avail_money, forbidden
  );
}

static EngineID AiChooseTrainToReplaceWith(const Company *c, const Vehicle *v)
{
  Money avail_money = c->money + v->value;
  const Vehicle *u = v;
  int num = 0;

  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 EngineID AiChooseShipToReplaceWith(const Company *c, const Vehicle *v)
{
  /* Ships are not implemented in this (broken) AI */
  return INVALID_ENGINE;
}

static void AiHandleGotoDepot(Company *c, int cmd)
{
  if (!_companies_ai[c->index].cur_veh->current_order.IsType(OT_GOTO_DEPOT))
    DoCommand(0, _companies_ai[c->index].cur_veh->index, 0, DC_EXEC, cmd);

  if (++_companies_ai[c->index].state_counter <= 1387) {
    _companies_ai[c->index].state = AIS_VEH_DO_REPLACE_VEHICLE;
    return;
  }

  if (_companies_ai[c->index].cur_veh->current_order.IsType(OT_GOTO_DEPOT)) {
    _companies_ai[c->index].cur_veh->current_order.MakeDummy();
    InvalidateWindow(WC_VEHICLE_VIEW, _companies_ai[c->index].cur_veh->index);
  }
}

static void AiRestoreVehicleOrders(Vehicle *v, BackuppedOrders *bak)
{
  if (bak->order == NULL) return;

  for (uint i = 0; !bak->order[i].IsType(OT_NOTHING); i++) {
    if (!DoCommandP(0, v->index + (i << 16), bak->order[i].Pack(), NULL, CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK))
      break;
  }
}

static void AiHandleReplaceTrain(Company *c)
{
  const Vehicle* v = _companies_ai[c->index].cur_veh;
  BackuppedOrders orderbak;
  EngineID veh;

  // wait until the vehicle reaches the depot.
  if (!IsRailDepotTile(v->tile) || v->u.rail.track != TRACK_BIT_DEPOT || !(v->vehstatus & VS_STOPPED)) {
    AiHandleGotoDepot(c, CMD_SEND_TRAIN_TO_DEPOT);
    return;
  }

  veh = AiChooseTrainToReplaceWith(c, v);
  if (veh != INVALID_ENGINE) {
    TileIndex tile;

    BackupVehicleOrders(v, &orderbak);
    tile = v->tile;

    if (CmdSucceeded(DoCommand(0, v->index, 2, DC_EXEC, CMD_SELL_RAIL_WAGON)) &&
        CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE))) {
      VehicleID veh = _new_vehicle_id;
      AiRestoreVehicleOrders(GetVehicle(veh), &orderbak);
      DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_VEHICLE);

      DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
    }
  }
}

static void AiHandleReplaceRoadVeh(Company *c)
{
  const Vehicle* v = _companies_ai[c->index].cur_veh;
  BackuppedOrders orderbak;
  EngineID veh;

  if (!v->IsStoppedInDepot()) {
    AiHandleGotoDepot(c, CMD_SEND_ROADVEH_TO_DEPOT);
    return;
  }

  veh = AiChooseRoadVehToReplaceWith(c, v);
  if (veh != INVALID_ENGINE) {
    TileIndex tile;

    BackupVehicleOrders(v, &orderbak);
    tile = v->tile;

    if (CmdSucceeded(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH)) &&
        CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH))) {
      VehicleID veh = _new_vehicle_id;

      AiRestoreVehicleOrders(GetVehicle(veh), &orderbak);
      DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_VEHICLE);
      DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
    }
  }
}

static void AiHandleReplaceAircraft(Company *c)
{
  const Vehicle* v = _companies_ai[c->index].cur_veh;
  BackuppedOrders orderbak;
  EngineID veh;

  if (!v->IsStoppedInDepot()) {
    AiHandleGotoDepot(c, CMD_SEND_AIRCRAFT_TO_HANGAR);
    return;
  }

  veh = AiChooseAircraftToReplaceWith(c, v);
  if (veh != INVALID_ENGINE) {
    TileIndex tile;

    BackupVehicleOrders(v, &orderbak);
    tile = v->tile;

    if (CmdSucceeded(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT)) &&
        CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT))) {
      VehicleID veh = _new_vehicle_id;
      AiRestoreVehicleOrders(GetVehicle(veh), &orderbak);
      DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_VEHICLE);

      DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
    }
  }
}

static void AiHandleReplaceShip(Company *c)
{
  /* Ships are not implemented in this (broken) AI */
}

typedef EngineID CheckReplaceProc(const Company *c, const Vehicle* v);

static CheckReplaceProc* const _veh_check_replace_proc[] = {
  AiChooseTrainToReplaceWith,
  AiChooseRoadVehToReplaceWith,
  AiChooseShipToReplaceWith,
  AiChooseAircraftToReplaceWith,
};

typedef void DoReplaceProc(Company *c);
static DoReplaceProc* const _veh_do_replace_proc[] = {
  AiHandleReplaceTrain,
  AiHandleReplaceRoadVeh,
  AiHandleReplaceShip,
  AiHandleReplaceAircraft
};

static void AiStateCheckReplaceVehicle(Company *c)
{
  const Vehicle* v = _companies_ai[c->index].cur_veh;

  if (!v->IsValid() ||
      v->owner != _current_company ||
      v->type > VEH_SHIP ||
      _veh_check_replace_proc[v->type - VEH_TRAIN](c, v) == INVALID_ENGINE) {
    _companies_ai[c->index].state = AIS_VEH_LOOP;
  } else {
    _companies_ai[c->index].state_counter = 0;
    _companies_ai[c->index].state = AIS_VEH_DO_REPLACE_VEHICLE;
  }
}

static void AiStateDoReplaceVehicle(Company *c)
{
  const Vehicle* v = _companies_ai[c->index].cur_veh;

  _companies_ai[c->index].state = AIS_VEH_LOOP;
  // vehicle is not owned by the company anymore, something went very wrong.
  if (!v->IsValid() || v->owner != _current_company) return;
  _veh_do_replace_proc[v->type - VEH_TRAIN](c);
}

struct FoundRoute {
  int distance;
  CargoID cargo;
  void *from;
  void *to;
};

static Town *AiFindRandomTown()
{
  return GetRandomTown();
}

static Industry *AiFindRandomIndustry()
{
  int num = RandomRange(GetMaxIndustryIndex());
  if (IsValidIndustryID(num)) return GetIndustry(num);

  return NULL;
}

static void AiFindSubsidyIndustryRoute(FoundRoute *fr)
{
  uint i;
  CargoID cargo;
  const Subsidy* s;
  Industry* from;
  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 == CT_INVALID ||
      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) {
    Town* to_tow = GetTown(s->to);

    if (to_tow->population < (cargo == CT_FOOD ? 200U : 900U)) return; // error
    fr->to = to_tow;
    to_xy = to_tow->xy;
  } else {
    Industry* 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;
  const 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);
}

static void AiFindRandomIndustryRoute(FoundRoute *fr)
{
  Industry* i;
  uint32 r;
  CargoID cargo;

  // initially error
  fr->distance = -1;

  r = Random();

  // pick a source
  fr->from = i = AiFindRandomIndustry();
  if (i == NULL) return;

  // pick a random produced cargo
  cargo = i->produced_cargo[0];
  if (r & 1 && i->produced_cargo[1] != CT_INVALID) cargo = i->produced_cargo[1];

  fr->cargo = cargo;

  // don't allow passengers
  if (cargo == CT_INVALID || cargo == CT_PASSENGERS) return;

  if (cargo != CT_GOODS && cargo != CT_FOOD) {
    // pick a dest, and see if it can receive
    Industry* i2 = AiFindRandomIndustry();
    if (i2 == NULL || i == i2 ||
        (i2->accepts_cargo[0] != cargo &&
        i2->accepts_cargo[1] != cargo &&
        i2->accepts_cargo[2] != cargo)) {
      return;
    }

    fr->to = i2;
    fr->distance = DistanceManhattan(i->xy, i2->xy);
  } else {
    // pick a dest town, and see if it's big enough
    Town* t = AiFindRandomTown();

    if (t == NULL || t->population < (cargo == CT_FOOD ? 200U : 900U)) return;

    fr->to = t;
    fr->distance = DistanceManhattan(i->xy, t->xy);
  }
}

static void AiFindRandomPassengerRoute(FoundRoute *fr)
{
  Town* source;
  Town* dest;

  // initially error
  fr->distance = -1;

  fr->from = source = AiFindRandomTown();
  if (source == NULL || source->population < 400) return;

  fr->to = dest = AiFindRandomTown();
  if (dest == NULL || source == dest || dest->population < 400) return;

  fr->distance = DistanceManhattan(source->xy, dest->xy);
}

// Warn: depends on 'xy' being the first element in both Town and Industry
#define GET_TOWN_OR_INDUSTRY_TILE(p) (((Town*)(p))->xy)

static bool AiCheckIfRouteIsGood(Company *c, FoundRoute *fr, byte bitmask)
{
  TileIndex from_tile, to_tile;
  Station *st;
  int dist;
  uint same_station = 0;

  from_tile = GET_TOWN_OR_INDUSTRY_TILE(fr->from);
  to_tile = GET_TOWN_OR_INDUSTRY_TILE(fr->to);

  dist = 0xFFFF;
  FOR_ALL_STATIONS(st) {
    int cur;

    if (st->owner != _current_company) continue;
    cur = DistanceMax(from_tile, st->xy);
    if (cur < dist) dist = cur;
    cur = DistanceMax(to_tile, st->xy);
    if (cur < dist) dist = cur;
    if (to_tile == from_tile && st->xy == to_tile) same_station++;
  }

  // To prevent the AI from building ten busstations in the same town, do some calculations
  //  For each road or airport station, we want 350 of population!
  if ((bitmask == 2 || bitmask == 4) &&
      same_station > 2 &&
      ((Town*)fr->from)->population < same_station * 350) {
    return false;
  }

  /* Requiring distance to nearest station to be always under 37 tiles may be suboptimal,
   * Especially for longer aircraft routes that start and end pretty at any arbitrary place on map
   * While it may be nice for AI to cluster their creations together, hardcoded limit is not ideal.
   * If AI will randomly start on some isolated spot, it will never get out of there.
   * AI will have chance of randomly rejecting routes further than 37 tiles from their network,
   * so there will be some attempt to cluster the network together */

  /* Random value between 37 and 292. Low values are exponentially more likely
   * With 50% chance the value will be under 52 tiles */
  int min_distance = 36 + (1 << (Random() % 9)); // 0..8

  /* Make sure distance to closest station is < min_distance tiles. */
  if (dist != 0xFFFF && dist > min_distance) return false;

  if (_companies_ai[c->index].route_type_mask != 0 &&
      !(_companies_ai[c->index].route_type_mask & bitmask) &&
      !Chance16(1, 5)) {
    return false;
  }

  if (fr->cargo == CT_PASSENGERS || fr->cargo == CT_MAIL) {
    const Town* from = (const Town*)fr->from;
    const Town* to   = (const Town*)fr->to;

    if (from->pct_pass_transported > 0x99 ||
        to->pct_pass_transported > 0x99) {
      return false;
    }

    // Make sure it has a reasonably good rating
    if (from->ratings[_current_company] < -100 ||
        to->ratings[_current_company] < -100) {
      return false;
    }
  } else {
    const Industry* i = (const Industry*)fr->from;

    if (i->last_month_pct_transported[fr->cargo != i->produced_cargo[0]] > 0x99 ||
        i->last_month_production[fr->cargo != i->produced_cargo[0]] == 0) {
      return false;
    }
  }

  _companies_ai[c->index].route_type_mask |= bitmask;
  return true;
}

static byte AiGetDirectionBetweenTiles(TileIndex a, TileIndex b)
{
  byte i = (TileX(a) < TileX(b)) ? 1 : 0;
  if (TileY(a) >= TileY(b)) i ^= 3;
  return i;
}

static TileIndex AiGetPctTileBetween(TileIndex a, TileIndex b, byte pct)
{
  return TileXY(
    TileX(a) + ((TileX(b) - TileX(a)) * pct >> 8),
    TileY(a) + ((TileY(b) - TileY(a)) * pct >> 8)
  );
}

static void AiWantLongIndustryRoute(Company *c)
{
  int i;
  FoundRoute fr;

  i = 60;
  for (;;) {
    // look for one from the subsidy list
    AiFindSubsidyIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 60, 90 + 1)) break;

    // try a random one
    AiFindRandomIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 60, 90 + 1)) break;

    // only test 60 times
    if (--i == 0) return;
  }

  if (!AiCheckIfRouteIsGood(c, &fr, 1)) return;

  // Fill the source field
  _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to);
  _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from);

  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 9;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.unk6 = 1;
  _companies_ai[c->index].src.unk7 = 0;
  _companies_ai[c->index].src.buildcmd_a = 0x24;
  _companies_ai[c->index].src.buildcmd_b = 0xFF;
  _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles(
    _companies_ai[c->index].src.spec_tile,
    _companies_ai[c->index].dst.spec_tile
  );
  _companies_ai[c->index].src.cargo = fr.cargo | 0x80;

  // Fill the dest field

  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 9;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.unk6 = 1;
  _companies_ai[c->index].dst.unk7 = 0;
  _companies_ai[c->index].dst.buildcmd_a = 0x34;
  _companies_ai[c->index].dst.buildcmd_b = 0xFF;
  _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles(
    _companies_ai[c->index].dst.spec_tile,
    _companies_ai[c->index].src.spec_tile
  );
  _companies_ai[c->index].dst.cargo = fr.cargo;

  // Fill middle field 1
  _companies_ai[c->index].mid1.spec_tile = AiGetPctTileBetween(
    _companies_ai[c->index].src.spec_tile,
    _companies_ai[c->index].dst.spec_tile,
    0x55
  );
  _companies_ai[c->index].mid1.use_tile = 0;
  _companies_ai[c->index].mid1.rand_rng = 6;
  _companies_ai[c->index].mid1.cur_building_rule = 0xFF;
  _companies_ai[c->index].mid1.unk6 = 2;
  _companies_ai[c->index].mid1.unk7 = 1;
  _companies_ai[c->index].mid1.buildcmd_a = 0x30;
  _companies_ai[c->index].mid1.buildcmd_b = 0xFF;
  _companies_ai[c->index].mid1.direction = _companies_ai[c->index].src.direction;
  _companies_ai[c->index].mid1.cargo = fr.cargo;

  // Fill middle field 2
  _companies_ai[c->index].mid2.spec_tile = AiGetPctTileBetween(
    _companies_ai[c->index].src.spec_tile,
    _companies_ai[c->index].dst.spec_tile,
    0xAA
  );
  _companies_ai[c->index].mid2.use_tile = 0;
  _companies_ai[c->index].mid2.rand_rng = 6;
  _companies_ai[c->index].mid2.cur_building_rule = 0xFF;
  _companies_ai[c->index].mid2.unk6 = 2;
  _companies_ai[c->index].mid2.unk7 = 1;
  _companies_ai[c->index].mid2.buildcmd_a = 0xFF;
  _companies_ai[c->index].mid2.buildcmd_b = 0xFF;
  _companies_ai[c->index].mid2.direction = _companies_ai[c->index].dst.direction;
  _companies_ai[c->index].mid2.cargo = fr.cargo;

  // Fill common fields
  _companies_ai[c->index].cargo_type = fr.cargo;
  _companies_ai[c->index].num_wagons = 3;
  _companies_ai[c->index].build_kind = 2;
  _companies_ai[c->index].num_build_rec = 4;
  _companies_ai[c->index].num_loco_to_build = 2;
  _companies_ai[c->index].num_want_fullload = 2;
  _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;

  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantMediumIndustryRoute(Company *c)
{
  int i;
  FoundRoute fr;

  i = 60;
  for (;;) {
    // look for one from the subsidy list
    AiFindSubsidyIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 40, 60 + 1)) break;

    // try a random one
    AiFindRandomIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 40, 60 + 1)) break;

    // only test 60 times
    if (--i == 0) return;
  }

  if (!AiCheckIfRouteIsGood(c, &fr, 1)) return;

  // Fill the source field
  _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from);
  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 9;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.unk6 = 1;
  _companies_ai[c->index].src.unk7 = 0;
  _companies_ai[c->index].src.buildcmd_a = 0x10;
  _companies_ai[c->index].src.buildcmd_b = 0xFF;
  _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles(
    GET_TOWN_OR_INDUSTRY_TILE(fr.from),
    GET_TOWN_OR_INDUSTRY_TILE(fr.to)
  );
  _companies_ai[c->index].src.cargo = fr.cargo | 0x80;

  // Fill the dest field
  _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to);
  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 9;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.unk6 = 1;
  _companies_ai[c->index].dst.unk7 = 0;
  _companies_ai[c->index].dst.buildcmd_a = 0xFF;
  _companies_ai[c->index].dst.buildcmd_b = 0xFF;
  _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles(
    GET_TOWN_OR_INDUSTRY_TILE(fr.to),
    GET_TOWN_OR_INDUSTRY_TILE(fr.from)
  );
  _companies_ai[c->index].dst.cargo = fr.cargo;

  // Fill common fields
  _companies_ai[c->index].cargo_type = fr.cargo;
  _companies_ai[c->index].num_wagons = 3;
  _companies_ai[c->index].build_kind = 1;
  _companies_ai[c->index].num_build_rec = 2;
  _companies_ai[c->index].num_loco_to_build = 1;
  _companies_ai[c->index].num_want_fullload = 1;
  _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;
  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantShortIndustryRoute(Company *c)
{
  int i;
  FoundRoute fr;

  i = 60;
  for (;;) {
    // look for one from the subsidy list
    AiFindSubsidyIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 15, 40 + 1)) break;

    // try a random one
    AiFindRandomIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 15, 40 + 1)) break;

    // only test 60 times
    if (--i == 0) return;
  }

  if (!AiCheckIfRouteIsGood(c, &fr, 1)) return;

  // Fill the source field
  _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from);
  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 9;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.unk6 = 1;
  _companies_ai[c->index].src.unk7 = 0;
  _companies_ai[c->index].src.buildcmd_a = 0x10;
  _companies_ai[c->index].src.buildcmd_b = 0xFF;
  _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles(
    GET_TOWN_OR_INDUSTRY_TILE(fr.from),
    GET_TOWN_OR_INDUSTRY_TILE(fr.to)
  );
  _companies_ai[c->index].src.cargo = fr.cargo | 0x80;

  // Fill the dest field
  _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to);
  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 9;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.unk6 = 1;
  _companies_ai[c->index].dst.unk7 = 0;
  _companies_ai[c->index].dst.buildcmd_a = 0xFF;
  _companies_ai[c->index].dst.buildcmd_b = 0xFF;
  _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles(
    GET_TOWN_OR_INDUSTRY_TILE(fr.to),
    GET_TOWN_OR_INDUSTRY_TILE(fr.from)
  );
  _companies_ai[c->index].dst.cargo = fr.cargo;

  // Fill common fields
  _companies_ai[c->index].cargo_type = fr.cargo;
  _companies_ai[c->index].num_wagons = 2;
  _companies_ai[c->index].build_kind = 1;
  _companies_ai[c->index].num_build_rec = 2;
  _companies_ai[c->index].num_loco_to_build = 1;
  _companies_ai[c->index].num_want_fullload = 1;
  _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;
  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantMailRoute(Company *c)
{
  int i;
  FoundRoute fr;

  i = 60;
  for (;;) {
    // look for one from the subsidy list
    AiFindSubsidyPassengerRoute(&fr);
    if (IsInsideMM(fr.distance, 60, 110 + 1)) break;

    // try a random one
    AiFindRandomPassengerRoute(&fr);
    if (IsInsideMM(fr.distance, 60, 110 + 1)) break;

    // only test 60 times
    if (--i == 0) return;
  }

  fr.cargo = CT_MAIL;
  if (!AiCheckIfRouteIsGood(c, &fr, 1)) return;

  // Fill the source field
  _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from);
  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 7;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.unk6 = 1;
  _companies_ai[c->index].src.unk7 = 0;
  _companies_ai[c->index].src.buildcmd_a = 0x24;
  _companies_ai[c->index].src.buildcmd_b = 0xFF;
  _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles(
    GET_TOWN_OR_INDUSTRY_TILE(fr.from),
    GET_TOWN_OR_INDUSTRY_TILE(fr.to)
  );
  _companies_ai[c->index].src.cargo = fr.cargo;

  // Fill the dest field
  _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to);
  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 7;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.unk6 = 1;
  _companies_ai[c->index].dst.unk7 = 0;
  _companies_ai[c->index].dst.buildcmd_a = 0x34;
  _companies_ai[c->index].dst.buildcmd_b = 0xFF;
  _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles(
    GET_TOWN_OR_INDUSTRY_TILE(fr.to),
    GET_TOWN_OR_INDUSTRY_TILE(fr.from)
  );
  _companies_ai[c->index].dst.cargo = fr.cargo;

  // Fill middle field 1
  _companies_ai[c->index].mid1.spec_tile = AiGetPctTileBetween(
    GET_TOWN_OR_INDUSTRY_TILE(fr.from),
    GET_TOWN_OR_INDUSTRY_TILE(fr.to),
    0x55
  );
  _companies_ai[c->index].mid1.use_tile = 0;
  _companies_ai[c->index].mid1.rand_rng = 6;
  _companies_ai[c->index].mid1.cur_building_rule = 0xFF;
  _companies_ai[c->index].mid1.unk6 = 2;
  _companies_ai[c->index].mid1.unk7 = 1;
  _companies_ai[c->index].mid1.buildcmd_a = 0x30;
  _companies_ai[c->index].mid1.buildcmd_b = 0xFF;
  _companies_ai[c->index].mid1.direction = _companies_ai[c->index].src.direction;
  _companies_ai[c->index].mid1.cargo = fr.cargo;

  // Fill middle field 2
  _companies_ai[c->index].mid2.spec_tile = AiGetPctTileBetween(
    GET_TOWN_OR_INDUSTRY_TILE(fr.from),
    GET_TOWN_OR_INDUSTRY_TILE(fr.to),
    0xAA
  );
  _companies_ai[c->index].mid2.use_tile = 0;
  _companies_ai[c->index].mid2.rand_rng = 6;
  _companies_ai[c->index].mid2.cur_building_rule = 0xFF;
  _companies_ai[c->index].mid2.unk6 = 2;
  _companies_ai[c->index].mid2.unk7 = 1;
  _companies_ai[c->index].mid2.buildcmd_a = 0xFF;
  _companies_ai[c->index].mid2.buildcmd_b = 0xFF;
  _companies_ai[c->index].mid2.direction = _companies_ai[c->index].dst.direction;
  _companies_ai[c->index].mid2.cargo = fr.cargo;

  // Fill common fields
  _companies_ai[c->index].cargo_type = fr.cargo;
  _companies_ai[c->index].num_wagons = 3;
  _companies_ai[c->index].build_kind = 2;
  _companies_ai[c->index].num_build_rec = 4;
  _companies_ai[c->index].num_loco_to_build = 2;
  _companies_ai[c->index].num_want_fullload = 0;
  _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;
  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantPassengerRoute(Company *c)
{
  int i;
  FoundRoute fr;

  i = 60;
  for (;;) {
    // look for one from the subsidy list
    AiFindSubsidyPassengerRoute(&fr);
    if (IsInsideMM(fr.distance, 0, 55 + 1)) break;

    // try a random one
    AiFindRandomPassengerRoute(&fr);
    if (IsInsideMM(fr.distance, 0, 55 + 1)) break;

    // only test 60 times
    if (--i == 0) return;
  }

  fr.cargo = CT_PASSENGERS;
  if (!AiCheckIfRouteIsGood(c, &fr, 1)) return;

  // Fill the source field
  _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from);
  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 7;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.unk6 = 1;
  _companies_ai[c->index].src.unk7 = 0;
  _companies_ai[c->index].src.buildcmd_a = 0x10;
  _companies_ai[c->index].src.buildcmd_b = 0xFF;
  _companies_ai[c->index].src.direction = AiGetDirectionBetweenTiles(
    GET_TOWN_OR_INDUSTRY_TILE(fr.from),
    GET_TOWN_OR_INDUSTRY_TILE(fr.to)
  );
  _companies_ai[c->index].src.cargo = fr.cargo;

  // Fill the dest field
  _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to);
  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 7;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.unk6 = 1;
  _companies_ai[c->index].dst.unk7 = 0;
  _companies_ai[c->index].dst.buildcmd_a = 0xFF;
  _companies_ai[c->index].dst.buildcmd_b = 0xFF;
  _companies_ai[c->index].dst.direction = AiGetDirectionBetweenTiles(
    GET_TOWN_OR_INDUSTRY_TILE(fr.to),
    GET_TOWN_OR_INDUSTRY_TILE(fr.from)
  );
  _companies_ai[c->index].dst.cargo = fr.cargo;

  // Fill common fields
  _companies_ai[c->index].cargo_type = fr.cargo;
  _companies_ai[c->index].num_wagons = 2;
  _companies_ai[c->index].build_kind = 1;
  _companies_ai[c->index].num_build_rec = 2;
  _companies_ai[c->index].num_loco_to_build = 1;
  _companies_ai[c->index].num_want_fullload = 0;
  _companies_ai[c->index].wagon_list[0] = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;
  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_RAIL_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantTrainRoute(Company *c)
{
  uint16 r = GB(Random(), 0, 16);

  _companies_ai[c->index].railtype_to_use = GetBestRailtype(c->index);

  if (r > 0xD000) {
    AiWantLongIndustryRoute(c);
  } else if (r > 0x6000) {
    AiWantMediumIndustryRoute(c);
  } else if (r > 0x1000) {
    AiWantShortIndustryRoute(c);
  } else if (r > 0x800) {
    AiWantPassengerRoute(c);
  } else {
    AiWantMailRoute(c);
  }
}

static void AiWantLongRoadIndustryRoute(Company *c)
{
  int i;
  FoundRoute fr;

  i = 60;
  for (;;) {
    // look for one from the subsidy list
    AiFindSubsidyIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 35, 55 + 1)) break;

    // try a random one
    AiFindRandomIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 35, 55 + 1)) break;

    // only test 60 times
    if (--i == 0) return;
  }

  if (!AiCheckIfRouteIsGood(c, &fr, 2)) return;

  // Fill the source field
  _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from);
  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 9;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.buildcmd_a = 1;
  _companies_ai[c->index].src.direction = 0;
  _companies_ai[c->index].src.cargo = fr.cargo | 0x80;

  // Fill the dest field
  _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to);
  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 9;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.buildcmd_a = 0xFF;
  _companies_ai[c->index].dst.direction = 0;
  _companies_ai[c->index].dst.cargo = fr.cargo;

  // Fill common fields
  _companies_ai[c->index].cargo_type = fr.cargo;
  _companies_ai[c->index].num_build_rec = 2;
  _companies_ai[c->index].num_loco_to_build = 5;
  _companies_ai[c->index].num_want_fullload = 5;

//  _companies_ai[c->index].loco_id = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;

  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_ROAD_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantMediumRoadIndustryRoute(Company *c)
{
  int i;
  FoundRoute fr;

  i = 60;
  for (;;) {
    // look for one from the subsidy list
    AiFindSubsidyIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 15, 40 + 1)) break;

    // try a random one
    AiFindRandomIndustryRoute(&fr);
    if (IsInsideMM(fr.distance, 15, 40 + 1)) break;

    // only test 60 times
    if (--i == 0) return;
  }

  if (!AiCheckIfRouteIsGood(c, &fr, 2)) return;

  // Fill the source field
  _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from);
  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 9;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.buildcmd_a = 1;
  _companies_ai[c->index].src.direction = 0;
  _companies_ai[c->index].src.cargo = fr.cargo | 0x80;

  // Fill the dest field
  _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to);
  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 9;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.buildcmd_a = 0xFF;
  _companies_ai[c->index].dst.direction = 0;
  _companies_ai[c->index].dst.cargo = fr.cargo;

  // Fill common fields
  _companies_ai[c->index].cargo_type = fr.cargo;
  _companies_ai[c->index].num_build_rec = 2;
  _companies_ai[c->index].num_loco_to_build = 3;
  _companies_ai[c->index].num_want_fullload = 3;

//  _companies_ai[c->index].loco_id = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;

  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_ROAD_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantLongRoadPassengerRoute(Company *c)
{
  int i;
  FoundRoute fr;

  i = 60;
  for (;;) {
    // look for one from the subsidy list
    AiFindSubsidyPassengerRoute(&fr);
    if (IsInsideMM(fr.distance, 55, 180 + 1)) break;

    // try a random one
    AiFindRandomPassengerRoute(&fr);
    if (IsInsideMM(fr.distance, 55, 180 + 1)) break;

    // only test 60 times
    if (--i == 0) return;
  }

  fr.cargo = CT_PASSENGERS;

  if (!AiCheckIfRouteIsGood(c, &fr, 2)) return;

  // Fill the source field
  _companies_ai[c->index].src.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.to);
  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 10;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.buildcmd_a = 1;
  _companies_ai[c->index].src.direction = 0;
  _companies_ai[c->index].src.cargo = CT_PASSENGERS;

  // Fill the dest field
  _companies_ai[c->index].dst.spec_tile = GET_TOWN_OR_INDUSTRY_TILE(fr.from);
  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 10;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.buildcmd_a = 0xFF;
  _companies_ai[c->index].dst.direction = 0;
  _companies_ai[c->index].dst.cargo = CT_PASSENGERS;

  // Fill common fields
  _companies_ai[c->index].cargo_type = CT_PASSENGERS;
  _companies_ai[c->index].num_build_rec = 2;
  _companies_ai[c->index].num_loco_to_build = 4;
  _companies_ai[c->index].num_want_fullload = 0;

//  _companies_ai[c->index].loco_id = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;

  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_ROAD_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantPassengerRouteInsideTown(Company *c)
{
  int i;
  FoundRoute fr;
  Town *t;

  i = 60;
  for (;;) {
    // Find a town big enough
    t = AiFindRandomTown();
    if (t != NULL && t->population >= 700) break;

    // only test 60 times
    if (--i == 0) return;
  }

  fr.cargo = CT_PASSENGERS;
  fr.from = fr.to = t;

  if (!AiCheckIfRouteIsGood(c, &fr, 2)) return;

  // Fill the source field
  _companies_ai[c->index].src.spec_tile = t->xy;
  _companies_ai[c->index].src.use_tile = 0;
  _companies_ai[c->index].src.rand_rng = 10;
  _companies_ai[c->index].src.cur_building_rule = 0xFF;
  _companies_ai[c->index].src.buildcmd_a = 1;
  _companies_ai[c->index].src.direction = 0;
  _companies_ai[c->index].src.cargo = CT_PASSENGERS;

  // Fill the dest field
  _companies_ai[c->index].dst.spec_tile = t->xy;
  _companies_ai[c->index].dst.use_tile = 0;
  _companies_ai[c->index].dst.rand_rng = 10;
  _companies_ai[c->index].dst.cur_building_rule = 0xFF;
  _companies_ai[c->index].dst.buildcmd_a = 0xFF;
  _companies_ai[c->index].dst.direction = 0;
  _companies_ai[c->index].dst.cargo = CT_PASSENGERS;

  // Fill common fields
  _companies_ai[c->index].cargo_type = CT_PASSENGERS;
  _companies_ai[c->index].num_build_rec = 2;
  _companies_ai[c->index].num_loco_to_build = 2;
  _companies_ai[c->index].num_want_fullload = 0;

//  _companies_ai[c->index].loco_id = INVALID_VEHICLE;
  _companies_ai[c->index].order_list_blocks[0] = 0;
  _companies_ai[c->index].order_list_blocks[1] = 1;
  _companies_ai[c->index].order_list_blocks[2] = 255;

  _companies_ai[c->index].state = AIS_BUILD_DEFAULT_ROAD_BLOCKS;
  _companies_ai[c->index].state_mode = UCHAR_MAX;
  _companies_ai[c->index].state_counter = 0;
  _companies_ai[c->index].timeout_counter = 0;
}

static void AiWantRoadRoute(Company *c)
{
  uint16 r = GB(Random(), 0, 16);

  if (r > 0x4000) {
    AiWantLongRoadIndustryRoute(c);
  } else if (r > 0x2000) {
    AiWantMediumRoadIndustryRoute(c);
  } else if (r > 0x1000) {
    AiWantLongRoadPassengerRoute(c);
  } else {
    AiWantPassengerRouteInsideTown(c);
  }
}

static void AiWantPassengerAircraftRoute(Company *c)
{
  FoundRoute fr;
  int i;

  /* Get aircraft that would be bought for this route
   * (probably, as conditions may change before the route is fully built,
   * like running out of money and having to select different aircraft, etc ...) */
  EngineID veh = AiChooseAircraftToBuild(c->money, _companies_ai[c->index].build_kind != 0 ? AIR_CTOL : 0);

  /* No aircraft buildable mean no aircraft route */
  if (veh == INVALID_ENGINE) return;

  const AircraftVehicleInfo *avi = AircraftVehInfo(veh);

  /* For passengers, "optimal" number of days in transit is about 80 to 100
   * Calculate "maximum optimal number of squares" from speed for 80 days
   * 20 days should be enough for takeoff, land, taxi, etc ...
   *
   * "A vehicle traveling at 100kph will cross 5.6 tiles per day" ->
   * Since in table aircraft speeds are in "real km/h", this should be accurate
   * We get max_squares = avi->max_speed * 5.6 / 100.0 * 80 */
  int max_squares = avi->max_speed * 448 / 100;

  /* For example this will be 10456 tiles for 2334 km/h aircrafts with realistic aircraft speeds
   * and 836 with "unrealistic" speeds, much more than the original 95 squares limit
   *
   * Size of the map, if not rectangular, it is the larger dimension of it
   */
  int map_size = max(MapSizeX(), MapSizeY());

  /* Minimum distance between airports is half of map size, clamped between 1% and 20% of optimum.
   * May prevent building plane routes at all on small maps, but they will be ineffective there, so
   * it is feature, not a bug.
   * On smaller distances, buses or trains are usually more effective approach anyway.
   * Additional safeguard is needing at least 20 squares,
   * which may trigger in highly unusual configurations */
  int min_squares = max(20, max(max_squares / 100, min(max_squares / 5, map_size / 2)));

  /* Should not happen, unless aircraft with real speed under approx. 5 km/h is selected.
   * No such exist, unless using some NewGRF with ballons, zeppelins or similar
   * slow-moving stuff. In that case, bail out, it is faster to walk by foot anyway :). */
  if (max_squares < min_squares) return;

  i = 60;
  for (;;) {

    // look for one from the subsidy list
    AiFindSubsidyPassengerRoute(&fr);
    if (IsInsideMM(fr.distance, min_squares, max_squares + 1)) break;

    // try a random one
    AiFindRandomPassengerRoute(&fr);
    if (IsInsideMM<