aircraft_cmd.cpp

Go to the documentation of this file.

/* $Id: aircraft_cmd.cpp 14422 2008-09-30 20:51:04Z rubidium $ */

#include "stdafx.h"
#include "openttd.h"
#include "aircraft.h"
#include "debug.h"
#include "landscape.h"
#include "station_map.h"
#include "timetable.h"
#include "depot_func.h"
#include "news_func.h"
#include "aircraft.h"
#include "airport.h"
#include "vehicle_gui.h"
#include "newgrf_engine.h"
#include "newgrf_callbacks.h"
#include "newgrf_text.h"
#include "newgrf_sound.h"
#include "spritecache.h"
#include "cargotype.h"
#include "strings_func.h"
#include "command_func.h"
#include "window_func.h"
#include "date_func.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "functions.h"
#include "variables.h"
#include "cheat_func.h"
#include "autoreplace_func.h"
#include "autoreplace_gui.h"
#include "gfx_func.h"
#include "company_func.h"
#include "settings_type.h"
#include "order_func.h"
#include "effectvehicle_func.h"

#include "table/strings.h"
#include "table/sprites.h"

void Aircraft::UpdateDeltaXY(Direction direction)
{
  uint32 x;
#define MKIT(a, b, c, d) ((a & 0xFF) << 24) | ((b & 0xFF) << 16) | ((c & 0xFF) << 8) | ((d & 0xFF) << 0)
  switch (this->subtype) {
    default: NOT_REACHED();
    case AIR_AIRCRAFT:
    case AIR_HELICOPTER:
      switch (this->u.air.state) {
        case ENDTAKEOFF:
        case LANDING:
        case HELILANDING:
        case FLYING:     x = MKIT(24, 24, -1, -1); break;
        default:         x = MKIT( 2,  2, -1, -1); break;
      }
      this->z_extent = 5;
      break;
    case AIR_SHADOW:     this->z_extent = 1; x = MKIT(2,  2,  0,  0); break;
    case AIR_ROTOR:      this->z_extent = 1; x = MKIT(2,  2, -1, -1); break;
  }
#undef MKIT

  this->x_offs        = GB(x,  0, 8);
  this->y_offs        = GB(x,  8, 8);
  this->x_extent      = GB(x, 16, 8);
  this->y_extent      = GB(x, 24, 8);
}


static const byte _airport_terminal_state[] = {2, 3, 4, 5, 6, 7, 19, 20, 0, 0, 8, 9, 21, 22};
static const byte _airport_terminal_flag[] =  {0, 1, 2, 3, 4, 5, 22, 23, 0, 0, 6, 7, 24, 25};

static bool AirportMove(Vehicle *v, const AirportFTAClass *apc);
static bool AirportSetBlocks(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc);
static bool AirportHasBlock(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc);
static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *apc);
static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *apc);
static void CrashAirplane(Vehicle *v);

void AircraftNextAirportPos_and_Order(Vehicle *v);
static byte GetAircraftFlyingAltitude(const Vehicle *v);

static const SpriteID _aircraft_sprite[] = {
  0x0EB5, 0x0EBD, 0x0EC5, 0x0ECD,
  0x0ED5, 0x0EDD, 0x0E9D, 0x0EA5,
  0x0EAD, 0x0EE5, 0x0F05, 0x0F0D,
  0x0F15, 0x0F1D, 0x0F25, 0x0F2D,
  0x0EED, 0x0EF5, 0x0EFD, 0x0F35,
  0x0E9D, 0x0EA5, 0x0EAD, 0x0EB5,
  0x0EBD, 0x0EC5
};

enum HelicopterRotorStates {
  HRS_ROTOR_STOPPED,
  HRS_ROTOR_MOVING_1,
  HRS_ROTOR_MOVING_2,
  HRS_ROTOR_MOVING_3,
};

static StationID FindNearestHangar(const Vehicle *v)
{
  const Station *st;
  uint best = 0;
  StationID index = INVALID_STATION;
  TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);

  FOR_ALL_STATIONS(st) {
    if (st->owner != v->owner || !(st->facilities & FACIL_AIRPORT)) continue;

    const AirportFTAClass *afc = st->Airport();
    if (afc->nof_depots == 0 || (
          /* don't crash the plane if we know it can't land at the airport */
          afc->flags & AirportFTAClass::SHORT_STRIP &&
          AircraftVehInfo(v->engine_type)->subtype & AIR_FAST &&
          !_cheats.no_jetcrash.value
        )) {
      continue;
    }

    /* v->tile can't be used here, when aircraft is flying v->tile is set to 0 */
    uint distance = DistanceSquare(vtile, st->airport_tile);
    if (distance < best || index == INVALID_STATION) {
      best = distance;
      index = st->index;
    }
  }
  return index;
}

#if 0

static bool HaveHangarInOrderList(Vehicle *v)
{
  const Order *order;

  FOR_VEHICLE_ORDERS(v, order) {
    const Station *st = GetStation(order->station);
    if (st->owner == v->owner && st->facilities & FACIL_AIRPORT) {
      /* If an airport doesn't have a hangar, skip it */
      if (st->Airport()->nof_depots != 0)
        return true;
    }
  }

  return false;
}
#endif

SpriteID Aircraft::GetImage(Direction direction) const
{
  uint8 spritenum = this->spritenum;

  if (is_custom_sprite(spritenum)) {
    SpriteID sprite = GetCustomVehicleSprite(this, direction);
    if (sprite != 0) return sprite;

    spritenum = GetEngine(this->engine_type)->image_index;
  }

  return direction + _aircraft_sprite[spritenum];
}

SpriteID GetRotorImage(const Vehicle *v)
{
  assert(v->subtype == AIR_HELICOPTER);

  const Vehicle *w = v->Next()->Next();
  if (is_custom_sprite(v->spritenum)) {
    SpriteID sprite = GetCustomRotorSprite(v, false);
    if (sprite != 0) return sprite;
  }

  /* Return standard rotor sprites if there are no custom sprites for this helicopter */
  return SPR_ROTOR_STOPPED + w->u.air.state;
}

static SpriteID GetAircraftIcon(EngineID engine)
{
  uint8 spritenum = AircraftVehInfo(engine)->image_index;

  if (is_custom_sprite(spritenum)) {
    SpriteID sprite = GetCustomVehicleIcon(engine, DIR_W);
    if (sprite != 0) return sprite;

    spritenum = GetEngine(engine)->image_index;
  }

  return 6 + _aircraft_sprite[spritenum];
}

void DrawAircraftEngine(int x, int y, EngineID engine, SpriteID pal)
{
  DrawSprite(GetAircraftIcon(engine), pal, x, y);

  if (!(AircraftVehInfo(engine)->subtype & AIR_CTOL)) {
    SpriteID rotor_sprite = GetCustomRotorIcon(engine);
    if (rotor_sprite == 0) rotor_sprite = SPR_ROTOR_STOPPED;
    DrawSprite(rotor_sprite, PAL_NONE, x, y - 5);
  }
}

void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height)
{
  const Sprite *spr = GetSprite(GetAircraftIcon(engine), ST_NORMAL);

  width  = spr->width;
  height = spr->height;
}

static CommandCost EstimateAircraftCost(EngineID engine, const AircraftVehicleInfo *avi)
{
  return CommandCost(EXPENSES_NEW_VEHICLES, GetEngineProperty(engine, 0x0B, avi->cost_factor) * (_price.aircraft_base >> 3) >> 5);
}


uint16 AircraftDefaultCargoCapacity(CargoID cid, const AircraftVehicleInfo *avi)
{
  assert(cid != CT_INVALID);

  /* An aircraft can carry twice as much goods as normal cargo,
   * and four times as many passengers. */
  switch (cid) {
    case CT_PASSENGERS:
      return avi->passenger_capacity;
    case CT_MAIL:
      return avi->passenger_capacity + avi->mail_capacity;
    case CT_GOODS:
      return (avi->passenger_capacity + avi->mail_capacity) / 2;
    default:
      return (avi->passenger_capacity + avi->mail_capacity) / 4;
  }
}

CommandCost CmdBuildAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  if (!IsEngineBuildable(p1, VEH_AIRCRAFT, _current_company)) return_cmd_error(STR_AIRCRAFT_NOT_AVAILABLE);

  const AircraftVehicleInfo *avi = AircraftVehInfo(p1);
  CommandCost value = EstimateAircraftCost(p1, avi);

  /* to just query the cost, it is not neccessary to have a valid tile (automation/AI) */
  if (flags & DC_QUERY_COST) return value;

  if (!IsHangarTile(tile) || !IsTileOwner(tile, _current_company)) return CMD_ERROR;

  /* Prevent building aircraft types at places which can't handle them */
  if (!CanAircraftUseStation(p1, tile)) return CMD_ERROR;

  /* Allocate 2 or 3 vehicle structs, depending on type
   * vl[0] = aircraft, vl[1] = shadow, [vl[2] = rotor] */
  Vehicle *vl[3];
  if (!Vehicle::AllocateList(vl, avi->subtype & AIR_CTOL ? 2 : 3)) {
    return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
  }

  UnitID unit_num = (flags & DC_AUTOREPLACE) ? 0 : GetFreeUnitNumber(VEH_AIRCRAFT);
  if (unit_num > _settings_game.vehicle.max_aircraft)
    return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

  if (flags & DC_EXEC) {
    Vehicle *v = vl[0]; // aircraft
    Vehicle *u = vl[1]; // shadow

    v = new (v) Aircraft();
    u = new (u) Aircraft();
    v->unitnumber = unit_num;
    v->direction = DIR_SE;

    v->owner = u->owner = _current_company;

    v->tile = tile;
//    u->tile = 0;

    uint x = TileX(tile) * TILE_SIZE + 5;
    uint y = TileY(tile) * TILE_SIZE + 3;

    v->x_pos = u->x_pos = x;
    v->y_pos = u->y_pos = y;

    u->z_pos = GetSlopeZ(x, y);
    v->z_pos = u->z_pos + 1;

    v->running_ticks = 0;

//    u->delta_x = u->delta_y = 0;

    v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
    u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_SHADOW;

    v->spritenum = avi->image_index;
//    v->cargo_count = u->number_of_pieces = 0;

    v->cargo_cap = avi->passenger_capacity;
    u->cargo_cap = avi->mail_capacity;

    v->cargo_type = CT_PASSENGERS;
    u->cargo_type = CT_MAIL;

    v->cargo_subtype = 0;

    v->name = NULL;
//    v->next_order_param = v->next_order = 0;

//    v->load_unload_time_rem = 0;
//    v->progress = 0;
    v->last_station_visited = INVALID_STATION;
//    v->destination_coords = 0;

    v->max_speed = avi->max_speed;
    v->acceleration = avi->acceleration;
    v->engine_type = p1;

    v->subtype = (avi->subtype & AIR_CTOL ? AIR_AIRCRAFT : AIR_HELICOPTER);
    v->UpdateDeltaXY(INVALID_DIR);
    v->value = value.GetCost();

    u->subtype = AIR_SHADOW;
    u->UpdateDeltaXY(INVALID_DIR);

    /* Danger, Will Robinson!
     * If the aircraft is refittable, but cannot be refitted to
     * passengers, we select the cargo type from the refit mask.
     * This is a fairly nasty hack to get around the fact that TTD
     * has no default cargo type specifier for planes... */
    CargoID cargo = FindFirstRefittableCargo(p1);
    if (cargo != CT_INVALID && cargo != CT_PASSENGERS) {
      uint16 callback = CALLBACK_FAILED;

      v->cargo_type = cargo;

      if (HasBit(EngInfo(p1)->callbackmask, CBM_VEHICLE_REFIT_CAPACITY)) {
        callback = GetVehicleCallback(CBID_VEHICLE_REFIT_CAPACITY, 0, 0, v->engine_type, v);
      }

      if (callback == CALLBACK_FAILED) {
        /* Callback failed, or not executed; use the default cargo capacity */
        v->cargo_cap = AircraftDefaultCargoCapacity(v->cargo_type, avi);
      } else {
        v->cargo_cap = callback;
      }

      /* Set the 'second compartent' capacity to none */
      u->cargo_cap = 0;
    }

    const Engine *e = GetEngine(p1);
    v->reliability = e->reliability;
    v->reliability_spd_dec = e->reliability_spd_dec;
    v->max_age = e->lifelength * 366;

    _new_vehicle_id = v->index;

    /* When we click on hangar we know the tile it is on. By that we know
     * its position in the array of depots the airport has.....we can search
     * layout for #th position of depot. Since layout must start with a listing
     * of all depots, it is simple */
    for (uint i = 0;; i++) {
      const Station *st = GetStationByTile(tile);
      const AirportFTAClass *apc = st->Airport();

      assert(i != apc->nof_depots);
      if (st->airport_tile + ToTileIndexDiff(apc->airport_depots[i]) == tile) {
        assert(apc->layout[i].heading == HANGAR);
        v->u.air.pos = apc->layout[i].position;
        break;
      }
    }

    v->u.air.state = HANGAR;
    v->u.air.previous_pos = v->u.air.pos;
    v->u.air.targetairport = GetStationIndex(tile);
    v->SetNext(u);

    v->service_interval = _settings_game.vehicle.servint_aircraft;

    v->date_of_last_service = _date;
    v->build_year = u->build_year = _cur_year;

    v->cur_image = u->cur_image = 0xEA0;

    v->random_bits = VehicleRandomBits();
    u->random_bits = VehicleRandomBits();

    v->vehicle_flags = 0;
    if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);

    UpdateAircraftCache(v);

    VehiclePositionChanged(v);
    VehiclePositionChanged(u);

    /* Aircraft with 3 vehicles (chopper)? */
    if (v->subtype == AIR_HELICOPTER) {
      Vehicle *w = vl[2];

      w = new (w) Aircraft();
      w->direction = DIR_N;
      w->owner = _current_company;
      w->x_pos = v->x_pos;
      w->y_pos = v->y_pos;
      w->z_pos = v->z_pos + 5;
      w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;
      w->spritenum = 0xFF;
      w->subtype = AIR_ROTOR;
      w->cur_image = SPR_ROTOR_STOPPED;
      w->random_bits = VehicleRandomBits();
      /* Use rotor's air.state to store the rotor animation frame */
      w->u.air.state = HRS_ROTOR_STOPPED;
      w->UpdateDeltaXY(INVALID_DIR);

      u->SetNext(w);
      VehiclePositionChanged(w);
    }

    InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
    InvalidateWindowClassesData(WC_AIRCRAFT_LIST, 0);
    InvalidateWindow(WC_COMPANY, v->owner);
    if (IsLocalCompany())
      InvalidateAutoreplaceWindow(v->engine_type, v->group_id); //updates the replace Aircraft window

    GetCompany(_current_company)->num_engines[p1]++;
  }

  return value;
}


static void DoDeleteAircraft(Vehicle *v)
{
  DeleteWindowById(WC_VEHICLE_VIEW, v->index);
  InvalidateWindow(WC_COMPANY, v->owner);
  DeleteDepotHighlightOfVehicle(v);
  DeleteVehicleChain(v);
  InvalidateWindowClassesData(WC_AIRCRAFT_LIST, 0);
}

CommandCost CmdSellAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  if (!IsValidVehicleID(p1)) return CMD_ERROR;

  Vehicle *v = GetVehicle(p1);

  if (v->type != VEH_AIRCRAFT || !CheckOwnership(v->owner)) return CMD_ERROR;
  if (!v->IsStoppedInDepot()) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED);

  if (HASBITS(v->vehstatus, VS_CRASHED)) return_cmd_error(STR_CAN_T_SELL_DESTROYED_VEHICLE);

  CommandCost ret(EXPENSES_NEW_VEHICLES, -v->value);

  if (flags & DC_EXEC) {
    // Invalidate depot
    InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
    DoDeleteAircraft(v);
  }

  return ret;
}

bool Aircraft::FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
{
  const Station *st = GetTargetAirportIfValid(this);
  /* If the station is not a valid airport or if it has no hangars */
  if (st == NULL || st->Airport()->nof_depots == 0) {
    /* the aircraft has to search for a hangar on its own */
    StationID station = FindNearestHangar(this);

    if (station == INVALID_STATION) return false;

    st = GetStation(station);
  }

  if (location    != NULL) *location    = st->xy;
  if (destination != NULL) *destination = st->index;

  return true;
}

CommandCost CmdSendAircraftToHangar(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  if (p2 & DEPOT_MASS_SEND) {
    /* Mass goto depot requested */
    if (!ValidVLWFlags(p2 & VLW_MASK)) return CMD_ERROR;
    return SendAllVehiclesToDepot(VEH_AIRCRAFT, flags, p2 & DEPOT_SERVICE, _current_company, (p2 & VLW_MASK), p1);
  }

  if (!IsValidVehicleID(p1)) return CMD_ERROR;

  Vehicle *v = GetVehicle(p1);

  if (v->type != VEH_AIRCRAFT) return CMD_ERROR;

  return v->SendToDepot(flags, (DepotCommand)(p2 & DEPOT_COMMAND_MASK));
}


CommandCost CmdRefitAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  byte new_subtype = GB(p2, 8, 8);

  if (!IsValidVehicleID(p1)) return CMD_ERROR;

  Vehicle *v = GetVehicle(p1);

  if (v->type != VEH_AIRCRAFT || !CheckOwnership(v->owner)) return CMD_ERROR;
  if (!v->IsStoppedInDepot()) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED);
  if (v->vehstatus & VS_CRASHED) return_cmd_error(STR_CAN_T_REFIT_DESTROYED_VEHICLE);

  /* Check cargo */
  CargoID new_cid = GB(p2, 0, 8);
  if (new_cid >= NUM_CARGO || !CanRefitTo(v->engine_type, new_cid)) return CMD_ERROR;

  /* Check the refit capacity callback */
  uint16 callback = CALLBACK_FAILED;
  if (HasBit(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_REFIT_CAPACITY)) {
    /* Back up the existing cargo type */
    CargoID temp_cid = v->cargo_type;
    byte temp_subtype = v->cargo_subtype;
    v->cargo_type = new_cid;
    v->cargo_subtype = new_subtype;

    callback = GetVehicleCallback(CBID_VEHICLE_REFIT_CAPACITY, 0, 0, v->engine_type, v);

    /* Restore the cargo type */
    v->cargo_type = temp_cid;
    v->cargo_subtype = temp_subtype;
  }

  const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);

  uint pass;
  if (callback == CALLBACK_FAILED) {
    /* If the callback failed, or wasn't executed, use the aircraft's
     * default cargo capacity */
    pass = AircraftDefaultCargoCapacity(new_cid, avi);
  } else {
    pass = callback;
  }
  _returned_refit_capacity = pass;

  CommandCost cost;
  if (IsHumanCompany(v->owner) && new_cid != v->cargo_type) {
    cost = GetRefitCost(v->engine_type);
  }

  if (flags & DC_EXEC) {
    v->cargo_cap = pass;

    Vehicle *u = v->Next();
    uint mail = IsCargoInClass(new_cid, CC_PASSENGERS) ? avi->mail_capacity : 0;
    u->cargo_cap = mail;
    v->cargo.Truncate(v->cargo_type == new_cid ? pass : 0);
    u->cargo.Truncate(v->cargo_type == new_cid ? mail : 0);
    v->cargo_type = new_cid;
    v->cargo_subtype = new_subtype;
    InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
    InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
    InvalidateWindowClassesData(WC_AIRCRAFT_LIST, 0);
  }

  return cost;
}


static void CheckIfAircraftNeedsService(Vehicle *v)
{
  if (_settings_game.vehicle.servint_aircraft == 0 || !v->NeedsAutomaticServicing()) return;
  if (v->IsInDepot()) {
    VehicleServiceInDepot(v);
    return;
  }

  const Station *st = GetStation(v->current_order.GetDestination());
  /* only goto depot if the target airport has terminals (eg. it is airport) */
  if (st->IsValid() && st->airport_tile != 0 && st->Airport()->terminals != NULL) {
//    printf("targetairport = %d, st->index = %d\n", v->u.air.targetairport, st->index);
//    v->u.air.targetairport = st->index;
    v->current_order.MakeGoToDepot(st->index, ODTFB_SERVICE);
    InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
  } else if (v->current_order.IsType(OT_GOTO_DEPOT)) {
    v->current_order.MakeDummy();
    InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
  }
}

void Aircraft::OnNewDay()
{
  if (!IsNormalAircraft(this)) return;

  if ((++this->day_counter & 7) == 0) DecreaseVehicleValue(this);

  CheckOrders(this);

  CheckVehicleBreakdown(this);
  AgeVehicle(this);
  CheckIfAircraftNeedsService(this);

  if (this->running_ticks == 0) return;

  CommandCost cost(EXPENSES_AIRCRAFT_RUN, GetVehicleProperty(this, 0x0E, AircraftVehInfo(this->engine_type)->running_cost) * _price.aircraft_running * this->running_ticks / (364 * DAY_TICKS));

  this->profit_this_year -= cost.GetCost();
  this->running_ticks = 0;

  SubtractMoneyFromCompanyFract(this->owner, cost);

  InvalidateWindow(WC_VEHICLE_DETAILS, this->index);
  InvalidateWindowClasses(WC_AIRCRAFT_LIST);
}

void AircraftYearlyLoop()
{
  Vehicle *v;

  FOR_ALL_VEHICLES(v) {
    if (v->type == VEH_AIRCRAFT && IsNormalAircraft(v)) {
      v->profit_last_year = v->profit_this_year;
      v->profit_this_year = 0;
      InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
    }
  }
}

static void AgeAircraftCargo(Vehicle *v)
{
  if (_age_cargo_skip_counter != 0) return;

  do {
    v->cargo.AgeCargo();
    v = v->Next();
  } while (v != NULL);
}

static void HelicopterTickHandler(Vehicle *v)
{
  Vehicle *u = v->Next()->Next();

  if (u->vehstatus & VS_HIDDEN) return;

  /* if true, helicopter rotors do not rotate. This should only be the case if a helicopter is
   * loading/unloading at a terminal or stopped */
  if (v->current_order.IsType(OT_LOADING) || (v->vehstatus & VS_STOPPED)) {
    if (u->cur_speed != 0) {
      u->cur_speed++;
      if (u->cur_speed >= 0x80 && u->u.air.state == HRS_ROTOR_MOVING_3) {
        u->cur_speed = 0;
      }
    }
  } else {
    if (u->cur_speed == 0)
      u->cur_speed = 0x70;

    if (u->cur_speed >= 0x50)
      u->cur_speed--;
  }

  int tick = ++u->tick_counter;
  int spd = u->cur_speed >> 4;

  SpriteID img;
  if (spd == 0) {
    u->u.air.state = HRS_ROTOR_STOPPED;
    img = GetRotorImage(v);
    if (u->cur_image == img) return;
  } else if (tick >= spd) {
    u->tick_counter = 0;
    u->u.air.state++;
    if (u->u.air.state > HRS_ROTOR_MOVING_3) u->u.air.state = HRS_ROTOR_MOVING_1;
    img = GetRotorImage(v);
  } else {
    return;
  }

  u->cur_image = img;

  BeginVehicleMove(u);
  VehiclePositionChanged(u);
  EndVehicleMove(u);
}

static void SetAircraftPosition(Vehicle *v, int x, int y, int z)
{
  v->x_pos = x;
  v->y_pos = y;
  v->z_pos = z;

  v->cur_image = v->GetImage(v->direction);
  if (v->subtype == AIR_HELICOPTER) v->Next()->Next()->cur_image = GetRotorImage(v);

  BeginVehicleMove(v);
  VehiclePositionChanged(v);
  EndVehicleMove(v);

  Vehicle *u = v->Next();

  int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE);
  int safe_y = Clamp(y - 1, 0, MapMaxY() * TILE_SIZE);
  u->x_pos = x;
  u->y_pos = y - ((v->z_pos-GetSlopeZ(safe_x, safe_y)) >> 3);;

  safe_y = Clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE);
  u->z_pos = GetSlopeZ(safe_x, safe_y);
  u->cur_image = v->cur_image;

  BeginVehicleMove(u);
  VehiclePositionChanged(u);
  EndVehicleMove(u);

  u = u->Next();
  if (u != NULL) {
    u->x_pos = x;
    u->y_pos = y;
    u->z_pos = z + 5;

    BeginVehicleMove(u);
    VehiclePositionChanged(u);
    EndVehicleMove(u);
  }
}

void HandleAircraftEnterHangar(Vehicle *v)
{
  v->subspeed = 0;
  v->progress = 0;

  Vehicle *u = v->Next();
  u->vehstatus |= VS_HIDDEN;
  u = u->Next();
  if (u != NULL) {
    u->vehstatus |= VS_HIDDEN;
    u->cur_speed = 0;
  }

  SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
}

static void PlayAircraftSound(const Vehicle* v)
{
  if (!PlayVehicleSound(v, VSE_START)) {
    SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v);
  }
}


void UpdateAircraftCache(Vehicle *v)
{
  uint max_speed = GetVehicleProperty(v, 0x0C, 0);
  if (max_speed != 0) {
    /* Convert from original units to (approx) km/h */
    max_speed = (max_speed * 129) / 10;

    v->u.air.cached_max_speed = max_speed;
  } else {
    v->u.air.cached_max_speed = 0xFFFF;
  }
}


enum AircraftSpeedLimits {
  SPEED_LIMIT_TAXI     =     50,  
  SPEED_LIMIT_APPROACH =    230,  
  SPEED_LIMIT_BROKEN   =    320,  
  SPEED_LIMIT_HOLD     =    425,  
  SPEED_LIMIT_NONE     = 0xFFFF   
};

static int UpdateAircraftSpeed(Vehicle *v, uint speed_limit = SPEED_LIMIT_NONE, bool hard_limit = true)
{
  uint spd = v->acceleration * 16;
  byte t;

  /* Adjust speed limits by plane speed factor to prevent taxiing
   * and take-off speeds being too low. */
  speed_limit *= _settings_game.vehicle.plane_speed;

  if (v->u.air.cached_max_speed < speed_limit) {
    if (v->cur_speed < speed_limit) hard_limit = false;
    speed_limit = v->u.air.cached_max_speed;
  }

  speed_limit = min(speed_limit, v->max_speed);

  v->subspeed = (t=v->subspeed) + (byte)spd;

  /* Aircraft's current speed is used twice so that very fast planes are
   * forced to slow down rapidly in the short distance needed. The magic
   * value 16384 was determined to give similar results to the old speed/48
   * method at slower speeds. This also results in less reduction at slow
   * speeds to that aircraft do not get to taxi speed straight after
   * touchdown. */
  if (!hard_limit && v->cur_speed > speed_limit) {
    speed_limit = v->cur_speed - max(1, ((v->cur_speed * v->cur_speed) / 16384) / _settings_game.vehicle.plane_speed);
  }

  spd = min(v->cur_speed + (spd >> 8) + (v->subspeed < t), speed_limit);

  /* adjust speed for broken vehicles */
  if (v->vehstatus & VS_AIRCRAFT_BROKEN) spd = min(spd, SPEED_LIMIT_BROKEN);

  /* updates statusbar only if speed have changed to save CPU time */
  if (spd != v->cur_speed) {
    v->cur_speed = spd;
    if (_settings_client.gui.vehicle_speed)
      InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
  }

  /* Adjust distance moved by plane speed setting */
  if (_settings_game.vehicle.plane_speed > 1) spd /= _settings_game.vehicle.plane_speed;

  if (!(v->direction & 1)) spd = spd * 3 / 4;

  spd += v->progress;
  v->progress = (byte)spd;
  return spd >> 8;
}

static byte GetAircraftFlyingAltitude(const Vehicle *v)
{
  /* Make sure Aircraft fly no lower so that they don't conduct
   * CFITs (controlled flight into terrain)
   */
  byte base_altitude = 150;

  /* Make sure eastbound and westbound planes do not "crash" into each
   * other by providing them with vertical seperation
   */
  switch (v->direction) {
    case DIR_N:
    case DIR_NE:
    case DIR_E:
    case DIR_SE:
      base_altitude += 10;
      break;

    default: break;
  }

  /* Make faster planes fly higher so that they can overtake slower ones */
  base_altitude += min(20 * (v->max_speed / 200), 90);

  return base_altitude;
}

static byte AircraftGetEntryPoint(const Vehicle *v, const AirportFTAClass *apc)
{
  assert(v != NULL);
  assert(apc != NULL);

  /* In the case the station doesn't exit anymore, set target tile 0.
   * It doesn't hurt much, aircraft will go to next order, nearest hangar
   * or it will simply crash in next tick */
  TileIndex tile = 0;

  if (IsValidStationID(v->u.air.targetairport)) {
    const Station *st = GetStation(v->u.air.targetairport);
    /* Make sure we don't go to 0,0 if the airport has been removed. */
    tile = (st->airport_tile != 0) ? st->airport_tile : st->xy;
  }

  int delta_x = v->x_pos - TileX(tile) * TILE_SIZE;
  int delta_y = v->y_pos - TileY(tile) * TILE_SIZE;

  DiagDirection dir;
  if (abs(delta_y) < abs(delta_x)) {
    /* We are northeast or southwest of the airport */
    dir = delta_x < 0 ? DIAGDIR_NE : DIAGDIR_SW;
  } else {
    /* We are northwest or southeast of the airport */
    dir = delta_y < 0 ? DIAGDIR_NW : DIAGDIR_SE;
  }
  return apc->entry_points[dir];
}

static bool AircraftController(Vehicle *v)
{
  int count;

  /* NULL if station is invalid */
  const Station *st = IsValidStationID(v->u.air.targetairport) ? GetStation(v->u.air.targetairport) : NULL;
  /* 0 if there is no station */
  TileIndex tile = 0;
  if (st != NULL) {
    tile = st->airport_tile;
    if (tile == 0) tile = st->xy;
  }
  /* DUMMY if there is no station or no airport */
  const AirportFTAClass *afc = tile == 0 ? GetAirport(AT_DUMMY) : st->Airport();

  /* prevent going to 0,0 if airport is deleted. */
  if (st == NULL || st->airport_tile == 0) {
    /* Jump into our "holding pattern" state machine if possible */
    if (v->u.air.pos >= afc->nofelements) {
      v->u.air.pos = v->u.air.previous_pos = AircraftGetEntryPoint(v, afc);
    } else if (v->u.air.targetairport != v->current_order.GetDestination()) {
      /* If not possible, just get out of here fast */
      v->u.air.state = FLYING;
      UpdateAircraftCache(v);
      AircraftNextAirportPos_and_Order(v);
      /* get aircraft back on running altitude */
      SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlyingAltitude(v));
      return false;
    }
  }

  /*  get airport moving data */
  const AirportMovingData *amd = afc->MovingData(v->u.air.pos);

  int x = TileX(tile) * TILE_SIZE;
  int y = TileY(tile) * TILE_SIZE;

  /* Helicopter raise */
  if (amd->flag & AMED_HELI_RAISE) {
    Vehicle *u = v->Next()->Next();

    /* Make sure the rotors don't rotate too fast */
    if (u->cur_speed > 32) {
      v->cur_speed = 0;
      if (--u->cur_speed == 32) SndPlayVehicleFx(SND_18_HELICOPTER, v);
    } else {
      u->cur_speed = 32;
      count = UpdateAircraftSpeed(v);
      if (count > 0) {
        v->tile = 0;

        /* Reached altitude? */
        if (v->z_pos >= 184) {
          v->cur_speed = 0;
          return true;
        }
        SetAircraftPosition(v, v->x_pos, v->y_pos, min(v->z_pos + count, 184));
      }
    }
    return false;
  }

  /* Helicopter landing. */
  if (amd->flag & AMED_HELI_LOWER) {
    if (st == NULL) {
      /* FIXME - AircraftController -> if station no longer exists, do not land
       * helicopter will circle until sign disappears, then go to next order
       * what to do when it is the only order left, right now it just stays in 1 place */
      v->u.air.state = FLYING;
      UpdateAircraftCache(v);
      AircraftNextAirportPos_and_Order(v);
      return false;
    }

    /* Vehicle is now at the airport. */
    v->tile = tile;

    /* Find altitude of landing position. */
    int z = GetSlopeZ(x, y) + 1 + afc->delta_z;

    if (z == v->z_pos) {
      Vehicle *u = v->Next()->Next();

      /*  Increase speed of rotors. When speed is 80, we've landed. */
      if (u->cur_speed >= 80) return true;
      u->cur_speed += 4;
    } else {
      count = UpdateAircraftSpeed(v);
      if (count > 0) {
        if (v->z_pos > z) {
          SetAircraftPosition(v, v->x_pos, v->y_pos, max(v->z_pos - count, z));
        } else {
          SetAircraftPosition(v, v->x_pos, v->y_pos, min(v->z_pos + count, z));
        }
      }
    }
    return false;
  }

  /* Get distance from destination pos to current pos. */
  uint dist = abs(x + amd->x - v->x_pos) +  abs(y + amd->y - v->y_pos);

  /* Need exact position? */
  if (!(amd->flag & AMED_EXACTPOS) && dist <= (amd->flag & AMED_SLOWTURN ? 8U : 4U)) return true;

  /* At final pos? */
  if (dist == 0) {
    /* Change direction smoothly to final direction. */
    DirDiff dirdiff = DirDifference(amd->direction, v->direction);
    /* if distance is 0, and plane points in right direction, no point in calling
     * UpdateAircraftSpeed(). So do it only afterwards */
    if (dirdiff == DIRDIFF_SAME) {
      v->cur_speed = 0;
      return true;
    }

    if (!UpdateAircraftSpeed(v, SPEED_LIMIT_TAXI)) return false;

    v->direction = ChangeDir(v->direction, dirdiff > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
    v->cur_speed >>= 1;

    SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
    return false;
  }

  uint speed_limit = SPEED_LIMIT_TAXI;
  bool hard_limit = true;

  if (amd->flag & AMED_NOSPDCLAMP)   speed_limit = SPEED_LIMIT_NONE;
  if (amd->flag & AMED_HOLD)       { speed_limit = SPEED_LIMIT_HOLD;     hard_limit = false; }
  if (amd->flag & AMED_LAND)       { speed_limit = SPEED_LIMIT_APPROACH; hard_limit = false; }
  if (amd->flag & AMED_BRAKE)      { speed_limit = SPEED_LIMIT_TAXI;     hard_limit = false; }

  count = UpdateAircraftSpeed(v, speed_limit, hard_limit);
  if (count == 0) return false;

  if (v->load_unload_time_rem != 0) v->load_unload_time_rem--;

  do {

    GetNewVehiclePosResult gp;

    if (dist < 4 || amd->flag & AMED_LAND) {
      /* move vehicle one pixel towards target */
      gp.x = (v->x_pos != (x + amd->x)) ?
          v->x_pos + ((x + amd->x > v->x_pos) ? 1 : -1) :
          v->x_pos;
      gp.y = (v->y_pos != (y + amd->y)) ?
          v->y_pos + ((y + amd->y > v->y_pos) ? 1 : -1) :
          v->y_pos;

      /* Oilrigs must keep v->tile as st->airport_tile, since the landing pad is in a non-airport tile */
      gp.new_tile = (st->airport_type == AT_OILRIG) ? st->airport_tile : TileVirtXY(gp.x, gp.y);

    } else {

      /* Turn. Do it slowly if in the air. */
      Direction newdir = GetDirectionTowards(v, x + amd->x, y + amd->y);
      if (newdir != v->direction) {
        v->direction = newdir;
        if (amd->flag & AMED_SLOWTURN) {
          if (v->load_unload_time_rem == 0) v->load_unload_time_rem = 8;
        } else {
          v->cur_speed >>= 1;
        }
      }

      /* Move vehicle. */
      gp = GetNewVehiclePos(v);
    }

    v->tile = gp.new_tile;
    /* If vehicle is in the air, use tile coordinate 0. */
    if (amd->flag & (AMED_TAKEOFF | AMED_SLOWTURN | AMED_LAND)) v->tile = 0;

    /* Adjust Z for land or takeoff? */
    uint z = v->z_pos;

    if (amd->flag & AMED_TAKEOFF) {
      z = min(z + 2, GetAircraftFlyingAltitude(v));
    }

    if ((amd->flag & AMED_HOLD) && (z > 150)) z--;

    if (amd->flag & AMED_LAND) {
      if (st->airport_tile == 0) {
        /* Airport has been removed, abort the landing procedure */
        v->u.air.state = FLYING;
        UpdateAircraftCache(v);
        AircraftNextAirportPos_and_Order(v);
        /* get aircraft back on running altitude */