train_cmd.cpp

Go to the documentation of this file.

/* $Id: train_cmd.cpp 14852 2009-01-05 20:29:05Z michi_cc $ */

#include "stdafx.h"
#include "openttd.h"
#include "bridge_map.h"
#include "debug.h"
#include "tile_cmd.h"
#include "landscape.h"
#include "gui.h"
#include "station_map.h"
#include "tunnel_map.h"
#include "articulated_vehicles.h"
#include "command_func.h"
#include "pathfind.h"
#include "npf.h"
#include "station_base.h"
#include "news_func.h"
#include "engine_func.h"
#include "engine_base.h"
#include "company_func.h"
#include "company_base.h"
#include "depot_base.h"
#include "depot_func.h"
#include "waypoint.h"
#include "vehicle_gui.h"
#include "train.h"
#include "bridge.h"
#include "newgrf_callbacks.h"
#include "newgrf_engine.h"
#include "newgrf_sound.h"
#include "newgrf_text.h"
#include "direction_func.h"
#include "yapf/yapf.h"
#include "yapf/follow_track.hpp"
#include "cargotype.h"
#include "group.h"
#include "table/sprites.h"
#include "tunnelbridge_map.h"
#include "strings_func.h"
#include "functions.h"
#include "window_func.h"
#include "date_func.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "signal_func.h"
#include "variables.h"
#include "autoreplace_gui.h"
#include "gfx_func.h"
#include "settings_type.h"
#include "order_func.h"
#include "newgrf_station.h"
#include "effectvehicle_func.h"
#include "gamelog.h"
#include "network/network.h"
#include "pbs.h"

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

static Track ChooseTrainTrack(Vehicle* v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool force_res, bool *got_reservation, bool mark_stuck);
static bool TrainCheckIfLineEnds(Vehicle *v);
static void TrainController(Vehicle *v, Vehicle *nomove, bool update_image);
static TileIndex TrainApproachingCrossingTile(const Vehicle *v);
static void CheckIfTrainNeedsService(Vehicle *v);
static void CheckNextTrainTile(Vehicle *v);

static const byte _vehicle_initial_x_fract[4] = {10, 8, 4,  8};
static const byte _vehicle_initial_y_fract[4] = { 8, 4, 8, 10};


static inline DiagDirection TrainExitDir(Direction direction, TrackBits track)
{
  static const TrackBits state_dir_table[DIAGDIR_END] = { TRACK_BIT_RIGHT, TRACK_BIT_LOWER, TRACK_BIT_LEFT, TRACK_BIT_UPPER };

  DiagDirection diagdir = DirToDiagDir(direction);

  /* Determine the diagonal direction in which we will exit this tile */
  if (!HasBit(direction, 0) && track != state_dir_table[diagdir]) {
    diagdir = ChangeDiagDir(diagdir, DIAGDIRDIFF_90LEFT);
  }

  return diagdir;
}


byte FreightWagonMult(CargoID cargo)
{
  if (!GetCargo(cargo)->is_freight) return 1;
  return _settings_game.vehicle.freight_trains;
}


void TrainPowerChanged(Vehicle *v)
{
  uint32 total_power = 0;
  uint32 max_te = 0;

  for (const Vehicle *u = v; u != NULL; u = u->Next()) {
    RailType railtype = GetRailType(u->tile);

    /* Power is not added for articulated parts */
    if (!IsArticulatedPart(u)) {
      bool engine_has_power = HasPowerOnRail(u->u.rail.railtype, railtype);

      const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);

      if (engine_has_power) {
        uint16 power = GetVehicleProperty(u, 0x0B, rvi_u->power);
        if (power != 0) {
          /* Halve power for multiheaded parts */
          if (IsMultiheaded(u)) power /= 2;

          total_power += power;
          /* Tractive effort in (tonnes * 1000 * 10 =) N */
          max_te += (u->u.rail.cached_veh_weight * 10000 * GetVehicleProperty(u, 0x1F, rvi_u->tractive_effort)) / 256;
        }
      }
    }

    if (HasBit(u->u.rail.flags, VRF_POWEREDWAGON) && HasPowerOnRail(v->u.rail.railtype, railtype)) {
      total_power += RailVehInfo(u->u.rail.first_engine)->pow_wag_power;
    }
  }

  if (v->u.rail.cached_power != total_power || v->u.rail.cached_max_te != max_te) {
    /* If it has no power (no catenary), stop the train */
    if (total_power == 0) v->vehstatus |= VS_STOPPED;

    v->u.rail.cached_power = total_power;
    v->u.rail.cached_max_te = max_te;
    InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
    InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
  }
}


static void TrainCargoChanged(Vehicle *v)
{
  uint32 weight = 0;

  for (Vehicle *u = v; u != NULL; u = u->Next()) {
    uint32 vweight = GetCargo(u->cargo_type)->weight * u->cargo.Count() * FreightWagonMult(u->cargo_type) / 16;

    /* Vehicle weight is not added for articulated parts. */
    if (!IsArticulatedPart(u)) {
      /* vehicle weight is the sum of the weight of the vehicle and the weight of its cargo */
      vweight += GetVehicleProperty(u, 0x16, RailVehInfo(u->engine_type)->weight);
    }

    /* powered wagons have extra weight added */
    if (HasBit(u->u.rail.flags, VRF_POWEREDWAGON)) {
      vweight += RailVehInfo(u->u.rail.first_engine)->pow_wag_weight;
    }

    /* consist weight is the sum of the weight of all vehicles in the consist */
    weight += vweight;

    /* store vehicle weight in cache */
    u->u.rail.cached_veh_weight = vweight;
  }

  /* store consist weight in cache */
  v->u.rail.cached_weight = weight;

  /* Now update train power (tractive effort is dependent on weight) */
  TrainPowerChanged(v);
}


static void RailVehicleLengthChanged(const Vehicle *u)
{
  /* show a warning once for each engine in whole game and once for each GRF after each game load */
  const Engine *engine = GetEngine(u->engine_type);
  uint32 grfid = engine->grffile->grfid;
  GRFConfig *grfconfig = GetGRFConfig(grfid);
  if (GamelogGRFBugReverse(grfid, engine->internal_id) || !HasBit(grfconfig->grf_bugs, GBUG_VEH_LENGTH)) {
    SetBit(grfconfig->grf_bugs, GBUG_VEH_LENGTH);
    SetDParamStr(0, grfconfig->name);
    SetDParam(1, u->engine_type);
    ShowErrorMessage(STR_NEWGRF_BROKEN_VEHICLE_LENGTH, STR_NEWGRF_BROKEN, 0, 0);

    /* debug output */
    char buffer[512];

    SetDParamStr(0, grfconfig->name);
    GetString(buffer, STR_NEWGRF_BROKEN, lastof(buffer));
    DEBUG(grf, 0, "%s", buffer + 3);

    SetDParam(1, u->engine_type);
    GetString(buffer, STR_NEWGRF_BROKEN_VEHICLE_LENGTH, lastof(buffer));
    DEBUG(grf, 0, "%s", buffer + 3);

    if (!_networking) _pause_game = -1;
  }
}

void CheckTrainsLengths()
{
  const Vehicle *v;

  FOR_ALL_VEHICLES(v) {
    if (v->type == VEH_TRAIN && v->First() == v && !(v->vehstatus & VS_CRASHED)) {
      for (const Vehicle *u = v, *w = v->Next(); w != NULL; u = w, w = w->Next()) {
        if (u->u.rail.track != TRACK_BIT_DEPOT) {
          if ((w->u.rail.track != TRACK_BIT_DEPOT &&
              max(abs(u->x_pos - w->x_pos), abs(u->y_pos - w->y_pos)) != u->u.rail.cached_veh_length) ||
              (w->u.rail.track == TRACK_BIT_DEPOT && TicksToLeaveDepot(u) <= 0)) {
            SetDParam(0, v->index);
            SetDParam(1, v->owner);
            ShowErrorMessage(INVALID_STRING_ID, STR_BROKEN_VEHICLE_LENGTH, 0, 0);

            if (!_networking) _pause_game = -1;
          }
        }
      }
    }
  }
}

void TrainConsistChanged(Vehicle *v, bool same_length)
{
  uint16 max_speed = UINT16_MAX;

  assert(v->type == VEH_TRAIN);
  assert(IsFrontEngine(v) || IsFreeWagon(v));

  const RailVehicleInfo *rvi_v = RailVehInfo(v->engine_type);
  EngineID first_engine = IsFrontEngine(v) ? v->engine_type : INVALID_ENGINE;
  v->u.rail.cached_total_length = 0;
  v->u.rail.compatible_railtypes = RAILTYPES_NONE;

  bool train_can_tilt = true;

  for (Vehicle *u = v; u != NULL; u = u->Next()) {
    const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);

    /* Check the v->first cache. */
    assert(u->First() == v);

    /* update the 'first engine' */
    u->u.rail.first_engine = v == u ? INVALID_ENGINE : first_engine;
    u->u.rail.railtype = rvi_u->railtype;

    if (IsTrainEngine(u)) first_engine = u->engine_type;

    /* Set user defined data to its default value */
    u->u.rail.user_def_data = rvi_u->user_def_data;
  }

  for (Vehicle *u = v; u != NULL; u = u->Next()) {
    /* Update user defined data (must be done before other properties) */
    u->u.rail.user_def_data = GetVehicleProperty(u, 0x25, u->u.rail.user_def_data);
  }

  for (Vehicle *u = v; u != NULL; u = u->Next()) {
    const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);

    if (!HasBit(EngInfo(u->engine_type)->misc_flags, EF_RAIL_TILTS)) train_can_tilt = false;

    /* Cache wagon override sprite group. NULL is returned if there is none */
    u->u.rail.cached_override = GetWagonOverrideSpriteSet(u->engine_type, u->cargo_type, u->u.rail.first_engine);

    /* Reset color map */
    u->colormap = PAL_NONE;

    if (rvi_u->visual_effect != 0) {
      u->u.rail.cached_vis_effect = rvi_u->visual_effect;
    } else {
      if (IsTrainWagon(u) || IsArticulatedPart(u)) {
        /* Wagons and articulated parts have no effect by default */
        u->u.rail.cached_vis_effect = 0x40;
      } else if (rvi_u->engclass == 0) {
        /* Steam is offset by -4 units */
        u->u.rail.cached_vis_effect = 4;
      } else {
        /* Diesel fumes and sparks come from the centre */
        u->u.rail.cached_vis_effect = 8;
      }
    }

    /* Check powered wagon / visual effect callback */
    if (HasBit(EngInfo(u->engine_type)->callbackmask, CBM_TRAIN_WAGON_POWER)) {
      uint16 callback = GetVehicleCallback(CBID_TRAIN_WAGON_POWER, 0, 0, u->engine_type, u);

      if (callback != CALLBACK_FAILED) u->u.rail.cached_vis_effect = GB(callback, 0, 8);
    }

    if (rvi_v->pow_wag_power != 0 && rvi_u->railveh_type == RAILVEH_WAGON &&
      UsesWagonOverride(u) && !HasBit(u->u.rail.cached_vis_effect, 7)) {
      /* wagon is powered */
      SetBit(u->u.rail.flags, VRF_POWEREDWAGON); // cache 'powered' status
    } else {
      ClrBit(u->u.rail.flags, VRF_POWEREDWAGON);
    }

    if (!IsArticulatedPart(u)) {
      /* Do not count powered wagons for the compatible railtypes, as wagons always
         have railtype normal */
      if (rvi_u->power > 0) {
        v->u.rail.compatible_railtypes |= GetRailTypeInfo(u->u.rail.railtype)->powered_railtypes;
      }

      /* Some electric engines can be allowed to run on normal rail. It happens to all
       * existing electric engines when elrails are disabled and then re-enabled */
      if (HasBit(u->u.rail.flags, VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL)) {
        u->u.rail.railtype = RAILTYPE_RAIL;
        u->u.rail.compatible_railtypes |= RAILTYPES_RAIL;
      }

      /* max speed is the minimum of the speed limits of all vehicles in the consist */
      if ((rvi_u->railveh_type != RAILVEH_WAGON || _settings_game.vehicle.wagon_speed_limits) && !UsesWagonOverride(u)) {
        uint16 speed = GetVehicleProperty(u, 0x09, rvi_u->max_speed);
        if (speed != 0) max_speed = min(speed, max_speed);
      }
    }

    if (u->cargo_type == rvi_u->cargo_type && u->cargo_subtype == 0) {
      /* Set cargo capacity if we've not been refitted */
      u->cargo_cap = GetVehicleProperty(u, 0x14, rvi_u->capacity);
    }

    /* check the vehicle length (callback) */
    uint16 veh_len = CALLBACK_FAILED;
    if (HasBit(EngInfo(u->engine_type)->callbackmask, CBM_VEHICLE_LENGTH)) {
      veh_len = GetVehicleCallback(CBID_VEHICLE_LENGTH, 0, 0, u->engine_type, u);
    }
    if (veh_len == CALLBACK_FAILED) veh_len = rvi_u->shorten_factor;
    veh_len = 8 - Clamp(veh_len, 0, u->Next() == NULL ? 7 : 5); // the clamp on vehicles not the last in chain is stricter, as too short wagons can break the 'follow next vehicle' code

    /* verify length hasn't changed */
    if (same_length && veh_len != u->u.rail.cached_veh_length) RailVehicleLengthChanged(u);

    /* update vehicle length? */
    if (!same_length) u->u.rail.cached_veh_length = veh_len;

    v->u.rail.cached_total_length += u->u.rail.cached_veh_length;
  }

  /* store consist weight/max speed in cache */
  v->u.rail.cached_max_speed = max_speed;
  v->u.rail.cached_tilt = train_can_tilt;

  /* recalculate cached weights and power too (we do this *after* the rest, so it is known which wagons are powered and need extra weight added) */
  TrainCargoChanged(v);

  if (IsFrontEngine(v)) {
    UpdateTrainAcceleration(v);
    InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
  }
}

enum AccelType {
  AM_ACCEL,
  AM_BRAKE
};

static int GetTrainAcceleration(Vehicle *v, bool mode)
{
  static const int absolute_max_speed = UINT16_MAX;
  int max_speed = absolute_max_speed;
  int speed = v->cur_speed * 10 / 16; // km-ish/h -> mp/h
  int curvecount[2] = {0, 0};

  /*first find the curve speed limit */
  int numcurve = 0;
  int sum = 0;
  int pos = 0;
  int lastpos = -1;
  for (const Vehicle *u = v; u->Next() != NULL; u = u->Next(), pos++) {
    Direction this_dir = u->direction;
    Direction next_dir = u->Next()->direction;

    DirDiff dirdiff = DirDifference(this_dir, next_dir);
    if (dirdiff == DIRDIFF_SAME) continue;

    if (dirdiff == DIRDIFF_45LEFT) curvecount[0]++;
    if (dirdiff == DIRDIFF_45RIGHT) curvecount[1]++;
    if (dirdiff == DIRDIFF_45LEFT || dirdiff == DIRDIFF_45RIGHT) {
      if (lastpos != -1) {
        numcurve++;
        sum += pos - lastpos;
        if (pos - lastpos == 1) {
          max_speed = 88;
        }
      }
      lastpos = pos;
    }

    /*if we have a 90 degree turn, fix the speed limit to 60 */
    if (dirdiff == DIRDIFF_90LEFT || dirdiff == DIRDIFF_90RIGHT) {
      max_speed = 61;
    }
  }

  if ((curvecount[0] != 0 || curvecount[1] != 0) && max_speed > 88) {
    int total = curvecount[0] + curvecount[1];

    if (curvecount[0] == 1 && curvecount[1] == 1) {
      max_speed = absolute_max_speed;
    } else if (total > 1) {
      if (numcurve > 0) sum /= numcurve;
      max_speed = 232 - (13 - Clamp(sum, 1, 12)) * (13 - Clamp(sum, 1, 12));
    }
  }

  if (max_speed != absolute_max_speed) {
    /* Apply the engine's rail type curve speed advantage, if it slowed by curves */
    const RailtypeInfo *rti = GetRailTypeInfo(v->u.rail.railtype);
    max_speed += (max_speed / 2) * rti->curve_speed;

    if (v->u.rail.cached_tilt) {
      /* Apply max_speed bonus of 20% for a tilting train */
      max_speed += max_speed / 5;
    }
  }

  if (IsTileType(v->tile, MP_STATION) && IsFrontEngine(v)) {
    if (v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile))) {
      int station_length = GetStationByTile(v->tile)->GetPlatformLength(v->tile, DirToDiagDir(v->direction));

      int st_max_speed = 120;

      int delta_v = v->cur_speed / (station_length + 1);
      if (v->max_speed > (v->cur_speed - delta_v)) {
        st_max_speed = v->cur_speed - (delta_v / 10);
      }

      st_max_speed = max(st_max_speed, 25 * station_length);
      max_speed = min(max_speed, st_max_speed);
    }
  }

  int mass = v->u.rail.cached_weight;
  int power = v->u.rail.cached_power * 746;
  max_speed = min(max_speed, v->u.rail.cached_max_speed);

  int num = 0; //number of vehicles, change this into the number of axles later
  int incl = 0;
  int drag_coeff = 20; //[1e-4]
  for (const Vehicle *u = v; u != NULL; u = u->Next()) {
    num++;
    drag_coeff += 3;

    if (u->u.rail.track == TRACK_BIT_DEPOT) max_speed = min(max_speed, 61);

    if (HasBit(u->u.rail.flags, VRF_GOINGUP)) {
      incl += u->u.rail.cached_veh_weight * 60; //3% slope, quite a bit actually
    } else if (HasBit(u->u.rail.flags, VRF_GOINGDOWN)) {
      incl -= u->u.rail.cached_veh_weight * 60;
    }
  }

  v->max_speed = max_speed;

  const int area = 120;
  const int friction = 35; //[1e-3]
  int resistance;
  if (v->u.rail.railtype != RAILTYPE_MAGLEV) {
    resistance = 13 * mass / 10;
    resistance += 60 * num;
    resistance += friction * mass * speed / 1000;
    resistance += (area * drag_coeff * speed * speed) / 10000;
  } else {
    resistance = (area * (drag_coeff / 2) * speed * speed) / 10000;
  }
  resistance += incl;
  resistance *= 4; //[N]

  /* Due to the mph to m/s conversion below, at speeds below 3 mph the force is
   * actually double the train's power */
  const int max_te = v->u.rail.cached_max_te; // [N]
  int force;
  if (speed > 2) {
    switch (v->u.rail.railtype) {
      case RAILTYPE_RAIL:
      case RAILTYPE_ELECTRIC:
      case RAILTYPE_MONO:
        force = power / speed; //[N]
        force *= 22;
        force /= 10;
        if (mode == AM_ACCEL && force > max_te) force = max_te;
        break;

      default: NOT_REACHED();
      case RAILTYPE_MAGLEV:
        force = power / 25;
        break;
    }
  } else {
    /* "kickoff" acceleration */
    force = (mode == AM_ACCEL && v->u.rail.railtype != RAILTYPE_MAGLEV) ? min(max_te, power) : power;
    force = max(force, (mass * 8) + resistance);
  }

  if (force <= 0) force = 10000;

  if (v->u.rail.railtype != RAILTYPE_MAGLEV) force = min(force, mass * 10 * 200);

  if (mode == AM_ACCEL) {
    return (force - resistance) / (mass * 4);
  } else {
    return min((-force - resistance) / (mass * 4), -10000 / (mass * 4));
  }
}

void UpdateTrainAcceleration(Vehicle *v)
{
  assert(IsFrontEngine(v));

  v->max_speed = v->u.rail.cached_max_speed;

  uint power = v->u.rail.cached_power;
  uint weight = v->u.rail.cached_weight;
  assert(weight != 0);
  v->acceleration = Clamp(power / weight * 4, 1, 255);
}

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

  if (HasBit(this->u.rail.flags, VRF_REVERSE_DIRECTION)) direction = ReverseDir(direction);

  if (is_custom_sprite(spritenum)) {
    sprite = GetCustomVehicleSprite(this, (Direction)(direction + 4 * IS_CUSTOM_SECONDHEAD_SPRITE(spritenum)));
    if (sprite != 0) return sprite;

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

  sprite = _engine_sprite_base[spritenum] + ((direction + _engine_sprite_add[spritenum]) & _engine_sprite_and[spritenum]);

  if (this->cargo.Count() >= this->cargo_cap / 2U) sprite += _wagon_full_adder[spritenum];

  return sprite;
}

static SpriteID GetRailIcon(EngineID engine, bool rear_head, int &y)
{
  Direction dir = rear_head ? DIR_E : DIR_W;
  uint8 spritenum = RailVehInfo(engine)->image_index;

  if (is_custom_sprite(spritenum)) {
    SpriteID sprite = GetCustomVehicleIcon(engine, dir);
    if (sprite != 0) {
      y += _traininfo_vehicle_pitch; // TODO Make this per-GRF
      return sprite;
    }

    spritenum = GetEngine(engine)->image_index;
  }

  if (rear_head) spritenum++;

  return ((6 + _engine_sprite_add[spritenum]) & _engine_sprite_and[spritenum]) + _engine_sprite_base[spritenum];
}

void DrawTrainEngine(int x, int y, EngineID engine, SpriteID pal)
{
  if (RailVehInfo(engine)->railveh_type == RAILVEH_MULTIHEAD) {
    int yf = y;
    int yr = y;

    SpriteID spritef = GetRailIcon(engine, false, yf);
    SpriteID spriter = GetRailIcon(engine, true, yr);
    DrawSprite(spritef, pal, x - 14, yf);
    DrawSprite(spriter, pal, x + 15, yr);
  } else {
    SpriteID sprite = GetRailIcon(engine, false, y);
    DrawSprite(sprite, pal, x, y);
  }
}

static CommandCost CmdBuildRailWagon(EngineID engine, TileIndex tile, uint32 flags)
{
  const RailVehicleInfo *rvi = RailVehInfo(engine);
  CommandCost value(EXPENSES_NEW_VEHICLES, (GetEngineProperty(engine, 0x17, rvi->cost_factor) * _price.build_railwagon) >> 8);

  uint num_vehicles = 1 + CountArticulatedParts(engine, false);

  if (!(flags & DC_QUERY_COST)) {
    /* Check that the wagon can drive on the track in question */
    if (!IsCompatibleRail(rvi->railtype, GetRailType(tile))) return CMD_ERROR;

    /* Allow for the wagon and the articulated parts, plus one to "terminate" the list. */
    Vehicle **vl = AllocaM(Vehicle*, num_vehicles + 1);
    memset(vl, 0, sizeof(*vl) * (num_vehicles + 1));

    if (!Vehicle::AllocateList(vl, num_vehicles))
      return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

    if (flags & DC_EXEC) {
      Vehicle *v = vl[0];
      v->spritenum = rvi->image_index;

      Vehicle *u = NULL;

      Vehicle *w;
      FOR_ALL_VEHICLES(w) {
        if (w->type == VEH_TRAIN && w->tile == tile &&
            IsFreeWagon(w) && w->engine_type == engine &&
            !HASBITS(w->vehstatus, VS_CRASHED)) {          
          u = GetLastVehicleInChain(w);
          break;
        }
      }

      v = new (v) Train();
      v->engine_type = engine;

      DiagDirection dir = GetRailDepotDirection(tile);

      v->direction = DiagDirToDir(dir);
      v->tile = tile;

      int x = TileX(tile) * TILE_SIZE | _vehicle_initial_x_fract[dir];
      int y = TileY(tile) * TILE_SIZE | _vehicle_initial_y_fract[dir];

      v->x_pos = x;
      v->y_pos = y;
      v->z_pos = GetSlopeZ(x, y);
      v->owner = _current_company;
      v->u.rail.track = TRACK_BIT_DEPOT;
      v->vehstatus = VS_HIDDEN | VS_DEFPAL;

//      v->subtype = 0;
      SetTrainWagon(v);

      if (u != NULL) {
        u->SetNext(v);
      } else {
        SetFreeWagon(v);
        InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
      }

      v->cargo_type = rvi->cargo_type;
//      v->cargo_subtype = 0;
      v->cargo_cap = rvi->capacity;
      v->value = value.GetCost();
//      v->day_counter = 0;

      v->u.rail.railtype = rvi->railtype;

      v->build_year = _cur_year;
      v->cur_image = 0xAC2;
      v->random_bits = VehicleRandomBits();

      v->group_id = DEFAULT_GROUP;

      AddArticulatedParts(vl, VEH_TRAIN);

      _new_vehicle_id = v->index;

      VehiclePositionChanged(v);
      TrainConsistChanged(v->First(), false);
      UpdateTrainGroupID(v->First());

      InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
      if (IsLocalCompany()) {
        InvalidateAutoreplaceWindow(v->engine_type, v->group_id); // updates the replace Train window
      }
      GetCompany(_current_company)->num_engines[engine]++;
    }
  }

  return value;
}

static void NormalizeTrainVehInDepot(const Vehicle *u)
{
  const Vehicle *v;

  FOR_ALL_VEHICLES(v) {
    if (v->type == VEH_TRAIN && IsFreeWagon(v) &&
        v->tile == u->tile &&
        v->u.rail.track == TRACK_BIT_DEPOT) {
      if (CmdFailed(DoCommand(0, v->index | (u->index << 16), 1, DC_EXEC,
          CMD_MOVE_RAIL_VEHICLE)))
        break;
    }
  }
}

static CommandCost EstimateTrainCost(EngineID engine, const RailVehicleInfo *rvi)
{
  return CommandCost(EXPENSES_NEW_VEHICLES, GetEngineProperty(engine, 0x17, rvi->cost_factor) * (_price.build_railvehicle >> 3) >> 5);
}

static void AddRearEngineToMultiheadedTrain(Vehicle *v, Vehicle *u, bool building)
{
  u = new (u) Train();
  u->direction = v->direction;
  u->owner = v->owner;
  u->tile = v->tile;
  u->x_pos = v->x_pos;
  u->y_pos = v->y_pos;
  u->z_pos = v->z_pos;
  u->u.rail.track = TRACK_BIT_DEPOT;
  u->vehstatus = v->vehstatus & ~VS_STOPPED;
//  u->subtype = 0;
  SetMultiheaded(u);
  u->spritenum = v->spritenum + 1;
  u->cargo_type = v->cargo_type;
  u->cargo_subtype = v->cargo_subtype;
  u->cargo_cap = v->cargo_cap;
  u->u.rail.railtype = v->u.rail.railtype;
  if (building) v->SetNext(u);
  u->engine_type = v->engine_type;
  u->build_year = v->build_year;
  if (building) v->value >>= 1;
  u->value = v->value;
  u->cur_image = 0xAC2;
  u->random_bits = VehicleRandomBits();
  VehiclePositionChanged(u);
}

CommandCost CmdBuildRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2, const char *text)
{
  /* Check if the engine-type is valid (for the company) */
  if (!IsEngineBuildable(p1, VEH_TRAIN, _current_company)) return_cmd_error(STR_RAIL_VEHICLE_NOT_AVAILABLE);

  /* Check if the train is actually being built in a depot belonging
   * to the company. Doesn't matter if only the cost is queried */
  if (!(flags & DC_QUERY_COST)) {
    if (!IsRailDepotTile(tile)) return CMD_ERROR;
    if (!IsTileOwner(tile, _current_company)) return CMD_ERROR;
  }

  const RailVehicleInfo *rvi = RailVehInfo(p1);

  if (rvi->railveh_type == RAILVEH_WAGON) return CmdBuildRailWagon(p1, tile, flags);

  CommandCost value = EstimateTrainCost(p1, rvi);

  uint num_vehicles =
    (rvi->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1) +
    CountArticulatedParts(p1, false);

  if (!(flags & DC_QUERY_COST)) {
    /* Check if depot and new engine uses the same kind of tracks *
     * We need to see if the engine got power on the tile to avoid eletric engines in non-electric depots */
    if (!HasPowerOnRail(rvi->railtype, GetRailType(tile))) return CMD_ERROR;

    /* Allow for the dual-heads and the articulated parts, plus one to "terminate" the list. */
    Vehicle **vl = AllocaM(Vehicle*, num_vehicles + 1);
    memset(vl, 0, sizeof(*vl) * (num_vehicles + 1));

    if (!Vehicle::AllocateList(vl, num_vehicles)) {
      return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
    }

    Vehicle *v = vl[0];

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

    if (flags & DC_EXEC) {
      DiagDirection dir = GetRailDepotDirection(tile);
      int x = TileX(tile) * TILE_SIZE + _vehicle_initial_x_fract[dir];
      int y = TileY(tile) * TILE_SIZE + _vehicle_initial_y_fract[dir];

      v = new (v) Train();
      v->unitnumber = unit_num;
      v->direction = DiagDirToDir(dir);
      v->tile = tile;
      v->owner = _current_company;
      v->x_pos = x;
      v->y_pos = y;
      v->z_pos = GetSlopeZ(x, y);
//      v->running_ticks = 0;
      v->u.rail.track = TRACK_BIT_DEPOT;
      v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
      v->spritenum = rvi->image_index;
      v->cargo_type = rvi->cargo_type;
//      v->cargo_subtype = 0;
      v->cargo_cap = rvi->capacity;
      v->max_speed = rvi->max_speed;
      v->value = value.GetCost();
      v->last_station_visited = INVALID_STATION;
//      v->dest_tile = 0;

      v->engine_type = p1;

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

      v->name = NULL;
      v->u.rail.railtype = rvi->railtype;
      _new_vehicle_id = v->index;

      v->service_interval = _settings_game.vehicle.servint_trains;
      v->date_of_last_service = _date;
      v->build_year = _cur_year;
      v->cur_image = 0xAC2;
      v->random_bits = VehicleRandomBits();

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

      v->group_id = DEFAULT_GROUP;

//      v->subtype = 0;
      SetFrontEngine(v);
      SetTrainEngine(v);

      VehiclePositionChanged(v);

      if (rvi->railveh_type == RAILVEH_MULTIHEAD) {
        SetMultiheaded(v);
        AddRearEngineToMultiheadedTrain(vl[0], vl[1], true);
        /* Now we need to link the front and rear engines together
         * other_multiheaded_part is the pointer that links to the other half of the engine
         * vl[0] is the front and vl[1] is the rear
         */
        vl[0]->u.rail.other_multiheaded_part = vl[1];
        vl[1]->u.rail.other_multiheaded_part = vl[0];
      } else {
        AddArticulatedParts(vl, VEH_TRAIN);
      }

      TrainConsistChanged(v, false);
      UpdateTrainGroupID(v);

      if (!HasBit(p2, 1) && !(flags & DC_AUTOREPLACE)) { // check if the cars should be added to the new vehicle
        NormalizeTrainVehInDepot(v);
      }

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

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

  return value;
}


/* Check if all the wagons of the given train are in a depot, returns the
 * number of cars (including loco) then. If not it returns -1 */
int CheckTrainInDepot(const Vehicle *v, bool needs_to_be_stopped)
{
  TileIndex tile = v->tile;

  /* check if stopped in a depot */
  if (!IsRailDepotTile(tile) || v->cur_speed != 0) return -1;

  int count = 0;
  for (; v != NULL; v = v->Next()) {
    /* This count is used by the depot code to determine the number of engines
     * in the consist. Exclude articulated parts so that autoreplacing to
     * engines with more articulated parts than before works correctly.
     *
     * Also skip counting rear ends of multiheaded engines */
    if (!IsArticulatedPart(v) && !IsRearDualheaded(v)) count++;
    if (v->u.rail.track != TRACK_BIT_DEPOT || v->tile != tile ||
        (IsFrontEngine(v) && needs_to_be_stopped && !(v->vehstatus & VS_STOPPED))) {
      return -1;
    }
  }

  return count;
}

/* Used to check if the train is inside the depot and verifying that the VS_STOPPED flag is set */
int CheckTrainStoppedInDepot(const Vehicle *v)
{
  return CheckTrainInDepot(v, true);
}

/* Used to check if the train is inside the depot, but not checking the VS_STOPPED flag */
inline bool CheckTrainIsInsideDepot(const Vehicle *v)
{
  return CheckTrainInDepot(v, false) > 0;
}

static Vehicle *UnlinkWagon(Vehicle *v, Vehicle *first)
{
  /* unlinking the first vehicle of the chain? */
  if (v == first) {
    v = GetNextVehicle(v);
    if (v == NULL) return NULL;

    if (IsTrainWagon(v)) SetFreeWagon(v);

    /* First can be an articulated engine, meaning GetNextVehicle() isn't
     * v->Next(). Thus set the next vehicle of the last articulated part
     * and the last articulated part is just before the next vehicle (v). */
    v->Previous()->SetNext(NULL);

    return v;
  }

  Vehicle *u;
  for (u = first; GetNextVehicle(u) != v; u = GetNextVehicle(u)) {}
  GetLastEnginePart(u)->SetNext(GetNextVehicle(v));
  return first;
}

static Vehicle *FindGoodVehiclePos(const Vehicle *src)
{
  Vehicle *dst;
  EngineID eng = src->engine_type;
  TileIndex tile = src->tile;

  FOR_ALL_VEHICLES(dst) {
    if (dst->type == VEH_TRAIN && IsFreeWagon(dst) && dst->tile == tile && !HASBITS(dst->vehstatus, VS_CRASHED)) {
      /* check so all vehicles in the line have the same engine. */
      Vehicle *v = dst;

      while (v->engine_type == eng) {
        v = v->Next();
        if (v == NULL) return dst;
      }
    }
  }

  return NULL;
}

/*
 * add a vehicle v behind vehicle dest
 * use this function since it sets flags as needed
 */
static void AddWagonToConsist(Vehicle *v, Vehicle *dest)
{
  UnlinkWagon(v, v->First());
  if (dest == NULL) return;

  Vehicle *next = dest->Next();
  v->SetNext(NULL);
  dest->SetNext(v);
  v->SetNext(next);
  ClearFreeWagon(v);
  ClearFrontEngine(v);
}

/*
 * move around on the train so rear engines are placed correctly according to the other engines
 * always call with the front engine
 */
static void NormaliseTrainConsist(Vehicle *v)
{
  if (IsFreeWagon(v)) return;

  assert(IsFrontEngine(v));

  for (; v != NULL; v = GetNextVehicle(v)) {
    if (!IsMultiheaded(v) || !IsTrainEngine(v)) continue;

    /* make sure that there are no free cars before next engine */
    Vehicle *u;
    for (u = v; u->Next() != NULL && !IsTrainEngine(u->Next()); u = u->Next()) {}

    if (u == v->u.rail.other_multiheaded_part) continue;
    AddWagonToConsist(v->u.rail.other_multiheaded_part, u);
  }
}

CommandCost CmdMoveRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2, const char *text)
{
  VehicleID s = GB(p1, 0, 16);
  VehicleID d = GB(p1, 16, 16);

  if (!IsValidVehicleID(s)) return CMD_ERROR;

  Vehicle *src = GetVehicle(s);

  if (src->type != VEH_TRAIN || !CheckOwnership(src->owner)) return CMD_ERROR;

  /* Do not allow moving crashed vehicles inside the depot, it is likely to cause asserts later */
  if (HASBITS(src->vehstatus, VS_CRASHED)) return CMD_ERROR;

  /* if nothing is selected as destination, try and find a matching vehicle to drag to. */
  Vehicle *dst;
  if (d == INVALID_VEHICLE) {
    dst = IsTrainEngine(src) ? NULL : FindGoodVehiclePos(src);
  } else {
    if (!IsValidVehicleID(d)) return CMD_ERROR;
    dst = GetVehicle(d);
    if (dst->type != VEH_TRAIN || !CheckOwnership(dst->owner)) return CMD_ERROR;

    /* Do not allow appending to crashed vehicles, too */
    if (HASBITS(dst->vehstatus, VS_CRASHED)) return CMD_ERROR;
  }

  /* if an articulated part is being handled, deal with its parent vehicle */
  while (IsArticulatedPart(src)) src = src->Previous();
  if (dst != NULL) {
    while (IsArticulatedPart(dst)) dst = dst->Previous();
  }

  /* don't move the same vehicle.. */
  if (src == dst) return CommandCost();

  /* locate the head of the two chains */
  Vehicle *src_head = src->First();
  Vehicle *dst_head;
  if (dst != NULL) {
    dst_head = dst->First();
    if (dst_head->tile != src_head->tile) return CMD_ERROR;
    /* Now deal with articulated part of destination wagon */
    dst = GetLastEnginePart(dst);
  } else {
    dst_head = NULL;
  }

  if (IsRearDualheaded(src)) return_cmd_error(STR_REAR_ENGINE_FOLLOW_FRONT_ERROR);

  /* when moving all wagons, we can't have the same src_head and dst_head */
  if (HasBit(p2, 0) && src_head == dst_head) return CommandCost();

  /* check if all vehicles in the source train are stopped inside a depot. */
  int src_len = CheckTrainStoppedInDepot(src_head);
  if (src_len < 0) return_cmd_error(STR_881A_TRAINS_CAN_ONLY_BE_ALTERED);

  if ((flags & DC_AUTOREPLACE) == 0) {
    /* Check whether there are more than 'max_len' train units (articulated parts and rear heads do not count) in the new chain */
    int max_len = _settings_game.