summaryrefslogtreecommitdiff
path: root/src/train_cmd.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/train_cmd.cpp')
-rw-r--r--src/train_cmd.cpp3811
1 files changed, 3811 insertions, 0 deletions
diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp
new file mode 100644
index 000000000..074d92ce7
--- /dev/null
+++ b/src/train_cmd.cpp
@@ -0,0 +1,3811 @@
+/* $Id$ */
+
+#include "stdafx.h"
+#include "openttd.h"
+#include "bridge_map.h"
+#include "debug.h"
+#include "functions.h"
+#include "gui.h"
+#include "station_map.h"
+#include "table/strings.h"
+#include "map.h"
+#include "tile.h"
+#include "tunnel_map.h"
+#include "vehicle.h"
+#include "command.h"
+#include "pathfind.h"
+#include "npf.h"
+#include "station.h"
+#include "table/train_cmd.h"
+#include "news.h"
+#include "engine.h"
+#include "player.h"
+#include "sound.h"
+#include "depot.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.h"
+#include "yapf/yapf.h"
+#include "date.h"
+
+static bool TrainCheckIfLineEnds(Vehicle *v);
+static void TrainController(Vehicle *v, bool update_image);
+
+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 const byte _state_dir_table[4] = { 0x20, 8, 0x10, 4 };
+
+
+/** Return the cargo weight multiplier to use for a rail vehicle
+ * @param cargo Cargo type to get multiplier for
+ * @return Cargo weight multiplier
+ */
+byte FreightWagonMult(CargoID cargo)
+{
+ // XXX NewCargos introduces a specific "is freight" flag for this test.
+ if (cargo == CT_PASSENGERS || cargo == CT_MAIL) return 1;
+ return _patches.freight_trains;
+}
+
+
+/**
+ * Recalculates the cached total power of a train. Should be called when the consist is changed
+ * @param v First vehicle of the consist.
+ */
+void TrainPowerChanged(Vehicle* v)
+{
+ Vehicle* u;
+ uint32 power = 0;
+ uint32 max_te = 0;
+
+ for (u = v; u != NULL; u = u->next) {
+ const RailVehicleInfo *rvi_u;
+ bool engine_has_power = true;
+ bool wagon_has_power = true;
+
+ /* Power is not added for articulated parts */
+ if (IsArticulatedPart(u)) continue;
+
+ if (IsLevelCrossingTile(u->tile)) {
+ if (!HasPowerOnRail(u->u.rail.railtype, GetRailTypeCrossing(u->tile))) engine_has_power = false;
+ if (!HasPowerOnRail(v->u.rail.railtype, GetRailTypeCrossing(u->tile))) wagon_has_power = false;
+ } else {
+ if (!HasPowerOnRail(u->u.rail.railtype, GetRailType(u->tile))) engine_has_power = false;
+ if (!HasPowerOnRail(v->u.rail.railtype, GetRailType(u->tile))) wagon_has_power = false;
+ }
+
+ rvi_u = RailVehInfo(u->engine_type);
+
+ if (engine_has_power && rvi_u->power != 0) {
+ power += rvi_u->power;
+ /* Tractive effort in (tonnes * 1000 * 10 =) N */
+ max_te += (u->u.rail.cached_veh_weight * 10000 * rvi_u->tractive_effort) / 256;
+ }
+
+ if (HASBIT(u->u.rail.flags, VRF_POWEREDWAGON) && (wagon_has_power)) {
+ power += RailVehInfo(u->u.rail.first_engine)->pow_wag_power;
+ }
+ }
+
+ if (v->u.rail.cached_power != power || v->u.rail.cached_max_te != max_te) {
+ v->u.rail.cached_power = power;
+ v->u.rail.cached_max_te = max_te;
+ InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+ }
+}
+
+
+/**
+ * Recalculates the cached weight of a train and its vehicles. Should be called each time the cargo on
+ * the consist changes.
+ * @param v First vehicle of the consist.
+ */
+static void TrainCargoChanged(Vehicle* v)
+{
+ Vehicle *u;
+ uint32 weight = 0;
+
+ for (u = v; u != NULL; u = u->next) {
+ const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);
+ uint32 vweight = (_cargoc.weights[u->cargo_type] * 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 += rvi->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);
+}
+
+
+/**
+ * Recalculates the cached stuff of a train. Should be called each time a vehicle is added
+ * to/removed from the chain, and when the game is loaded.
+ * Note: this needs to be called too for 'wagon chains' (in the depot, without an engine)
+ * @param v First vehicle of the chain.
+ */
+void TrainConsistChanged(Vehicle* v)
+{
+ const RailVehicleInfo *rvi_v;
+ Vehicle *u;
+ uint16 max_speed = 0xFFFF;
+ EngineID first_engine;
+
+ assert(v->type == VEH_Train);
+
+ assert(IsFrontEngine(v) || IsFreeWagon(v));
+
+ rvi_v = RailVehInfo(v->engine_type);
+ first_engine = IsFrontEngine(v) ? v->engine_type : INVALID_ENGINE;
+ v->u.rail.cached_total_length = 0;
+ v->u.rail.compatible_railtypes = 0;
+
+ for (u = v; u != NULL; u = u->next) {
+ const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);
+ uint16 veh_len;
+
+ // Update the v->first cache. This is faster than having to brute force it later.
+ if (u->first == NULL) u->first = v;
+
+ // update the 'first engine'
+ u->u.rail.first_engine = (v == u) ? INVALID_ENGINE : first_engine;
+ u->u.rail.railtype = GetEngine(u->engine_type)->railtype;
+
+ if (IsTrainEngine(u)) first_engine = u->engine_type;
+
+ 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;
+ }
+ }
+
+ if (!IsArticulatedPart(u)) {
+ // check if its a powered wagon
+ CLRBIT(u->u.rail.flags, VRF_POWEREDWAGON);
+
+ /* Check powered wagon / visual effect callback */
+ if (HASBIT(EngInfo(u->engine_type)->callbackmask, CBM_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 = callback;
+ }
+
+ if ((rvi_v->pow_wag_power != 0) && (rvi_u->flags & RVI_WAGON) && UsesWagonOverride(u)) {
+ if (u->u.rail.cached_vis_effect < 0x40) {
+ /* wagon is powered */
+ SETBIT(u->u.rail.flags, VRF_POWEREDWAGON); // cache 'powered' status
+ }
+ }
+
+ /* 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 |= (1 << RAILTYPE_RAIL);
+ }
+
+ // max speed is the minimum of the speed limits of all vehicles in the consist
+ if (!(rvi_u->flags & RVI_WAGON) || _patches.wagon_speed_limits)
+ if (rvi_u->max_speed != 0 && !UsesWagonOverride(u))
+ max_speed = min(rvi_u->max_speed, max_speed);
+ }
+
+ // check the vehicle length (callback)
+ veh_len = CALLBACK_FAILED;
+ if (HASBIT(EngInfo(u->engine_type)->callbackmask, CBM_VEHICLE_LENGTH)) {
+ veh_len = GetVehicleCallback(CBID_TRAIN_VEHICLE_LENGTH, 0, 0, u->engine_type, u);
+ }
+ if (veh_len == CALLBACK_FAILED) veh_len = rvi_u->shorten_factor;
+ veh_len = 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
+ u->u.rail.cached_veh_length = 8 - 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;
+
+ // 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);
+}
+
+/* These two arrays are used for realistic acceleration. XXX: How should they
+ * be interpreted? */
+static const byte _curve_neighbours45[8][2] = {
+ {7, 1},
+ {0, 2},
+ {1, 3},
+ {2, 4},
+ {3, 5},
+ {4, 6},
+ {5, 7},
+ {6, 0},
+};
+
+static const byte _curve_neighbours90[8][2] = {
+ {6, 2},
+ {7, 3},
+ {0, 4},
+ {1, 5},
+ {2, 6},
+ {3, 7},
+ {4, 0},
+ {5, 1},
+};
+
+enum AccelType {
+ AM_ACCEL,
+ AM_BRAKE
+};
+
+static bool TrainShouldStop(const Vehicle* v, TileIndex tile)
+{
+ const Order* o = &v->current_order;
+ StationID sid = GetStationIndex(tile);
+
+ assert(v->type == VEH_Train);
+ //When does a train drive through a station
+ //first we deal with the "new nonstop handling"
+ if (_patches.new_nonstop && o->flags & OF_NON_STOP && sid == o->dest) {
+ return false;
+ }
+
+ if (v->last_station_visited == sid) return false;
+
+ if (sid != o->dest && (o->flags & OF_NON_STOP || _patches.new_nonstop)) {
+ return false;
+ }
+
+ return true;
+}
+
+//new acceleration
+static int GetTrainAcceleration(Vehicle *v, bool mode)
+{
+ const Vehicle *u;
+ int num = 0; //number of vehicles, change this into the number of axles later
+ int power = 0;
+ int mass = 0;
+ int max_speed = 2000;
+ int area = 120;
+ int friction = 35; //[1e-3]
+ int drag_coeff = 20; //[1e-4]
+ int incl = 0;
+ int resistance;
+ int speed = v->cur_speed; //[mph]
+ int force = 0x3FFFFFFF;
+ int pos = 0;
+ int lastpos = -1;
+ int curvecount[2] = {0, 0};
+ int sum = 0;
+ int numcurve = 0;
+ int max_te = v->u.rail.cached_max_te; // [N]
+
+ speed *= 10;
+ speed /= 16;
+
+ //first find the curve speed limit
+ for (u = v; u->next != NULL; u = u->next, pos++) {
+ Direction dir = u->direction;
+ Direction ndir = u->next->direction;
+ int i;
+
+ for (i = 0; i < 2; i++) {
+ if ( _curve_neighbours45[dir][i] == ndir) {
+ curvecount[i]++;
+ 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 (_curve_neighbours90[dir][0] == ndir ||
+ _curve_neighbours90[dir][1] == ndir) {
+ max_speed = 61;
+ }
+ }
+
+ if (numcurve > 0) sum /= numcurve;
+
+ 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 = 0xFFFF;
+ } else if (total > 1) {
+ max_speed = 232 - (13 - clamp(sum, 1, 12)) * (13 - clamp(sum, 1, 12));
+ }
+ }
+
+ max_speed += (max_speed / 2) * v->u.rail.railtype;
+
+ if (IsTileType(v->tile, MP_STATION) && IsFrontEngine(v)) {
+ if (TrainShouldStop(v, v->tile)) {
+ uint station_length = GetPlatformLength(v->tile, DirToDiagDir(v->direction));
+ int delta_v;
+
+ max_speed = 120;
+
+ delta_v = v->cur_speed / (station_length + 1);
+ if (v->max_speed > (v->cur_speed - delta_v))
+ max_speed = v->cur_speed - (delta_v / 10);
+
+ max_speed = max(max_speed, 25 * station_length);
+ }
+ }
+
+ mass = v->u.rail.cached_weight;
+ power = v->u.rail.cached_power * 746;
+ max_speed = min(max_speed, v->u.rail.cached_max_speed);
+
+ for (u = v; u != NULL; u = u->next) {
+ num++;
+ drag_coeff += 3;
+
+ if (u->u.rail.track == 0x80) 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;
+
+ 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 */
+ 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;
+
+ 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));
+ }
+}
+
+static void UpdateTrainAcceleration(Vehicle* v)
+{
+ uint power = 0;
+ uint weight = 0;
+
+ assert(IsFrontEngine(v));
+
+ weight = v->u.rail.cached_weight;
+ power = v->u.rail.cached_power;
+ v->max_speed = v->u.rail.cached_max_speed;
+
+ assert(weight != 0);
+
+ v->acceleration = clamp(power / weight * 4, 1, 255);
+}
+
+int GetTrainImage(const Vehicle* v, Direction direction)
+{
+ int img = v->spritenum;
+ int base;
+
+ if (HASBIT(v->u.rail.flags, VRF_REVERSE_DIRECTION)) direction = ReverseDir(direction);
+
+ if (is_custom_sprite(img)) {
+ base = GetCustomVehicleSprite(v, direction + 4 * IS_CUSTOM_SECONDHEAD_SPRITE(img));
+ if (base != 0) return base;
+ img = orig_rail_vehicle_info[v->engine_type].image_index;
+ }
+
+ base = _engine_sprite_base[img] + ((direction + _engine_sprite_add[img]) & _engine_sprite_and[img]);
+
+ if (v->cargo_count >= v->cargo_cap / 2) base += _wagon_full_adder[img];
+ return base;
+}
+
+void DrawTrainEngine(int x, int y, EngineID engine, uint32 image_ormod)
+{
+ const RailVehicleInfo *rvi = RailVehInfo(engine);
+
+ int img = rvi->image_index;
+ uint32 image = 0;
+
+ if (is_custom_sprite(img)) {
+ image = GetCustomVehicleIcon(engine, DIR_W);
+ if (image == 0) {
+ img = orig_rail_vehicle_info[engine].image_index;
+ } else {
+ y += _traininfo_vehicle_pitch;
+ }
+ }
+ if (image == 0) {
+ image = (6 & _engine_sprite_and[img]) + _engine_sprite_base[img];
+ }
+
+ if (rvi->flags & RVI_MULTIHEAD) {
+ DrawSprite(image | image_ormod, x - 14, y);
+ x += 15;
+ image = 0;
+ if (is_custom_sprite(img)) {
+ image = GetCustomVehicleIcon(engine, 2);
+ if (image == 0) img = orig_rail_vehicle_info[engine].image_index;
+ }
+ if (image == 0) {
+ image =
+ ((6 + _engine_sprite_add[img + 1]) & _engine_sprite_and[img + 1]) +
+ _engine_sprite_base[img + 1];
+ }
+ }
+ DrawSprite(image | image_ormod, x, y);
+}
+
+uint CountArticulatedParts(EngineID engine_type)
+{
+ uint16 callback;
+ uint i;
+
+ if (!HASBIT(EngInfo(engine_type)->callbackmask, CBM_ARTIC_ENGINE)) return 0;
+
+ for (i = 1; i < 10; i++) {
+ callback = GetVehicleCallback(CBID_TRAIN_ARTIC_ENGINE, i, 0, engine_type, NULL);
+ if (callback == CALLBACK_FAILED || callback == 0xFF) break;
+ }
+
+ return i - 1;
+}
+
+static void AddArticulatedParts(Vehicle **vl)
+{
+ const RailVehicleInfo *rvi_artic;
+ EngineID engine_type;
+ Vehicle *v = vl[0];
+ Vehicle *u = v;
+ uint16 callback;
+ bool flip_image;
+ uint i;
+
+ if (!HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_ARTIC_ENGINE)) return;
+
+ for (i = 1; i < 10; i++) {
+ callback = GetVehicleCallback(CBID_TRAIN_ARTIC_ENGINE, i, 0, v->engine_type, v);
+ if (callback == CALLBACK_FAILED || callback == 0xFF) return;
+
+ /* Attempt to use pre-allocated vehicles until they run out. This can happen
+ * if the callback returns different values depending on the cargo type. */
+ u->next = vl[i];
+ if (u->next == NULL) u->next = AllocateVehicle();
+ if (u->next == NULL) return;
+
+ u = u->next;
+
+ engine_type = GB(callback, 0, 7);
+ flip_image = HASBIT(callback, 7);
+ rvi_artic = RailVehInfo(engine_type);
+
+ // get common values from first engine
+ 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->z_height = v->z_height;
+ u->u.rail.track = v->u.rail.track;
+ u->u.rail.railtype = v->u.rail.railtype;
+ u->build_year = v->build_year;
+ u->vehstatus = v->vehstatus & ~VS_STOPPED;
+ u->u.rail.first_engine = v->engine_type;
+
+ // get more settings from rail vehicle info
+ u->spritenum = rvi_artic->image_index;
+ if (flip_image) u->spritenum++;
+ u->cargo_type = rvi_artic->cargo_type;
+ u->cargo_subtype = 0;
+ u->cargo_cap = rvi_artic->capacity;
+ u->max_speed = 0;
+ u->max_age = 0;
+ u->engine_type = engine_type;
+ u->value = 0;
+ u->type = VEH_Train;
+ u->subtype = 0;
+ SetArticulatedPart(u);
+ u->cur_image = 0xAC2;
+ u->random_bits = VehicleRandomBits();
+
+ VehiclePositionChanged(u);
+ }
+}
+
+static int32 CmdBuildRailWagon(EngineID engine, TileIndex tile, uint32 flags)
+{
+ int32 value;
+ const RailVehicleInfo *rvi;
+ uint num_vehicles;
+
+ SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
+
+ rvi = RailVehInfo(engine);
+ value = (rvi->base_cost * _price.build_railwagon) >> 8;
+
+ num_vehicles = 1 + CountArticulatedParts(engine);
+
+ if (!(flags & DC_QUERY_COST)) {
+ Vehicle *vl[11]; // Allow for wagon and upto 10 artic parts.
+ Vehicle* v;
+ int x;
+ int y;
+
+ memset(&vl, 0, sizeof(vl));
+
+ if (!AllocateVehicles(vl, num_vehicles))
+ return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
+
+ if (flags & DC_EXEC) {
+ Vehicle *u, *w;
+ DiagDirection dir;
+
+ v = vl[0];
+ v->spritenum = rvi->image_index;
+
+ u = NULL;
+
+ FOR_ALL_VEHICLES(w) {
+ if (w->type == VEH_Train && w->tile == tile &&
+ IsFreeWagon(w) && w->engine_type == engine) {
+ u = GetLastVehicleInChain(w);
+ break;
+ }
+ }
+
+ v->engine_type = engine;
+
+ dir = GetRailDepotDirection(tile);
+
+ v->direction = DiagDirToDir(dir);
+ v->tile = tile;
+
+ x = TileX(tile) * TILE_SIZE | _vehicle_initial_x_fract[dir];
+ 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_player;
+ v->z_height = 6;
+ v->u.rail.track = 0x80;
+ v->vehstatus = VS_HIDDEN | VS_DEFPAL;
+
+ v->subtype = 0;
+ SetTrainWagon(v);
+ if (u != NULL) {
+ u->next = 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;
+// v->day_counter = 0;
+
+ v->u.rail.railtype = GetEngine(engine)->railtype;
+
+ v->build_year = _cur_year;
+ v->type = VEH_Train;
+ v->cur_image = 0xAC2;
+ v->random_bits = VehicleRandomBits();
+
+ AddArticulatedParts(vl);
+
+ _new_vehicle_id = v->index;
+
+ VehiclePositionChanged(v);
+ TrainConsistChanged(GetFirstVehicleInChain(v));
+ GetPlayer(_current_player)->num_engines[engine]++;
+
+ InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
+ if (IsLocalPlayer()) {
+ InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Train); // updates the replace Train window
+ }
+ }
+ }
+
+ return value;
+}
+
+// Move all free vehicles in the depot to the train
+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 == 0x80) {
+ if (CmdFailed(DoCommand(0, v->index | (u->index << 16), 1, DC_EXEC,
+ CMD_MOVE_RAIL_VEHICLE)))
+ break;
+ }
+ }
+}
+
+static int32 EstimateTrainCost(const RailVehicleInfo* rvi)
+{
+ return rvi->base_cost * (_price.build_railvehicle >> 3) >> 5;
+}
+
+static void AddRearEngineToMultiheadedTrain(Vehicle* v, Vehicle* u, bool building)
+{
+ 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->z_height = 6;
+ u->u.rail.track = 0x80;
+ 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->next = u;
+ u->engine_type = v->engine_type;
+ u->build_year = v->build_year;
+ if (building) v->value >>= 1;
+ u->value = v->value;
+ u->type = VEH_Train;
+ u->cur_image = 0xAC2;
+ u->random_bits = VehicleRandomBits();
+ VehiclePositionChanged(u);
+}
+
+/** Build a railroad vehicle.
+ * @param tile tile of the depot where rail-vehicle is built
+ * @param p1 engine type id
+ * @param p2 bit 0 when set, the train will get number 0, otherwise it will get a free number
+ * bit 1 prevents any free cars from being added to the train
+ */
+int32 CmdBuildRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
+ const RailVehicleInfo *rvi;
+ int value;
+ Vehicle *v;
+ UnitID unit_num;
+ Engine *e;
+ uint num_vehicles;
+
+ /* Check if the engine-type is valid (for the player) */
+ if (!IsEngineBuildable(p1, VEH_Train, _current_player)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
+
+ /* Check if the train is actually being built in a depot belonging
+ * to the player. Doesn't matter if only the cost is queried */
+ if (!(flags & DC_QUERY_COST)) {
+ if (!IsTileDepotType(tile, TRANSPORT_RAIL)) return CMD_ERROR;
+ if (!IsTileOwner(tile, _current_player)) return CMD_ERROR;
+ }
+
+ SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
+
+ rvi = RailVehInfo(p1);
+ e = GetEngine(p1);
+
+ /* 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(e->railtype, GetRailType(tile))) return CMD_ERROR;
+
+ if (rvi->flags & RVI_WAGON) return CmdBuildRailWagon(p1, tile, flags);
+
+ value = EstimateTrainCost(rvi);
+
+ num_vehicles = (rvi->flags & RVI_MULTIHEAD) ? 2 : 1;
+ num_vehicles += CountArticulatedParts(p1);
+
+ if (!(flags & DC_QUERY_COST)) {
+ Vehicle *vl[12]; // Allow for upto 10 artic parts and dual-heads
+
+ memset(&vl, 0, sizeof(vl));
+
+ if (!AllocateVehicles(vl, num_vehicles) || IsOrderPoolFull())
+ return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
+
+ v = vl[0];
+
+ unit_num = HASBIT(p2, 0) ? 0 : GetFreeUnitNumber(VEH_Train);
+ if (unit_num > _patches.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->unitnumber = unit_num;
+ v->direction = DiagDirToDir(dir);
+ v->tile = tile;
+ v->owner = _current_player;
+ v->x_pos = x;
+ v->y_pos = y;
+ v->z_pos = GetSlopeZ(x,y);
+ v->z_height = 6;
+ v->u.rail.track = 0x80;
+ 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;
+ v->last_station_visited = INVALID_STATION;
+ v->dest_tile = 0;
+
+ v->engine_type = p1;
+
+ v->reliability = e->reliability;
+ v->reliability_spd_dec = e->reliability_spd_dec;
+ v->max_age = e->lifelength * 366;
+
+ v->string_id = STR_SV_TRAIN_NAME;
+ v->u.rail.railtype = e->railtype;
+ _new_vehicle_id = v->index;
+
+ v->service_interval = _patches.servint_trains;
+ v->date_of_last_service = _date;
+ v->build_year = _cur_year;
+ v->type = VEH_Train;
+ v->cur_image = 0xAC2;
+ v->random_bits = VehicleRandomBits();
+
+ v->subtype = 0;
+ SetFrontEngine(v);
+ SetTrainEngine(v);
+
+ VehiclePositionChanged(v);
+
+ if (rvi->flags & RVI_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);
+ }
+
+ TrainConsistChanged(v);
+ UpdateTrainAcceleration(v);
+
+ if (!HASBIT(p2, 1)) { // check if the cars should be added to the new vehicle
+ NormalizeTrainVehInDepot(v);
+ }
+
+ GetPlayer(_current_player)->num_engines[p1]++;
+ InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
+ RebuildVehicleLists();
+ InvalidateWindow(WC_COMPANY, v->owner);
+ if (IsLocalPlayer()) {
+ InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Train); // updates the replace Train window
+ }
+ }
+ }
+
+ 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)
+{
+ int count;
+ TileIndex tile = v->tile;
+
+ /* check if stopped in a depot */
+ if (!IsTileDepotType(tile, TRANSPORT_RAIL) || v->cur_speed != 0) return -1;
+
+ 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) && !(!IsTrainEngine(v) && IsMultiheaded(v))) count++;
+ if (v->u.rail.track != 0x80 || 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 */
+inline 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);
+}
+
+/**
+ * Unlink a rail wagon from the consist.
+ * @param v Vehicle to remove.
+ * @param first The first vehicle of the consist.
+ * @return The first vehicle of the consist.
+ */
+static Vehicle *UnlinkWagon(Vehicle *v, Vehicle *first)
+{
+ Vehicle *u;
+
+ // unlinking the first vehicle of the chain?
+ if (v == first) {
+ v = GetNextVehicle(v);
+ if (v == NULL) return NULL;
+
+ if (IsTrainWagon(v)) SetFreeWagon(v);
+
+ return v;
+ }
+
+ for (u = first; GetNextVehicle(u) != v; u = GetNextVehicle(u)) {}
+ GetLastEnginePart(u)->next = 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) {
+ // 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, GetFirstVehicleInChain(v));
+ if (dest == NULL) return;
+
+ v->next = dest->next;
+ dest->next = v;
+ 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)
+{
+ Vehicle *u;
+
+ 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 */
+ 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);
+ }
+}
+
+/** Move a rail vehicle around inside the depot.
+ * @param tile unused
+ * @param p1 various bitstuffed elements
+ * - p1 (bit 0 - 15) source vehicle index
+ * - p1 (bit 16 - 31) what wagon to put the source wagon AFTER, XXX - INVALID_VEHICLE to make a new line
+ * @param p2 (bit 0) move all vehicles following the source vehicle
+ */
+int32 CmdMoveRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
+ VehicleID s = GB(p1, 0, 16);
+ VehicleID d = GB(p1, 16, 16);
+ Vehicle *src, *dst, *src_head, *dst_head;
+
+ if (!IsValidVehicleID(s)) return CMD_ERROR;
+
+ src = GetVehicle(s);
+
+ if (src->type != VEH_Train) return CMD_ERROR;
+
+ // if nothing is selected as destination, try and find a matching vehicle to drag to.
+ if (d == INVALID_VEHICLE) {
+ dst = IsTrainEngine(src) ? NULL : FindGoodVehiclePos(src);
+ } else {
+ dst = GetVehicle(d);
+ }
+
+ // if an articulated part is being handled, deal with its parent vehicle
+ while (IsArticulatedPart(src)) src = GetPrevVehicleInChain(src);
+ if (dst != NULL) {
+ while (IsArticulatedPart(dst)) dst = GetPrevVehicleInChain(dst);
+ }
+
+ // don't move the same vehicle..
+ if (src == dst) return 0;
+
+ /* the player must be the owner */
+ if (!CheckOwnership(src->owner) || (dst != NULL && !CheckOwnership(dst->owner)))
+ return CMD_ERROR;
+
+ /* locate the head of the two chains */
+ src_head = GetFirstVehicleInChain(src);
+ dst_head = NULL;
+ if (dst != NULL) {
+ dst_head = GetFirstVehicleInChain(dst);
+ // Now deal with articulated part of destination wagon
+ dst = GetLastEnginePart(dst);
+ }
+
+ if (dst != NULL && IsMultiheaded(dst) && !IsTrainEngine(dst) && IsTrainWagon(src)) {
+ /* We are moving a wagon to the rear part of a multiheaded engine */
+ if (dst->next == NULL) {
+ /* It's the last one, so we will add the wagon just before the rear engine */
+ dst = GetPrevVehicleInChain(dst);
+ /* Now if the vehicle we want to link to is the vehicle itself, drop out */
+ if (dst == src) return CMD_ERROR;
+ // if dst is NULL, it means that dst got a rear multiheaded engine as first engine. We can't use that
+ if (dst == NULL) return CMD_ERROR;
+ } else {
+ /* there are more units on this train, so we will add the wagon after the next one*/
+ dst = dst->next;
+ }
+ }
+
+ if (IsTrainEngine(src) && dst_head != NULL) {
+ /* we need to make sure that we didn't place it between a pair of multiheaded engines */
+ Vehicle *u, *engine = NULL;
+
+ for (u = dst_head; u != NULL; u = u->next) {
+ if (IsTrainEngine(u) && IsMultiheaded(u) && u->u.rail.other_multiheaded_part != NULL) {
+ engine = u;
+ }
+ if (engine != NULL && engine->u.rail.other_multiheaded_part == u) {
+ engine = NULL;
+ }
+ if (u == dst) {
+ if (engine != NULL) dst = engine->u.rail.other_multiheaded_part;
+ break;
+ }
+ }
+ }
+
+ if (IsMultiheaded(src) && !IsTrainEngine(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 0;
+
+ {
+ int src_len = 0;
+ int max_len = _patches.mammoth_trains ? 100 : 9;
+
+ // check if all vehicles in the source train are stopped inside a depot.
+ src_len = CheckTrainStoppedInDepot(src_head);
+ if (src_len < 0) return_cmd_error(STR_881A_TRAINS_CAN_ONLY_BE_ALTERED);
+
+ // check the destination row if the source and destination aren't the same.
+ if (src_head != dst_head) {
+ int dst_len = 0;
+
+ if (dst_head != NULL) {
+ // check if all vehicles in the dest train are stopped.
+ dst_len = CheckTrainStoppedInDepot(dst_head);
+ if (dst_len < 0) return_cmd_error(STR_881A_TRAINS_CAN_ONLY_BE_ALTERED);
+
+ assert(dst_head->tile == src_head->tile);
+ }
+
+ // We are moving between rows, so only count the wagons from the source
+ // row that are being moved.
+ if (HASBIT(p2, 0)) {
+ const Vehicle *u;
+ for (u = src_head; u != src && u != NULL; u = GetNextVehicle(u))
+ src_len--;
+ } else {
+ // If moving only one vehicle, just count that.
+ src_len = 1;
+ }
+
+ if (src_len + dst_len > max_len) {
+ // Abort if we're adding too many wagons to a train.
+ if (dst_head != NULL && IsFrontEngine(dst_head)) return_cmd_error(STR_8819_TRAIN_TOO_LONG);
+ // Abort if we're making a train on a new row.
+ if (dst_head == NULL && IsTrainEngine(src)) return_cmd_error(STR_8819_TRAIN_TOO_LONG);
+ }
+ } else {
+ // Abort if we're creating a new train on an existing row.
+ if (src_len > max_len && src == src_head && IsTrainEngine(GetNextVehicle(src_head)))
+ return_cmd_error(STR_8819_TRAIN_TOO_LONG);
+ }
+ }
+
+ // moving a loco to a new line?, then we need to assign a unitnumber.
+ if (dst == NULL && !IsFrontEngine(src) && IsTrainEngine(src)) {
+ UnitID unit_num = GetFreeUnitNumber(VEH_Train);
+ if (unit_num > _patches.max_trains)
+ return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
+
+ if (flags & DC_EXEC) src->unitnumber = unit_num;
+ }
+
+ if (dst_head != NULL) {
+ /* Check NewGRF Callback 0x1D */
+ uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, dst_head->engine_type, src, dst_head);
+ if (callback != CALLBACK_FAILED) {
+ if (callback == 0xFD) return_cmd_error(STR_INCOMPATIBLE_RAIL_TYPES);
+ if (callback < 0xFD) {
+ StringID error = GetGRFStringID(GetEngineGRFID(dst_head->engine_type), 0xD000 + callback);
+ return_cmd_error(error);
+ }
+ }
+ }
+
+ /* do it? */
+ if (flags & DC_EXEC) {
+ /* clear the ->first cache */
+ {
+ Vehicle *u;
+
+ for (u = src_head; u != NULL; u = u->next) u->first = NULL;
+ for (u = dst_head; u != NULL; u = u->next) u->first = NULL;
+ }
+
+ if (HASBIT(p2, 0)) {
+ // unlink ALL wagons
+ if (src != src_head) {
+ Vehicle *v = src_head;
+ while (GetNextVehicle(v) != src) v = GetNextVehicle(v);
+ GetLastEnginePart(v)->next = NULL;
+ } else {
+ InvalidateWindowData(WC_VEHICLE_DEPOT, src_head->tile); // We removed a line
+ src_head = NULL;
+ }
+ } else {
+ // if moving within the same chain, dont use dst_head as it may get invalidated
+ if (src_head == dst_head) dst_head = NULL;
+ // unlink single wagon from linked list
+ src_head = UnlinkWagon(src, src_head);
+ GetLastEnginePart(src)->next = NULL;
+ }
+
+ if (dst == NULL) {
+ /* We make a new line in the depot, so we know already that we invalidate the window data */
+ InvalidateWindowData(WC_VEHICLE_DEPOT, src->tile);
+
+ // move the train to an empty line. for locomotives, we set the type to TS_Front. for wagons, 4.
+ if (IsTrainEngine(src)) {
+ if (!IsFrontEngine(src)) {
+ // setting the type to 0 also involves setting up the orders field.
+ SetFrontEngine(src);
+ assert(src->orders == NULL);
+ src->num_orders = 0;
+ }
+ } else {
+ SetFreeWagon(src);
+ }
+ dst_head = src;
+ } else {
+ if (IsFrontEngine(src)) {
+ // the vehicle was previously a loco. need to free the order list and delete vehicle windows etc.
+ DeleteWindowById(WC_VEHICLE_VIEW, src->index);
+ DeleteVehicleOrders(src);
+ }
+
+ if (IsFrontEngine(src) || IsFreeWagon(src)) {
+ InvalidateWindowData(WC_VEHICLE_DEPOT, src->tile);
+ ClearFrontEngine(src);
+ ClearFreeWagon(src);
+ src->unitnumber = 0; // doesn't occupy a unitnumber anymore.
+ }
+
+ // link in the wagon(s) in the chain.
+ {
+ Vehicle *v;
+
+ for (v = src; GetNextVehicle(v) != NULL; v = GetNextVehicle(v));
+ GetLastEnginePart(v)->next = dst->next;
+ }
+ dst->next = src;
+ }
+ if (src->u.rail.other_multiheaded_part != NULL) {
+ if (src->u.rail.other_multiheaded_part == src_head) {
+ src_head = src_head->next;
+ }
+ AddWagonToConsist(src->u.rail.other_multiheaded_part, src);
+ // previous line set the front engine to the old front. We need to clear that
+ src->u.rail.other_multiheaded_part->first = NULL;
+ }
+
+ if (HASBIT(p2, 0) && src_head != NULL && src_head != src) {
+ /* if we stole a rear multiheaded engine, we better give it back to the front end */
+ Vehicle *engine = NULL, *u;
+ for (u = src_head; u != NULL; u = u->next) {
+ if (IsMultiheaded(u)) {
+ if (IsTrainEngine(u)) {
+ engine = u;
+ continue;
+ }
+ /* we got the rear engine to match with the front one */
+ engine = NULL;
+ }
+ }
+ if (engine != NULL && engine->u.rail.other_multiheaded_part != NULL) {
+ AddWagonToConsist(engine->u.rail.other_multiheaded_part, engine);
+ // previous line set the front engine to the old front. We need to clear that
+ engine->u.rail.other_multiheaded_part->first = NULL;
+ }
+ }
+
+ /* If there is an engine behind first_engine we moved away, it should become new first_engine
+ * To do this, CmdMoveRailVehicle must be called once more
+ * we can't loop forever here because next time we reach this line we will have a front engine */
+ if (src_head != NULL && !IsFrontEngine(src_head) && IsTrainEngine(src_head)) {
+ CmdMoveRailVehicle(0, flags, src_head->index | (INVALID_VEHICLE << 16), 1);
+ src_head = NULL; // don't do anything more to this train since the new call will do it
+ }
+
+ if (src_head != NULL) {
+ NormaliseTrainConsist(src_head);
+ TrainConsistChanged(src_head);
+ if (IsFrontEngine(src_head)) {
+ UpdateTrainAcceleration(src_head);
+ InvalidateWindow(WC_VEHICLE_DETAILS, src_head->index);
+ /* Update the refit button and window */
+ InvalidateWindow(WC_VEHICLE_REFIT, src_head->index);
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, src_head->index, 12);
+ }
+ /* Update the depot window */
+ InvalidateWindow(WC_VEHICLE_DEPOT, src_head->tile);
+ };
+
+ if (dst_head != NULL) {
+ NormaliseTrainConsist(dst_head);
+ TrainConsistChanged(dst_head);
+ if (IsFrontEngine(dst_head)) {
+ UpdateTrainAcceleration(dst_head);
+ InvalidateWindow(WC_VEHICLE_DETAILS, dst_head->index);
+ /* Update the refit button and window */
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, dst_head->index, 12);
+ InvalidateWindow(WC_VEHICLE_REFIT, dst_head->index);
+ }
+ /* Update the depot window */
+ InvalidateWindow(WC_VEHICLE_DEPOT, dst_head->tile);
+ }
+
+ RebuildVehicleLists();
+ }
+
+ return 0;
+}
+
+/** Start/Stop a train.
+ * @param tile unused
+ * @param p1 train to start/stop
+ * @param p2 unused
+ */
+int32 CmdStartStopTrain(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
+ Vehicle *v;
+ uint16 callback;
+
+ if (!IsValidVehicleID(p1)) return CMD_ERROR;
+
+ v = GetVehicle(p1);
+
+ if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+
+ /* Check if this train can be started/stopped. The callback will fail or
+ * return 0xFF if it can. */
+ callback = GetVehicleCallback(CBID_VEHICLE_START_STOP_CHECK, 0, 0, v->engine_type, v);
+ if (callback != CALLBACK_FAILED && callback != 0xFF) {
+ StringID error = GetGRFStringID(GetEngineGRFID(v->engine_type), 0xD000 + callback);
+ return_cmd_error(error);
+ }
+
+ if (v->vehstatus & VS_STOPPED && v->u.rail.cached_power == 0) return_cmd_error(STR_TRAIN_START_NO_CATENARY);
+
+ if (flags & DC_EXEC) {
+ if (v->vehstatus & VS_STOPPED && v->u.rail.track == 0x80) {
+ DeleteVehicleNews(p1, STR_8814_TRAIN_IS_WAITING_IN_DEPOT);
+ }
+
+ v->u.rail.days_since_order_progr = 0;
+ v->vehstatus ^= VS_STOPPED;
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+ InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
+ }
+ return 0;
+}
+
+/** Sell a (single) train wagon/engine.
+ * @param tile unused
+ * @param p1 the wagon/engine index
+ * @param p2 the selling mode
+ * - p2 = 0: only sell the single dragged wagon/engine (and any belonging rear-engines)
+ * - p2 = 1: sell the vehicle and all vehicles following it in the chain
+ if the wagon is dragged, don't delete the possibly belonging rear-engine to some front
+ * - p2 = 2: when selling attached locos, rearrange all vehicles after it to separate lines;
+ * all wagons of the same type will go on the same line. Used by the AI currently
+ */
+int32 CmdSellRailWagon(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
+ Vehicle *v, *tmp, *first;
+ Vehicle *new_f = NULL;
+ int32 cost = 0;
+
+ if (!IsValidVehicleID(p1) || p2 > 2) return CMD_ERROR;
+
+ v = GetVehicle(p1);
+
+ if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+
+ SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
+
+ while (IsArticulatedPart(v)) v = GetPrevVehicleInChain(v);
+ first = GetFirstVehicleInChain(v);
+
+ // make sure the vehicle is stopped in the depot
+ if (CheckTrainStoppedInDepot(first) < 0) {
+ return_cmd_error(STR_881A_TRAINS_CAN_ONLY_BE_ALTERED);
+ }
+
+ if (IsMultiheaded(v) && !IsTrainEngine(v)) return_cmd_error(STR_REAR_ENGINE_FOLLOW_FRONT_ERROR);
+
+ if (flags & DC_EXEC) {
+ if (v == first && IsFrontEngine(first)) {
+ DeleteWindowById(WC_VEHICLE_VIEW, first->index);
+ }
+ if (IsLocalPlayer() && (p1 == 1 || !(RailVehInfo(v->engine_type)->flags & RVI_WAGON))) {
+ InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Train);
+ }
+ InvalidateWindow(WC_VEHICLE_DEPOT, first->tile);
+ RebuildVehicleLists();
+ }
+
+ switch (p2) {
+ case 0: case 2: { /* Delete given wagon */
+ bool switch_engine = false; // update second wagon to engine?
+ byte ori_subtype = v->subtype; // backup subtype of deleted wagon in case DeleteVehicle() changes
+
+ /* 1. Delete the engine, if it is dualheaded also delete the matching
+ * rear engine of the loco (from the point of deletion onwards) */
+ Vehicle *rear = (IsMultiheaded(v) &&
+ IsTrainEngine(v)) ? v->u.rail.other_multiheaded_part : NULL;
+
+ if (rear != NULL) {
+ cost -= rear->value;
+ if (flags & DC_EXEC) {
+ UnlinkWagon(rear, first);
+ DeleteDepotHighlightOfVehicle(rear);
+ DeleteVehicle(rear);
+ }
+ }
+
+ /* 2. We are selling the first engine, some special action might be required
+ * here, so take attention */
+ if ((flags & DC_EXEC) && v == first) {
+ new_f = GetNextVehicle(first);
+
+ /* 2.1 If the first wagon is sold, update the first-> pointers to NULL */
+ for (tmp = first; tmp != NULL; tmp = tmp->next) tmp->first = NULL;
+
+ /* 2.2 If there are wagons present after the deleted front engine, check
+ * if the second wagon (which will be first) is an engine. If it is one,
+ * promote it as a new train, retaining the unitnumber, orders */
+ if (new_f != NULL) {
+ if (IsTrainEngine(new_f)) {
+ switch_engine = true;
+ /* Copy important data from the front engine */
+ new_f->unitnumber = first->unitnumber;
+ new_f->current_order = first->current_order;
+ new_f->cur_order_index = first->cur_order_index;
+ new_f->orders = first->orders;
+ if (first->prev_shared != NULL) {
+ first->prev_shared->next_shared = new_f;
+ new_f->prev_shared = first->prev_shared;
+ }
+
+ if (first->next_shared != NULL) {
+ first->next_shared->prev_shared = new_f;
+ new_f->next_shared = first->next_shared;
+ }
+
+ new_f->num_orders = first->num_orders;
+ first->orders = NULL; // XXX - to not to delete the orders */
+ if (IsLocalPlayer()) ShowTrainViewWindow(new_f);
+ }
+ }
+ }
+
+ /* 3. Delete the requested wagon */
+ cost -= v->value;
+ if (flags & DC_EXEC) {
+ first = UnlinkWagon(v, first);
+ DeleteDepotHighlightOfVehicle(v);
+ DeleteVehicle(v);
+
+ /* 4 If the second wagon was an engine, update it to front_engine
+ * which UnlinkWagon() has changed to TS_Free_Car */
+ if (switch_engine) SetFrontEngine(first);
+
+ /* 5. If the train still exists, update its acceleration, window, etc. */
+ if (first != NULL) {
+ NormaliseTrainConsist(first);
+ TrainConsistChanged(first);
+ if (IsFrontEngine(first)) {
+ InvalidateWindow(WC_VEHICLE_DETAILS, first->index);
+ InvalidateWindow(WC_VEHICLE_REFIT, first->index);
+ UpdateTrainAcceleration(first);
+ }
+ }
+
+
+ /* (6.) Borked AI. If it sells an engine it expects all wagons lined
+ * up on a new line to be added to the newly built loco. Replace it is.
+ * Totally braindead cause building a new engine adds all loco-less
+ * engines to its train anyways */
+ if (p2 == 2 && HASBIT(ori_subtype, Train_Front)) {
+ for (v = first; v != NULL; v = tmp) {
+ tmp = GetNextVehicle(v);
+ DoCommand(v->tile, v->index | INVALID_VEHICLE << 16, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
+ }
+ }
+ }
+ } break;
+ case 1: { /* Delete wagon and all wagons after it given certain criteria */
+ /* Start deleting every vehicle after the selected one
+ * If we encounter a matching rear-engine to a front-engine
+ * earlier in the chain (before deletion), leave it alone */
+ for (; v != NULL; v = tmp) {
+ tmp = GetNextVehicle(v);
+
+ if (IsMultiheaded(v)) {
+ if (IsTrainEngine(v)) {
+ /* We got a front engine of a multiheaded set. Now we will sell the rear end too */
+ Vehicle *rear = v->u.rail.other_multiheaded_part;
+
+ if (rear != NULL) {
+ cost -= rear->value;
+ if (flags & DC_EXEC) {
+ first = UnlinkWagon(rear, first);
+ DeleteDepotHighlightOfVehicle(rear);
+ DeleteVehicle(rear);
+ }
+ }
+ } else if (v->u.rail.other_multiheaded_part != NULL) {
+ /* The front to this engine is earlier in this train. Do nothing */
+ continue;
+ }
+ }
+
+ cost -= v->value;
+ if (flags & DC_EXEC) {
+ first = UnlinkWagon(v, first);
+ DeleteDepotHighlightOfVehicle(v);
+ DeleteVehicle(v);
+ }
+ }
+
+ /* 3. If it is still a valid train after selling, update its acceleration and cached values */
+ if (flags & DC_EXEC && first != NULL) {
+ NormaliseTrainConsist(first);
+ TrainConsistChanged(first);
+ if (IsFrontEngine(first)) UpdateTrainAcceleration(first);
+ InvalidateWindow(WC_VEHICLE_DETAILS, first->index);
+ InvalidateWindow(WC_VEHICLE_REFIT, first->index);
+ }
+ } break;
+ }
+ return cost;
+}
+
+static void UpdateTrainDeltaXY(Vehicle *v, Direction direction)
+{
+#define MKIT(a,b,c,d) ((a&0xFF)<<24) | ((b&0xFF)<<16) | ((c&0xFF)<<8) | ((d&0xFF)<<0)
+ static const uint32 _delta_xy_table[8] = {
+ MKIT(3, 3, -1, -1),
+ MKIT(3, 7, -1, -3),
+ MKIT(3, 3, -1, -1),
+ MKIT(7, 3, -3, -1),
+ MKIT(3, 3, -1, -1),
+ MKIT(3, 7, -1, -3),
+ MKIT(3, 3, -1, -1),
+ MKIT(7, 3, -3, -1),
+ };
+#undef MKIT
+
+ uint32 x = _delta_xy_table[direction];
+
+ v->x_offs = GB(x, 0, 8);
+ v->y_offs = GB(x, 8, 8);
+ v->sprite_width = GB(x, 16, 8);
+ v->sprite_height = GB(x, 24, 8);
+}
+
+static void UpdateVarsAfterSwap(Vehicle *v)
+{
+ UpdateTrainDeltaXY(v, v->direction);
+ v->cur_image = GetTrainImage(v, v->direction);
+ BeginVehicleMove(v);
+ VehiclePositionChanged(v);
+ EndVehicleMove(v);
+}
+
+static void SetLastSpeed(Vehicle* v, int spd)
+{
+ int old = v->u.rail.last_speed;
+ if (spd != old) {
+ v->u.rail.last_speed = spd;
+ if (_patches.vehicle_speed || (old == 0) != (spd == 0))
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+ }
+}
+
+static void SwapTrainFlags(byte *swap_flag1, byte *swap_flag2)
+{
+ byte flag1, flag2;
+
+ flag1 = *swap_flag1;
+ flag2 = *swap_flag2;
+
+ /* Clear the flags */
+ CLRBIT(*swap_flag1, VRF_GOINGUP);
+ CLRBIT(*swap_flag1, VRF_GOINGDOWN);
+ CLRBIT(*swap_flag2, VRF_GOINGUP);
+ CLRBIT(*swap_flag2, VRF_GOINGDOWN);
+
+ /* Reverse the rail-flags (if needed) */
+ if (HASBIT(flag1, VRF_GOINGUP)) {
+ SETBIT(*swap_flag2, VRF_GOINGDOWN);
+ } else if (HASBIT(flag1, VRF_GOINGDOWN)) {
+ SETBIT(*swap_flag2, VRF_GOINGUP);
+ }
+ if (HASBIT(flag2, VRF_GOINGUP)) {
+ SETBIT(*swap_flag1, VRF_GOINGDOWN);
+ } else if (HASBIT(flag2, VRF_GOINGDOWN)) {
+ SETBIT(*swap_flag1, VRF_GOINGUP);
+ }
+}
+
+static void ReverseTrainSwapVeh(Vehicle *v, int l, int r)
+{
+ Vehicle *a, *b;
+
+ /* locate vehicles to swap */
+ for (a = v; l != 0; l--) a = a->next;
+ for (b = v; r != 0; r--) b = b->next;
+
+ if (a != b) {
+ /* swap the hidden bits */
+ {
+ uint16 tmp = (a->vehstatus & ~VS_HIDDEN) | (b->vehstatus&VS_HIDDEN);
+ b->vehstatus = (b->vehstatus & ~VS_HIDDEN) | (a->vehstatus&VS_HIDDEN);
+ a->vehstatus = tmp;
+ }
+
+ /* swap variables */
+ swap_byte(&a->u.rail.track, &b->u.rail.track);
+ swap_byte(&a->direction, &b->direction);
+
+ /* toggle direction */
+ if (!(a->u.rail.track & 0x80)) a->direction = ReverseDir(a->direction);
+ if (!(b->u.rail.track & 0x80)) b->direction = ReverseDir(b->direction);
+
+ /* swap more variables */
+ swap_int32(&a->x_pos, &b->x_pos);
+ swap_int32(&a->y_pos, &b->y_pos);
+ swap_tile(&a->tile, &b->tile);
+ swap_byte(&a->z_pos, &b->z_pos);
+
+ SwapTrainFlags(&a->u.rail.flags, &b->u.rail.flags);
+
+ /* update other vars */
+ UpdateVarsAfterSwap(a);
+ UpdateVarsAfterSwap(b);
+
+ /* call the proper EnterTile function unless we are in a wormhole */
+ if (!(a->u.rail.track & 0x40)) VehicleEnterTile(a, a->tile, a->x_pos, a->y_pos);
+ if (!(b->u.rail.track & 0x40)) VehicleEnterTile(b, b->tile, b->x_pos, b->y_pos);
+ } else {
+ if (!(a->u.rail.track & 0x80)) a->direction = ReverseDir(a->direction);
+ UpdateVarsAfterSwap(a);
+
+ if (!(a->u.rail.track & 0x40)) VehicleEnterTile(a, a->tile, a->x_pos, a->y_pos);
+ }
+
+ /* Update train's power incase tiles were different rail type */
+ TrainPowerChanged(v);
+}
+
+/* Check if the vehicle is a train and is on the tile we are testing */
+static void *TestTrainOnCrossing(Vehicle *v, void *data)
+{
+ if (v->tile != *(const TileIndex*)data || v->type != VEH_Train) return NULL;
+ return v;
+}
+
+static void DisableTrainCrossing(TileIndex tile)
+{
+ if (IsLevelCrossingTile(tile) &&
+ VehicleFromPos(tile, &tile, TestTrainOnCrossing) == NULL && // empty?
+ IsCrossingBarred(tile)) {
+ UnbarCrossing(tile);
+ MarkTileDirtyByTile(tile);
+ }
+}
+
+/**
+ * Advances wagons for train reversing, needed for variable length wagons.
+ * Needs to be called once before the train is reversed, and once after it.
+ * @param v First vehicle in chain
+ * @param before Set to true for the call before reversing, false otherwise
+ */
+static void AdvanceWagons(Vehicle *v, bool before)
+{
+ Vehicle* base;
+ Vehicle* first;
+ int length;
+
+ base = v;
+ first = base->next;
+ length = CountVehiclesInChain(v);
+
+ while (length > 2) {
+ Vehicle* last;
+ int differential;
+ int i;
+
+ // find pairwise matching wagon
+ // start<>end, start+1<>end-1, ...
+ last = first;
+ for (i = length - 3; i > 0; i--) last = last->next;
+
+ differential = last->u.rail.cached_veh_length - base->u.rail.cached_veh_length;
+ if (before) differential *= -1;
+
+ if (differential > 0) {
+ Vehicle* tempnext;
+
+ // disconnect last car to make sure only this subset moves
+ tempnext = last->next;
+ last->next = NULL;
+
+ for (i = 0; i < differential; i++) TrainController(first, false);
+
+ last->next = tempnext;
+ }
+
+ base = first;
+ first = first->next;
+ length -= 2;
+ }
+}
+
+
+static void ReverseTrainDirection(Vehicle *v)
+{
+ int l = 0, r = -1;
+ Vehicle *u;
+
+ if (IsTileDepotType(v->tile, TRANSPORT_RAIL)) {
+ InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
+ }
+
+ /* Check if we were approaching a rail/road-crossing */
+ {
+ TileIndex tile = v->tile;
+ DiagDirection dir = DirToDiagDir(v->direction);
+
+ /* Determine the diagonal direction in which we will exit this tile */
+ if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[dir]) {
+ dir = ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT);
+ }
+ /* Calculate next tile */
+ tile += TileOffsByDiagDir(dir);
+
+ /* Check if the train left a rail/road-crossing */
+ DisableTrainCrossing(tile);
+ }
+
+ // count number of vehicles
+ u = v;
+ do r++; while ( (u = u->next) != NULL );
+
+ AdvanceWagons(v, true);
+
+ /* swap start<>end, start+1<>end-1, ... */
+ do {
+ ReverseTrainSwapVeh(v, l++, r--);
+ } while (l <= r);
+
+ AdvanceWagons(v, false);
+
+ if (IsTileDepotType(v->tile, TRANSPORT_RAIL)) {
+ InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
+ }
+
+ CLRBIT(v->u.rail.flags, VRF_REVERSING);
+}
+
+/** Reverse train.
+ * @param tile unused
+ * @param p1 train to reverse
+ * @param p2 if true, reverse a unit in a train (needs to be in a depot)
+ */
+int32 CmdReverseTrainDirection(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
+ Vehicle *v;
+
+ if (!IsValidVehicleID(p1)) return CMD_ERROR;
+
+ v = GetVehicle(p1);
+
+ if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+
+ if (p2) {
+ // turn a single unit around
+ Vehicle *front;
+
+ if (IsMultiheaded(v) || HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_ARTIC_ENGINE)) {
+ return_cmd_error(STR_ONLY_TURN_SINGLE_UNIT);
+ }
+
+ front = GetFirstVehicleInChain(v);
+ // make sure the vehicle is stopped in the depot
+ if (CheckTrainStoppedInDepot(front) < 0) {
+ return_cmd_error(STR_881A_TRAINS_CAN_ONLY_BE_ALTERED);
+ }
+
+ if (flags & DC_EXEC) {
+ TOGGLEBIT(v->u.rail.flags, VRF_REVERSE_DIRECTION);
+ InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
+ InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+ }
+ } else {
+ //turn the whole train around
+ if (v->u.rail.crash_anim_pos != 0 || v->breakdown_ctr != 0) return CMD_ERROR;
+
+ if (flags & DC_EXEC) {
+ if (_patches.realistic_acceleration && v->cur_speed != 0) {
+ TOGGLEBIT(v->u.rail.flags, VRF_REVERSING);
+ } else {
+ v->cur_speed = 0;
+ SetLastSpeed(v, 0);
+ ReverseTrainDirection(v);
+ }
+ }
+ }
+ return 0;
+}
+
+/** Force a train through a red signal
+ * @param tile unused
+ * @param p1 train to ignore the red signal
+ * @param p2 unused
+ */
+int32 CmdForceTrainProceed(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
+ Vehicle *v;
+
+ if (!IsValidVehicleID(p1)) return CMD_ERROR;
+
+ v = GetVehicle(p1);
+
+ if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+
+ if (flags & DC_EXEC) v->u.rail.force_proceed = 0x50;
+
+ return 0;
+}
+
+/** Refits a train to the specified cargo type.
+ * @param tile unused
+ * @param p1 vehicle ID of the train to refit
+ * param p2 various bitstuffed elements
+ * - p2 = (bit 0-7) - the new cargo type to refit to
+ * - p2 = (bit 8-15) - the new cargo subtype to refit to
+ */
+int32 CmdRefitRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
+ CargoID new_cid = GB(p2, 0, 8);
+ byte new_subtype = GB(p2, 8, 8);
+ Vehicle *v;
+ int32 cost;
+ uint num;
+
+ if (!IsValidVehicleID(p1)) return CMD_ERROR;
+
+ v = GetVehicle(p1);
+
+ if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+ if (CheckTrainStoppedInDepot(v) < 0) return_cmd_error(STR_TRAIN_MUST_BE_STOPPED);
+
+ /* Check cargo */
+ if (new_cid > NUM_CARGO) return CMD_ERROR;
+
+ SET_EXPENSES_TYPE(EXPENSES_TRAIN_RUN);
+
+ cost = 0;
+ num = 0;
+
+ do {
+ /* XXX: We also refit all the attached wagons en-masse if they
+ * can be refitted. This is how TTDPatch does it. TODO: Have
+ * some nice [Refit] button near each wagon. --pasky */
+ if (!CanRefitTo(v->engine_type, new_cid)) continue;
+
+ if (v->cargo_cap != 0) {
+ const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
+ uint16 amount = CALLBACK_FAILED;
+
+ if (HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_REFIT_CAPACITY)) {
+ /* Back up the vehicle's cargo type */
+ CargoID temp_cid = v->cargo_type;
+ byte temp_subtype = v->cargo_subtype;
+ v->cargo_type = new_cid;
+ v->cargo_subtype = new_subtype;
+ /* Check the refit capacity callback */
+ amount = GetVehicleCallback(CBID_VEHICLE_REFIT_CAPACITY, 0, 0, v->engine_type, v);
+ /* Restore the original cargo type */
+ v->cargo_type = temp_cid;
+ v->cargo_subtype = temp_subtype;
+ }
+
+ if (amount == CALLBACK_FAILED) { // callback failed or not used, use default
+ CargoID old_cid = rvi->cargo_type;
+ /* normally, the capacity depends on the cargo type, a rail vehicle can
+ * carry twice as much mail/goods as normal cargo, and four times as
+ * many passengers
+ */
+ amount = rvi->capacity;
+ switch (old_cid) {
+ case CT_PASSENGERS: break;
+ case CT_MAIL:
+ case CT_GOODS: amount *= 2; break;
+ default: amount *= 4; break;
+ }
+ switch (new_cid) {
+ case CT_PASSENGERS: break;
+ case CT_MAIL:
+ case CT_GOODS: amount /= 2; break;
+ default: amount /= 4; break;
+ }
+ };
+
+ if (amount != 0) {
+ if (new_cid != v->cargo_type) {
+ cost += GetRefitCost(v->engine_type);
+ }
+
+ num += amount;
+ if (flags & DC_EXEC) {
+ v->cargo_count = (v->cargo_type == new_cid) ? min(amount, v->cargo_count) : 0;
+ v->cargo_type = new_cid;
+ v->cargo_cap = amount;
+ v->cargo_subtype = new_subtype;
+ InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+ InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
+ RebuildVehicleLists();
+ }
+ }
+ }
+ } while ((v = v->next) != NULL);
+
+ _returned_refit_capacity = num;
+
+ /* Update the train's cached variables */
+ if (flags & DC_EXEC) TrainConsistChanged(GetFirstVehicleInChain(GetVehicle(p1)));
+
+ return cost;
+}
+
+typedef struct TrainFindDepotData {
+ uint best_length;
+ TileIndex tile;
+ PlayerID owner;
+ /**
+ * true if reversing is necessary for the train to get to this depot
+ * This value is unused when new depot finding and NPF are both disabled
+ */
+ bool reverse;
+} TrainFindDepotData;
+
+static bool NtpCallbFindDepot(TileIndex tile, TrainFindDepotData *tfdd, int track, uint length)
+{
+ if (IsTileType(tile, MP_RAILWAY) &&
+ IsTileOwner(tile, tfdd->owner) &&
+ IsRailDepot(tile)) {
+ /* approximate number of tiles by dividing by DIAG_FACTOR */
+ tfdd->best_length = length / DIAG_FACTOR;
+ tfdd->tile = tile;
+ return true;
+ }
+
+ return false;
+}
+
+// returns the tile of a depot to goto to. The given vehicle must not be
+// crashed!
+static TrainFindDepotData FindClosestTrainDepot(Vehicle *v, int max_distance)
+{
+ TrainFindDepotData tfdd;
+ TileIndex tile = v->tile;
+
+ assert(!(v->vehstatus & VS_CRASHED));
+
+ tfdd.owner = v->owner;
+ tfdd.best_length = (uint)-1;
+ tfdd.reverse = false;
+
+ if (IsTileDepotType(tile, TRANSPORT_RAIL)){
+ tfdd.tile = tile;
+ tfdd.best_length = 0;
+ return tfdd;
+ }
+
+ if (_patches.yapf.rail_use_yapf) {
+ bool found = YapfFindNearestRailDepotTwoWay(v, max_distance, NPF_INFINITE_PENALTY, &tfdd.tile, &tfdd.reverse);
+ tfdd.best_length = found ? max_distance / 2 : -1; // some fake distance or NOT_FOUND
+ } else if (_patches.new_pathfinding_all) {
+ NPFFoundTargetData ftd;
+ Vehicle* last = GetLastVehicleInChain(v);
+ Trackdir trackdir = GetVehicleTrackdir(v);
+ Trackdir trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
+
+ assert (trackdir != INVALID_TRACKDIR);
+ ftd = NPFRouteToDepotBreadthFirstTwoWay(v->tile, trackdir, last->tile, trackdir_rev, TRANSPORT_RAIL, v->owner, v->u.rail.compatible_railtypes, NPF_INFINITE_PENALTY);
+ if (ftd.best_bird_dist == 0) {
+ /* Found target */
+ tfdd.tile = ftd.node.tile;
+ /* Our caller expects a number of tiles, so we just approximate that
+ * number by this. It might not be completely what we want, but it will
+ * work for now :-) We can possibly change this when the old pathfinder
+ * is removed. */
+ tfdd.best_length = ftd.best_path_dist / NPF_TILE_LENGTH;
+ if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) tfdd.reverse = true;
+ }
+ } else {
+ // search in the forward direction first.
+ DiagDirection i;
+
+ i = DirToDiagDir(v->direction);
+ if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[i]) {
+ i = ChangeDiagDir(i, DIAGDIRDIFF_90LEFT);
+ }
+ NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
+ if (tfdd.best_length == (uint)-1){
+ tfdd.reverse = true;
+ // search in backwards direction
+ i = ReverseDiagDir(DirToDiagDir(v->direction));
+ if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[i]) {
+ i = ChangeDiagDir(i, DIAGDIRDIFF_90LEFT);
+ }
+ NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
+ }
+ }
+
+ return tfdd;
+}
+
+/** Send a train to a depot
+ * @param tile unused
+ * @param p1 train to send to the depot
+ * @param p2 various bitmasked elements
+ * - p2 bit 0-3 - DEPOT_ flags (see vehicle.h)
+ * - p2 bit 8-10 - VLW flag (for mass goto depot)
+ */
+int32 CmdSendTrainToDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
+ Vehicle *v;
+ TrainFindDepotData tfdd;
+
+ if (p2 & DEPOT_MASS_SEND) {
+ /* Mass goto depot requested */
+ if (!ValidVLWFlags(p2 & VLW_MASK)) return CMD_ERROR;
+ return SendAllVehiclesToDepot(VEH_Train, flags, p2 & DEPOT_SERVICE, _current_player, (p2 & VLW_MASK), p1);
+ }
+
+ if (!IsValidVehicleID(p1)) return CMD_ERROR;
+
+ v = GetVehicle(p1);
+
+ if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+
+ if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
+
+ if (v->current_order.type == OT_GOTO_DEPOT) {
+ if (!!(p2 & DEPOT_SERVICE) == HASBIT(v->current_order.flags, OFB_HALT_IN_DEPOT)) {
+ /* We called with a different DEPOT_SERVICE setting.
+ * Now we change the setting to apply the new one and let the vehicle head for the same depot.
+ * Note: the if is (true for requesting service == true for ordered to stop in depot) */
+ if (flags & DC_EXEC) {
+ TOGGLEBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+ }
+ return 0;
+ }
+
+ if (p2 & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of depot orders
+ if (flags & DC_EXEC) {
+ if (HASBIT(v->current_order.flags, OFB_PART_OF_ORDERS)) {
+ v->u.rail.days_since_order_progr = 0;
+ v->cur_order_index++;
+ }
+
+ v->current_order.type = OT_DUMMY;
+ v->current_order.flags = 0;
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+ }
+ return 0;
+ }
+
+ /* check if at a standstill (not stopped only) in a depot
+ * the check is down here to make it possible to alter stop/service for trains entering the depot */
+ if (IsTileDepotType(v->tile, TRANSPORT_RAIL) && v->cur_speed == 0) return CMD_ERROR;
+
+ tfdd = FindClosestTrainDepot(v, 0);
+ if (tfdd.best_length == (uint)-1) return_cmd_error(STR_883A_UNABLE_TO_FIND_ROUTE_TO);
+
+ if (flags & DC_EXEC) {
+ v->dest_tile = tfdd.tile;
+ v->current_order.type = OT_GOTO_DEPOT;
+ v->current_order.flags = OF_NON_STOP;
+ if (!(p2 & DEPOT_SERVICE)) SETBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
+ v->current_order.dest = GetDepotByTile(tfdd.tile)->index;
+ v->current_order.refit_cargo = CT_INVALID;
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+ /* If there is no depot in front, reverse automatically */
+ if (tfdd.reverse)
+ DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);
+ }
+
+ return 0;
+}
+
+
+void OnTick_Train(void)
+{
+ _age_cargo_skip_counter = (_age_cargo_skip_counter == 0) ? 184 : (_age_cargo_skip_counter - 1);
+}
+
+static const int8 _vehicle_smoke_pos[8] = {
+ 1, 1, 1, 0, -1, -1, -1, 0
+};
+
+static void HandleLocomotiveSmokeCloud(const Vehicle* v)
+{
+ const Vehicle* u;
+ bool sound = false;
+
+ if (v->vehstatus & VS_TRAIN_SLOWING || v->load_unload_time_rem != 0 || v->cur_speed < 2)
+ return;
+
+ u = v;
+
+ do {
+ EngineID engtype = v->engine_type;
+ int effect_offset = GB(v->u.rail.cached_vis_effect, 0, 4) - 8;
+ byte effect_type = GB(v->u.rail.cached_vis_effect, 4, 2);
+ bool disable_effect = HASBIT(v->u.rail.cached_vis_effect, 6);
+ int x, y;
+
+ // no smoke?
+ if ((RailVehInfo(engtype)->flags & RVI_WAGON && effect_type == 0) ||
+ disable_effect ||
+ GetEngine(engtype)->railtype > RAILTYPE_ELECTRIC ||
+ v->vehstatus & VS_HIDDEN) {
+ continue;
+ }
+
+ // No smoke in depots or tunnels
+ if (IsTileDepotType(v->tile, TRANSPORT_RAIL) || IsTunnelTile(v->tile)) continue;
+
+ // No sparks for electric vehicles on nonelectrified tracks
+ if (!HasPowerOnRail(v->u.rail.railtype, GetTileRailType(v->tile, GetVehicleTrackdir(v)))) continue;
+
+ if (effect_type == 0) {
+ // Use default effect type for engine class.
+ effect_type = RailVehInfo(engtype)->engclass;
+ } else {
+ effect_type--;
+ }
+
+ x = _vehicle_smoke_pos[v->direction] * effect_offset;
+ y = _vehicle_smoke_pos[(v->direction + 2) % 8] * effect_offset;
+
+ if (HASBIT(v->u.rail.flags, VRF_REVERSE_DIRECTION)) {
+ x = -x;
+ y = -y;
+ }
+
+ switch (effect_type) {
+ case 0:
+ // steam smoke.
+ if (GB(v->tick_counter, 0, 4) == 0) {
+ CreateEffectVehicleRel(v, x, y, 10, EV_STEAM_SMOKE);
+ sound = true;
+ }
+ break;
+
+ case 1:
+ // diesel smoke
+ if (u->cur_speed <= 40 && CHANCE16(15, 128)) {
+ CreateEffectVehicleRel(v, 0, 0, 10, EV_DIESEL_SMOKE);
+ sound = true;
+ }
+ break;
+
+ case 2:
+ // blue spark
+ if (GB(v->tick_counter, 0, 2) == 0 && CHANCE16(1, 45)) {
+ CreateEffectVehicleRel(v, 0, 0, 10, EV_ELECTRIC_SPARK);
+ sound = true;
+ }
+ break;
+ }
+ } while ((v = v->next) != NULL);
+
+ if (sound) PlayVehicleSound(u, VSE_TRAIN_EFFECT);
+}
+
+static void TrainPlayLeaveStationSound(const Vehicle* v)
+{
+ static const SoundFx sfx[] = {
+ SND_04_TRAIN,
+ SND_0A_TRAIN_HORN,
+ SND_0A_TRAIN_HORN
+ };
+
+ EngineID engtype = v->engine_type;
+
+ if (PlayVehicleSound(v, VSE_START)) return;
+
+ switch (GetEngine(engtype)->railtype) {
+ case RAILTYPE_RAIL:
+ case RAILTYPE_ELECTRIC:
+ SndPlayVehicleFx(sfx[RailVehInfo(engtype)->engclass], v);
+ break;
+
+ case RAILTYPE_MONO: SndPlayVehicleFx(SND_47_MAGLEV_2, v); break;
+ case RAILTYPE_MAGLEV: SndPlayVehicleFx(SND_41_MAGLEV, v); break;
+ }
+}
+
+static bool CheckTrainStayInDepot(Vehicle *v)
+{
+ Vehicle *u;
+
+ // bail out if not all wagons are in the same depot or not in a depot at all
+ for (u = v; u != NULL; u = u->next) {
+ if (u->u.rail.track != 0x80 || u->tile != v->tile) return false;
+ }
+
+ // if the train got no power, then keep it in the depot
+ if (v->u.rail.cached_power == 0) {
+ v->vehstatus |= VS_STOPPED;
+ InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
+ return true;
+ }
+
+ if (v->u.rail.force_proceed == 0) {
+ if (++v->load_unload_time_rem < 37) {
+ InvalidateWindowClasses(WC_TRAINS_LIST);
+ return true;
+ }
+
+ v->load_unload_time_rem = 0;
+
+ if (UpdateSignalsOnSegment(v->tile, DirToDiagDir(v->direction))) {
+ InvalidateWindowClasses(WC_TRAINS_LIST);
+ return true;
+ }
+ }
+
+ VehicleServiceInDepot(v);
+ InvalidateWindowClasses(WC_TRAINS_LIST);
+ TrainPlayLeaveStationSound(v);
+
+ v->u.rail.track = 1;
+ if (v->direction & 2) v->u.rail.track = 2;
+
+ v->vehstatus &= ~VS_HIDDEN;
+ v->cur_speed = 0;
+
+ UpdateTrainDeltaXY(v, v->direction);
+ v->cur_image = GetTrainImage(v, v->direction);
+ VehiclePositionChanged(v);
+ UpdateSignalsOnSegment(v->tile, DirToDiagDir(v->direction));
+ UpdateTrainAcceleration(v);
+ InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
+
+ return false;
+}
+
+/* Check for station tiles */
+typedef struct TrainTrackFollowerData {
+ TileIndex dest_coords;
+ StationID station_index; // station index we're heading for
+ uint best_bird_dist;
+ uint best_track_dist;
+ byte best_track;
+} TrainTrackFollowerData;
+
+static bool NtpCallbFindStation(TileIndex tile, TrainTrackFollowerData *ttfd, int track, uint length)
+{
+ // heading for nowhere?
+ if (ttfd->dest_coords == 0) return false;
+
+ // did we reach the final station?
+ if ((ttfd->station_index == INVALID_STATION && tile == ttfd->dest_coords) || (
+ IsTileType(tile, MP_STATION) &&
+ IsRailwayStation(tile) &&
+ GetStationIndex(tile) == ttfd->station_index
+ )) {
+ /* We do not check for dest_coords if we have a station_index,
+ * because in that case the dest_coords are just an
+ * approximation of where the station is */
+ // found station
+ ttfd->best_track = track;
+ return true;
+ } else {
+ uint dist;
+
+ // didn't find station, keep track of the best path so far.
+ dist = DistanceManhattan(tile, ttfd->dest_coords);
+ if (dist < ttfd->best_bird_dist) {
+ ttfd->best_bird_dist = dist;
+ ttfd->best_track = track;
+ }
+ return false;
+ }
+}
+
+static void FillWithStationData(TrainTrackFollowerData* fd, const Vehicle* v)
+{
+ fd->dest_coords = v->dest_tile;
+ if (v->current_order.type == OT_GOTO_STATION) {
+ fd->station_index = v->current_order.dest;
+ } else {
+ fd->station_index = INVALID_STATION;
+ }
+}
+
+static const byte _initial_tile_subcoord[6][4][3] = {
+{{ 15, 8, 1 }, { 0, 0, 0 }, { 0, 8, 5 }, { 0, 0, 0 }},
+{{ 0, 0, 0 }, { 8, 0, 3 }, { 0, 0, 0 }, { 8, 15, 7 }},
+{{ 0, 0, 0 }, { 7, 0, 2 }, { 0, 7, 6 }, { 0, 0, 0 }},
+{{ 15, 8, 2 }, { 0, 0, 0 }, { 0, 0, 0 }, { 8, 15, 6 }},
+{{ 15, 7, 0 }, { 8, 0, 4 }, { 0, 0, 0 }, { 0, 0, 0 }},
+{{ 0, 0, 0 }, { 0, 0, 0 }, { 0, 8, 4 }, { 7, 15, 0 }},
+};
+
+static const uint32 _reachable_tracks[4] = {
+ 0x10091009,
+ 0x00160016,
+ 0x05200520,
+ 0x2A002A00,
+};
+
+static const byte _search_directions[6][4] = {
+ { 0, 9, 2, 9 }, // track 1
+ { 9, 1, 9, 3 }, // track 2
+ { 9, 0, 3, 9 }, // track upper
+ { 1, 9, 9, 2 }, // track lower
+ { 3, 2, 9, 9 }, // track left
+ { 9, 9, 1, 0 }, // track right
+};
+
+static const byte _pick_track_table[6] = {1, 3, 2, 2, 0, 0};
+
+/* choose a track */
+static byte ChooseTrainTrack(Vehicle* v, TileIndex tile, DiagDirection enterdir, TrackdirBits trackdirbits)
+{
+ TrainTrackFollowerData fd;
+ uint best_track;
+ // pathfinders are able to tell that route was only 'guessed'
+ bool path_not_found = false;
+
+#ifdef PF_BENCHMARK
+ TIC()
+#endif
+
+ assert((trackdirbits & ~0x3F) == 0);
+
+ /* quick return in case only one possible track is available */
+ if (KILL_FIRST_BIT(trackdirbits) == 0) return FIND_FIRST_BIT(trackdirbits);
+
+ if (_patches.yapf.rail_use_yapf) {
+ Trackdir trackdir = YapfChooseRailTrack(v, tile, enterdir, trackdirbits, &path_not_found);
+ if (trackdir != INVALID_TRACKDIR) {
+ best_track = TrackdirToTrack(trackdir);
+ } else {
+ best_track = FIND_FIRST_BIT(TrackdirBitsToTrackBits(trackdirbits));
+ }
+ } else if (_patches.new_pathfinding_all) { /* Use a new pathfinding for everything */
+ void* perf = NpfBeginInterval();
+ int time = 0;
+
+ NPFFindStationOrTileData fstd;
+ NPFFoundTargetData ftd;
+ Trackdir trackdir;
+
+ NPFFillWithOrderData(&fstd, v);
+ /* The enterdir for the new tile, is the exitdir for the old tile */
+ trackdir = GetVehicleTrackdir(v);
+ assert(trackdir != 0xff);
+
+ ftd = NPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.compatible_railtypes);
+
+ if (ftd.best_trackdir == 0xff) {
+ /* We are already at our target. Just do something */
+ //TODO: maybe display error?
+ //TODO: go straight ahead if possible?
+ best_track = FIND_FIRST_BIT(trackdirbits);
+ } else {
+ /* If ftd.best_bird_dist is 0, we found our target and ftd.best_trackdir contains
+ the direction we need to take to get there, if ftd.best_bird_dist is not 0,
+ we did not find our target, but ftd.best_trackdir contains the direction leading
+ to the tile closest to our target. */
+ if (ftd.best_bird_dist != 0) path_not_found = true;
+ /* Discard enterdir information, making it a normal track */
+ best_track = TrackdirToTrack(ftd.best_trackdir);
+ }
+
+ time = NpfEndInterval(perf);
+ DEBUG(yapf, 4, "[NPFT] %d us - %d rounds - %d open - %d closed -- ", time, 0, _aystar_stats_open_size, _aystar_stats_closed_size);
+ } else {
+ void* perf = NpfBeginInterval();
+ int time = 0;
+
+ FillWithStationData(&fd, v);
+
+ /* New train pathfinding */
+ fd.best_bird_dist = (uint)-1;
+ fd.best_track_dist = (uint)-1;
+ fd.best_track = 0xFF;
+
+ NewTrainPathfind(tile - TileOffsByDiagDir(enterdir), v->dest_tile,
+ v->u.rail.compatible_railtypes, enterdir, (NTPEnumProc*)NtpCallbFindStation, &fd);
+
+ // check whether the path was found or only 'guessed'
+ if (fd.best_bird_dist != 0) path_not_found = true;
+
+ if (fd.best_track == 0xff) {
+ // blaha
+ best_track = FIND_FIRST_BIT(trackdirbits);
+ } else {
+ best_track = fd.best_track & 7;
+ }
+
+ time = NpfEndInterval(perf);
+ DEBUG(yapf, 4, "[NTPT] %d us - %d rounds - %d open - %d closed -- ", time, 0, 0, 0);
+ }
+ // handle "path not found" state
+ if (path_not_found) {
+ // PF didn't find the route
+ if (!HASBIT(v->u.rail.flags, VRF_NO_PATH_TO_DESTINATION)) {
+ // it is first time the problem occurred, set the "path not found" flag
+ SETBIT(v->u.rail.flags, VRF_NO_PATH_TO_DESTINATION);
+ // and notify user about the event
+ if (_patches.lost_train_warn && v->owner == _local_player) {
+ SetDParam(0, v->unitnumber);
+ AddNewsItem(
+ STR_TRAIN_IS_LOST,
+ NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0),
+ v->index,
+ 0);
+ }
+ }
+ } else {
+ // route found, is the train marked with "path not found" flag?
+ if (HASBIT(v->u.rail.flags, VRF_NO_PATH_TO_DESTINATION)) {
+ // clear the flag as the PF's problem was solved
+ CLRBIT(v->u.rail.flags, VRF_NO_PATH_TO_DESTINATION);
+ // can we also delete the "News" item somehow?
+ }
+ }
+
+#ifdef PF_BENCHMARK
+ TOC("PF time = ", 1)
+#endif
+
+ return best_track;
+}
+
+
+static bool CheckReverseTrain(Vehicle *v)
+{
+ TrainTrackFollowerData fd;
+ int i, r;
+ int best_track;
+ uint best_bird_dist = 0;
+ uint best_track_dist = 0;
+ uint reverse, reverse_best;
+
+ if (_opt.diff.line_reverse_mode != 0 ||
+ v->u.rail.track & 0xC0 ||
+ !(v->direction & 1))
+ return false;
+
+ FillWithStationData(&fd, v);
+
+ best_track = -1;
+ reverse_best = reverse = 0;
+
+ assert(v->u.rail.track);
+
+ i = _search_directions[FIND_FIRST_BIT(v->u.rail.track)][DirToDiagDir(v->direction)];
+
+ if (_patches.yapf.rail_use_yapf) {
+ reverse_best = YapfCheckReverseTrain(v);
+ } else if (_patches.new_pathfinding_all) { /* Use a new pathfinding for everything */
+ NPFFindStationOrTileData fstd;
+ NPFFoundTargetData ftd;
+ byte trackdir, trackdir_rev;
+ Vehicle* last = GetLastVehicleInChain(v);
+
+ NPFFillWithOrderData(&fstd, v);
+
+ trackdir = GetVehicleTrackdir(v);
+ trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
+ assert(trackdir != 0xff);
+ assert(trackdir_rev != 0xff);
+
+ ftd = NPFRouteToStationOrTileTwoWay(v->tile, trackdir, last->tile, trackdir_rev, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.compatible_railtypes);
+ if (ftd.best_bird_dist != 0) {
+ /* We didn't find anything, just keep on going straight ahead */
+ reverse_best = false;
+ } else {
+ if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) {
+ reverse_best = true;
+ } else {
+ reverse_best = false;
+ }
+ }
+ } else {
+ for (;;) {
+ fd.best_bird_dist = (uint)-1;
+ fd.best_track_dist = (uint)-1;
+
+ NewTrainPathfind(v->tile, v->dest_tile, v->u.rail.compatible_railtypes, reverse ^ i, (NTPEnumProc*)NtpCallbFindStation, &fd);
+
+ if (best_track != -1) {
+ if (best_bird_dist != 0) {
+ if (fd.best_bird_dist != 0) {
+ /* neither reached the destination, pick the one with the smallest bird dist */
+ if (fd.best_bird_dist > best_bird_dist) goto bad;
+ if (fd.best_bird_dist < best_bird_dist) goto good;
+ } else {
+ /* we found the destination for the first time */
+ goto good;
+ }
+ } else {
+ if (fd.best_bird_dist != 0) {
+ /* didn't find destination, but we've found the destination previously */
+ goto bad;
+ } else {
+ /* both old & new reached the destination, compare track length */
+ if (fd.best_track_dist > best_track_dist) goto bad;
+ if (fd.best_track_dist < best_track_dist) goto good;
+ }
+ }
+
+ /* if we reach this position, there's two paths of equal value so far.
+ * pick one randomly. */
+ r = GB(Random(), 0, 8);
+ if (_pick_track_table[i] == (v->direction & 3)) r += 80;
+ if (_pick_track_table[best_track] == (v->direction & 3)) r -= 80;
+ if (r <= 127) goto bad;
+ }
+good:;
+ best_track = i;
+ best_bird_dist = fd.best_bird_dist;
+ best_track_dist = fd.best_track_dist;
+ reverse_best = reverse;
+bad:;
+ if (reverse != 0) break;
+ reverse = 2;
+ }
+ }
+
+ return reverse_best != 0;
+}
+
+static bool ProcessTrainOrder(Vehicle *v)
+{
+ const Order *order;
+ bool at_waypoint = false;
+
+ switch (v->current_order.type) {
+ case OT_GOTO_DEPOT:
+ if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return false;
+ if ((v->current_order.flags & OF_SERVICE_IF_NEEDED) &&
+ !VehicleNeedsService(v)) {
+ v->cur_order_index++;
+ }
+ break;
+
+ case OT_LOADING:
+ case OT_LEAVESTATION:
+ return false;
+
+ default: break;
+ }
+
+ // check if we've reached the waypoint?
+ if (v->current_order.type == OT_GOTO_WAYPOINT && v->tile == v->dest_tile) {
+ v->cur_order_index++;
+ at_waypoint = true;
+ }
+
+ // check if we've reached a non-stop station while TTDPatch nonstop is enabled..
+ if (_patches.new_nonstop &&
+ v->current_order.flags & OF_NON_STOP &&
+ IsTileType(v->tile, MP_STATION) &&
+ v->current_order.dest == GetStationIndex(v->tile)) {
+ v->cur_order_index++;
+ }
+
+ // Get the current order
+ if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
+
+ order = GetVehicleOrder(v, v->cur_order_index);
+
+ // If no order, do nothing.
+ if (order == NULL) {
+ v->current_order.type = OT_NOTHING;
+ v->current_order.flags = 0;
+ v->dest_tile = 0;
+ return false;
+ }
+
+ // If it is unchanged, keep it.
+ if (order->type == v->current_order.type &&
+ order->flags == v->current_order.flags &&
+ order->dest == v->current_order.dest)
+ return false;
+
+ // Otherwise set it, and determine the destination tile.
+ v->current_order = *order;
+
+ v->dest_tile = 0;
+
+ InvalidateVehicleOrder(v);
+
+ switch (order->type) {
+ case OT_GOTO_STATION:
+ if (order->dest == v->last_station_visited)
+ v->last_station_visited = INVALID_STATION;
+ v->dest_tile = GetStation(order->dest)->xy;
+ break;
+
+ case OT_GOTO_DEPOT:
+ v->dest_tile = GetDepot(order->dest)->xy;
+ break;
+
+ case OT_GOTO_WAYPOINT:
+ v->dest_tile = GetWaypoint(order->dest)->xy;
+ break;
+
+ default:
+ return false;
+ }
+
+ return !at_waypoint && CheckReverseTrain(v);
+}
+
+static void MarkTrainDirty(Vehicle *v)
+{
+ do {
+ v->cur_image = GetTrainImage(v, v->direction);
+ MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
+ } while ((v = v->next) != NULL);
+}
+
+static void HandleTrainLoading(Vehicle *v, bool mode)
+{
+ if (v->current_order.type == OT_NOTHING) return;
+
+ if (v->current_order.type != OT_DUMMY) {
+ if (v->current_order.type != OT_LOADING) return;
+ if (mode) return;
+
+ // don't mark the train as lost if we're loading on the final station.
+ if (v->current_order.flags & OF_NON_STOP)
+ v->u.rail.days_since_order_progr = 0;
+
+ if (--v->load_unload_time_rem) return;
+
+ if (CanFillVehicle(v) && (v->current_order.flags & OF_FULL_LOAD ||
+ (_patches.gradual_loading && !HASBIT(v->load_status, LS_LOADING_FINISHED)))) {
+ v->u.rail.days_since_order_progr = 0; /* Prevent a train lost message for full loading trains */
+ SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);
+ if (LoadUnloadVehicle(v, false)) {
+ InvalidateWindow(WC_TRAINS_LIST, v->owner);
+ MarkTrainDirty(v);
+
+ // need to update acceleration and cached values since the goods on the train changed.
+ TrainCargoChanged(v);
+ UpdateTrainAcceleration(v);
+ }
+ return;
+ }
+
+ TrainPlayLeaveStationSound(v);
+
+ {
+ Order b = v->current_order;
+ v->current_order.type = OT_LEAVESTATION;
+ v->current_order.flags = 0;
+
+ // If this was not the final order, don't remove it from the list.
+ if (!(b.flags & OF_NON_STOP)) return;
+ }
+ }
+
+ v->u.rail.days_since_order_progr = 0;
+ v->cur_order_index++;
+ InvalidateVehicleOrder(v);
+}
+
+static int UpdateTrainSpeed(Vehicle *v)
+{
+ uint spd;
+ uint accel;
+
+ if (v->vehstatus & VS_STOPPED || HASBIT(v->u.rail.flags, VRF_REVERSING)) {
+ if (_patches.realistic_acceleration) {
+ accel = GetTrainAcceleration(v, AM_BRAKE) * 2;
+ } else {
+ accel = v->acceleration * -2;
+ }
+ } else {
+ if (_patches.realistic_acceleration) {
+ accel = GetTrainAcceleration(v, AM_ACCEL);
+ } else {
+ accel = v->acceleration;
+ }
+ }
+
+ spd = v->subspeed + accel * 2;
+ v->subspeed = (byte)spd;
+ {
+ int tempmax = v->max_speed;
+ if (v->cur_speed > v->max_speed)
+ tempmax = v->cur_speed - (v->cur_speed / 10) - 1;
+ v->cur_speed = spd = clamp(v->cur_speed + ((int)spd >> 8), 0, tempmax);
+ }
+
+ if (!(v->direction & 1)) spd = spd * 3 >> 2;
+
+ spd += v->progress;
+ v->progress = (byte)spd;
+ return (spd >> 8);
+}
+
+static void TrainEnterStation(Vehicle *v, StationID station)
+{
+ Station *st;
+ uint32 flags;
+
+ v->last_station_visited = station;
+
+ /* check if a train ever visited this station before */
+ st = GetStation(station);
+ if (!(st->had_vehicle_of_type & HVOT_TRAIN)) {
+ st->had_vehicle_of_type |= HVOT_TRAIN;
+ SetDParam(0, st->index);
+ flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
+ AddNewsItem(
+ STR_8801_CITIZENS_CELEBRATE_FIRST,
+ flags,
+ v->index,
+ 0
+ );
+ }
+
+ // Did we reach the final destination?
+ if (v->current_order.type == OT_GOTO_STATION &&
+ v->current_order.dest == station) {
+ // Yeah, keep the load/unload flags
+ // Non Stop now means if the order should be increased.
+ v->current_order.type = OT_LOADING;
+ v->current_order.flags &= OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER;
+ v->current_order.flags |= OF_NON_STOP;
+ } else {
+ // No, just do a simple load
+ v->current_order.type = OT_LOADING;
+ v->current_order.flags = 0;
+ }
+ v->current_order.dest = 0;
+
+ SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);
+ if (LoadUnloadVehicle(v, true) != 0) {
+ InvalidateWindow(WC_TRAINS_LIST, v->owner);
+ TrainCargoChanged(v);
+ UpdateTrainAcceleration(v);
+ }
+ MarkTrainDirty(v);
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+}
+
+static byte AfterSetTrainPos(Vehicle *v, bool new_tile)
+{
+ byte new_z, old_z;
+
+ // need this hint so it returns the right z coordinate on bridges.
+ new_z = GetSlopeZ(v->x_pos, v->y_pos);
+
+ old_z = v->z_pos;
+ v->z_pos = new_z;
+
+ if (new_tile) {
+ CLRBIT(v->u.rail.flags, VRF_GOINGUP);
+ CLRBIT(v->u.rail.flags, VRF_GOINGDOWN);
+
+ if (new_z != old_z) {
+ TileIndex tile = TileVirtXY(v->x_pos, v->y_pos);
+
+ // XXX workaround, whole UP/DOWN detection needs overhaul
+ if (!IsTunnelTile(tile)) {
+ SETBIT(v->u.rail.flags, (new_z > old_z) ? VRF_GOINGUP : VRF_GOINGDOWN);
+ }
+ }
+ }
+
+ VehiclePositionChanged(v);
+ EndVehicleMove(v);
+ return old_z;
+}
+
+static const Direction _new_vehicle_direction_table[11] = {
+ DIR_N , DIR_NW, DIR_W , 0,
+ DIR_NE, DIR_N , DIR_SW, 0,
+ DIR_E , DIR_SE, DIR_S
+};
+
+static Direction GetNewVehicleDirectionByTile(TileIndex new_tile, TileIndex old_tile)
+{
+ uint offs = (TileY(new_tile) - TileY(old_tile) + 1) * 4 +
+ TileX(new_tile) - TileX(old_tile) + 1;
+ assert(offs < 11);
+ return _new_vehicle_direction_table[offs];
+}
+
+static Direction GetNewVehicleDirection(const Vehicle *v, int x, int y)
+{
+ uint offs = (y - v->y_pos + 1) * 4 + (x - v->x_pos + 1);
+ assert(offs < 11);
+ return _new_vehicle_direction_table[offs];
+}
+
+static int GetDirectionToVehicle(const Vehicle *v, int x, int y)
+{
+ byte offs;
+
+ x -= v->x_pos;
+ if (x >= 0) {
+ offs = (x > 2) ? 0 : 1;
+ } else {
+ offs = (x < -2) ? 2 : 1;
+ }
+
+ y -= v->y_pos;
+ if (y >= 0) {
+ offs += ((y > 2) ? 0 : 1) * 4;
+ } else {
+ offs += ((y < -2) ? 2 : 1) * 4;
+ }
+
+ assert(offs < 11);
+ return _new_vehicle_direction_table[offs];
+}
+
+/* Check if the vehicle is compatible with the specified tile */
+static bool CheckCompatibleRail(const Vehicle *v, TileIndex tile)
+{
+ switch (GetTileType(tile)) {
+ case MP_TUNNELBRIDGE:
+ case MP_RAILWAY:
+ case MP_STATION:
+ // normal tracks, jump to owner check
+ break;
+
+ case MP_STREET:
+ // tracks over roads, do owner check of tracks
+ return
+ IsTileOwner(tile, v->owner) && (
+ !IsFrontEngine(v) ||
+ IsCompatibleRail(v->u.rail.railtype, GetRailTypeCrossing(tile))
+ );
+
+ default:
+ return true;
+ }
+
+ return
+ IsTileOwner(tile, v->owner) && (
+ !IsFrontEngine(v) ||
+ HASBIT(v->u.rail.compatible_railtypes, GetRailType(tile))
+ );
+}
+
+typedef struct {
+ byte small_turn, large_turn;
+ byte z_up; // fraction to remove when moving up
+ byte z_down; // fraction to remove when moving down
+} RailtypeSlowdownParams;
+
+static const RailtypeSlowdownParams _railtype_slowdown[] = {
+ // normal accel
+ {256 / 4, 256 / 2, 256 / 4, 2}, // normal
+ {256 / 4, 256 / 2, 256 / 4, 2}, // electrified
+ {256 / 4, 256 / 2, 256 / 4, 2}, // monorail
+ {0, 256 / 2, 256 / 4, 2}, // maglev
+};
+
+/* Modify the speed of the vehicle due to a turn */
+static void AffectSpeedByDirChange(Vehicle* v, Direction new_dir)
+{
+ DirDiff diff;
+ const RailtypeSlowdownParams *rsp;
+
+ if (_patches.realistic_acceleration) return;
+
+ diff = DirDifference(v->direction, new_dir);
+ if (diff == DIRDIFF_SAME) return;
+
+ rsp = &_railtype_slowdown[v->u.rail.railtype];
+ v->cur_speed -= (diff == DIRDIFF_45RIGHT || diff == DIRDIFF_45LEFT ? rsp->small_turn : rsp->large_turn) * v->cur_speed >> 8;
+}
+
+/* Modify the speed of the vehicle due to a change in altitude */
+static void AffectSpeedByZChange(Vehicle *v, byte old_z)
+{
+ const RailtypeSlowdownParams *rsp;
+ if (old_z == v->z_pos || _patches.realistic_acceleration) return;
+
+ rsp = &_railtype_slowdown[v->u.rail.railtype];
+
+ if (old_z < v->z_pos) {
+ v->cur_speed -= (v->cur_speed * rsp->z_up >> 8);
+ } else {
+ uint16 spd = v->cur_speed + rsp->z_down;
+ if (spd <= v->max_speed) v->cur_speed = spd;
+ }
+}
+
+static const DiagDirection _otherside_signal_directions[] = {
+ DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, 0, 0,
+ DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE
+};
+
+static void TrainMovedChangeSignals(TileIndex tile, DiagDirection dir)
+{
+ if (IsTileType(tile, MP_RAILWAY) &&
+ GetRailTileType(tile) == RAIL_TILE_SIGNALS) {
+ uint i = FindFirstBit2x64(GetTrackBits(tile) * 0x101 & _reachable_tracks[dir]);
+ UpdateSignalsOnSegment(tile, _otherside_signal_directions[i]);
+ }
+}
+
+
+typedef struct TrainCollideChecker {
+ const Vehicle *v;
+ const Vehicle *v_skip;
+} TrainCollideChecker;
+
+static void *FindTrainCollideEnum(Vehicle *v, void *data)
+{
+ const TrainCollideChecker* tcc = data;
+
+ if (v != tcc->v &&
+ v != tcc->v_skip &&
+ v->type == VEH_Train &&
+ v->u.rail.track != 0x80 &&
+ myabs(v->z_pos - tcc->v->z_pos) <= 6 &&
+ myabs(v->x_pos - tcc->v->x_pos) < 6 &&
+ myabs(v->y_pos - tcc->v->y_pos) < 6) {
+ return v;
+ } else {
+ return NULL;
+ }
+}
+
+static void SetVehicleCrashed(Vehicle *v)
+{
+ Vehicle *u;
+
+ if (v->u.rail.crash_anim_pos != 0) return;
+
+ v->u.rail.crash_anim_pos++;
+
+ u = v;
+ BEGIN_ENUM_WAGONS(v)
+ v->vehstatus |= VS_CRASHED;
+ END_ENUM_WAGONS(v)
+
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, u->index, STATUS_BAR);
+}
+
+static uint CountPassengersInTrain(const Vehicle* v)
+{
+ uint num = 0;
+ BEGIN_ENUM_WAGONS(v)
+ if (v->cargo_type == CT_PASSENGERS) num += v->cargo_count;
+ END_ENUM_WAGONS(v)
+ return num;
+}
+
+/*
+ * Checks whether the specified train has a collision with another vehicle. If
+ * so, destroys this vehicle, and the other vehicle if its subtype has TS_Front.
+ * Reports the incident in a flashy news item, modifies station ratings and
+ * plays a sound.
+ */
+static void CheckTrainCollision(Vehicle *v)
+{
+ TrainCollideChecker tcc;
+ Vehicle *coll;
+ Vehicle *realcoll;
+ uint num;
+
+ /* can't collide in depot */
+ if (v->u.rail.track == 0x80) return;
+
+ assert(v->u.rail.track == 0x40 || TileVirtXY(v->x_pos, v->y_pos) == v->tile);
+
+ tcc.v = v;
+ tcc.v_skip = v->next;
+
+ /* find colliding vehicle */
+ realcoll = VehicleFromPos(TileVirtXY(v->x_pos, v->y_pos), &tcc, FindTrainCollideEnum);
+ if (realcoll == NULL) return;
+
+ coll = GetFirstVehicleInChain(realcoll);
+
+ /* it can't collide with its own wagons */
+ if (v == coll ||
+ (v->u.rail.track & 0x40 && (v->direction & 2) != (realcoll->direction & 2)))
+ return;
+
+ //two drivers + passangers killed in train v
+ num = 2 + CountPassengersInTrain(v);
+ if (!(coll->vehstatus & VS_CRASHED))
+ //two drivers + passangers killed in train coll (if it was not crashed already)
+ num += 2 + CountPassengersInTrain(coll);
+
+ SetVehicleCrashed(v);
+ if (IsFrontEngine(coll)) SetVehicleCrashed(coll);
+
+ SetDParam(0, num);
+ AddNewsItem(STR_8868_TRAIN_CRASH_DIE_IN_FIREBALL,
+ NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_VEHICLE, NT_ACCIDENT, 0),
+ v->index,
+ 0
+ );
+
+ ModifyStationRatingAround(v->tile, v->owner, -160, 30);
+ SndPlayVehicleFx(SND_13_BIG_CRASH, v);
+}
+
+typedef struct VehicleAtSignalData {
+ TileIndex tile;
+ Direction direction;
+} VehicleAtSignalData;
+
+static void *CheckVehicleAtSignal(Vehicle *v, void *data)
+{
+ const VehicleAtSignalData* vasd = data;
+
+ if (v->type == VEH_Train && IsFrontEngine(v) && v->tile == vasd->tile) {
+ DirDiff diff = ChangeDirDiff(DirDifference(v->direction, vasd->direction), DIRDIFF_90RIGHT);
+
+ if (diff == DIRDIFF_90RIGHT || (v->cur_speed <= 5 && diff <= DIRDIFF_REVERSE)) return v;
+ }
+ return NULL;
+}
+
+static void TrainController(Vehicle *v, bool update_image)
+{
+ Vehicle *prev;
+ GetNewVehiclePosResult gp;
+ uint32 r, tracks,ts;
+ int i;
+ DiagDirection enterdir;
+ Direction dir;
+ Direction newdir;
+ Direction chosen_dir;
+ byte chosen_track;
+ byte old_z;
+
+ /* For every vehicle after and including the given vehicle */
+ for (prev = GetPrevVehicleInChain(v); v != NULL; prev = v, v = v->next) {
+ BeginVehicleMove(v);
+
+ if (v->u.rail.track != 0x40) {
+ /* Not inside tunnel */
+ if (GetNewVehiclePos(v, &gp)) {
+ /* Staying in the old tile */
+ if (v->u.rail.track == 0x80) {
+ /* inside depot */
+ gp.x = v->x_pos;
+ gp.y = v->y_pos;
+ } else {
+ /* is not inside depot */
+
+ if (!TrainCheckIfLineEnds(v)) return;
+
+ r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);
+ if (r & 0x8) {
+ //debug("%x & 0x8", r);
+ goto invalid_rail;
+ }
+ if (r & 0x2) {
+ TrainEnterStation(v, r >> 8);
+ return;
+ }
+
+ if (v->current_order.type == OT_LEAVESTATION) {
+ v->current_order.type = OT_NOTHING;
+ v->current_order.flags = 0;
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+ }
+ }
+ } else {
+ /* A new tile is about to be entered. */
+
+ byte bits;
+ /* Determine what direction we're entering the new tile from */
+ dir = GetNewVehicleDirectionByTile(gp.new_tile, gp.old_tile);
+ enterdir = DirToDiagDir(dir);
+ assert(enterdir==0 || enterdir==1 || enterdir==2 || enterdir==3);
+
+ /* Get the status of the tracks in the new tile and mask
+ * away the bits that aren't reachable. */
+ ts = GetTileTrackStatus(gp.new_tile, TRANSPORT_RAIL) & _reachable_tracks[enterdir];
+
+ /* Combine the from & to directions.
+ * Now, the lower byte contains the track status, and the byte at bit 16 contains
+ * the signal status. */
+ tracks = ts | (ts >> 8);
+ bits = tracks & 0xFF;
+ if ((_patches.new_pathfinding_all || _patches.yapf.rail_use_yapf) && _patches.forbid_90_deg && prev == NULL) {
+ /* We allow wagons to make 90 deg turns, because forbid_90_deg
+ * can be switched on halfway a turn */
+ bits &= ~TrackCrossesTracks(FIND_FIRST_BIT(v->u.rail.track));
+ }
+
+ if (bits == 0) {
+ //debug("%x == 0", bits);
+ goto invalid_rail;
+ }
+
+ /* Check if the new tile contrains tracks that are compatible
+ * with the current train, if not, bail out. */
+ if (!CheckCompatibleRail(v, gp.new_tile)) {
+ //debug("!CheckCompatibleRail(%p, %x)", v, gp.new_tile);
+ goto invalid_rail;
+ }
+
+ if (prev == NULL) {
+ /* Currently the locomotive is active. Determine which one of the
+ * available tracks to choose */
+ chosen_track = 1 << ChooseTrainTrack(v, gp.new_tile, enterdir, bits);
+ assert(chosen_track & tracks);
+
+ /* Check if it's a red signal and that force proceed is not clicked. */
+ if ( (tracks>>16)&chosen_track && v->u.rail.force_proceed == 0) goto red_light;
+ } else {
+ static byte _matching_tracks[8] = {0x30, 1, 0xC, 2, 0x30, 1, 0xC, 2};
+
+ /* The wagon is active, simply follow the prev vehicle. */
+ chosen_track = (byte)(_matching_tracks[GetDirectionToVehicle(prev, gp.x, gp.y)] & bits);
+ }
+
+ /* make sure chosen track is a valid track */
+ assert(chosen_track==1 || chosen_track==2 || chosen_track==4 || chosen_track==8 || chosen_track==16 || chosen_track==32);
+
+ /* Update XY to reflect the entrance to the new tile, and select the direction to use */
+ {
+ const byte *b = _initial_tile_subcoord[FIND_FIRST_BIT(chosen_track)][enterdir];
+ gp.x = (gp.x & ~0xF) | b[0];
+ gp.y = (gp.y & ~0xF) | b[1];
+ chosen_dir = b[2];
+ }
+
+ /* Call the landscape function and tell it that the vehicle entered the tile */
+ r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);
+ if (r & 0x8) {
+ //debug("%x & 0x8", r);
+ goto invalid_rail;
+ }
+
+ if (IsLevelCrossingTile(v->tile) && v->next == NULL) {
+ UnbarCrossing(v->tile);
+ MarkTileDirtyByTile(v->tile);
+ }
+
+ if (IsFrontEngine(v)) v->load_unload_time_rem = 0;
+
+ if (!(r&0x4)) {
+ v->tile = gp.new_tile;
+
+ if (GetTileRailType(gp.new_tile, chosen_track) != GetTileRailType(gp.old_tile, v->u.rail.track)) {
+ TrainPowerChanged(GetFirstVehicleInChain(v));
+ }
+
+ v->u.rail.track = chosen_track;
+ assert(v->u.rail.track);
+ }
+
+ if (IsFrontEngine(v)) TrainMovedChangeSignals(gp.new_tile, enterdir);
+
+ /* Signals can only change when the first
+ * (above) or the last vehicle moves. */
+ if (v->next == NULL)
+ TrainMovedChangeSignals(gp.old_tile, ReverseDiagDir(enterdir));
+
+ if (prev == NULL) AffectSpeedByDirChange(v, chosen_dir);
+
+ v->direction = chosen_dir;
+ }
+ } else {
+ /* in tunnel on on a bridge */
+ GetNewVehiclePos(v, &gp);
+
+ SetSpeedLimitOnBridge(v);
+
+ if (!(IsTunnelTile(gp.new_tile) || IsBridgeTile(gp.new_tile)) || !(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y) & 0x4)) {
+ v->x_pos = gp.x;
+ v->y_pos = gp.y;
+ VehiclePositionChanged(v);
+ if (!(v->vehstatus & VS_HIDDEN)) EndVehicleMove(v);
+ continue;
+ }
+ }
+
+ /* update image of train, as well as delta XY */
+ newdir = GetNewVehicleDirection(v, gp.x, gp.y);
+ UpdateTrainDeltaXY(v, newdir);
+ if (update_image) v->cur_image = GetTrainImage(v, newdir);
+
+ v->x_pos = gp.x;
+ v->y_pos = gp.y;
+
+ /* update the Z position of the vehicle */
+ old_z = AfterSetTrainPos(v, (gp.new_tile != gp.old_tile));
+
+ if (prev == NULL) {
+ /* This is the first vehicle in the train */
+ AffectSpeedByZChange(v, old_z);
+ }
+ }
+ return;
+
+invalid_rail:
+ /* We've reached end of line?? */
+ if (prev != NULL) error("!Disconnecting train");
+ goto reverse_train_direction;
+
+red_light: {
+ /* We're in front of a red signal ?? */
+ /* find the first set bit in ts. need to do it in 2 steps, since
+ * FIND_FIRST_BIT only handles 6 bits at a time. */
+ i = FindFirstBit2x64(ts);
+
+ if (!HasSignalOnTrackdir(gp.new_tile, ReverseTrackdir(i))) {
+ v->cur_speed = 0;
+ v->subspeed = 0;
+ v->progress = 255 - 100;
+ if (++v->load_unload_time_rem < _patches.wait_oneway_signal * 20) return;
+ } else if (HasSignalOnTrackdir(gp.new_tile, i)){
+ v->cur_speed = 0;
+ v->subspeed = 0;
+ v->progress = 255-10;
+ if (++v->load_unload_time_rem < _patches.wait_twoway_signal * 73) {
+ TileIndex o_tile = gp.new_tile + TileOffsByDiagDir(enterdir);
+ VehicleAtSignalData vasd;
+ vasd.tile = o_tile;
+ vasd.direction = ReverseDir(dir);
+
+ /* check if a train is waiting on the other side */
+ if (VehicleFromPos(o_tile, &vasd, CheckVehicleAtSignal) == NULL) return;
+ }
+ }
+ }
+
+reverse_train_direction:
+ v->load_unload_time_rem = 0;
+ v->cur_speed = 0;
+ v->subspeed = 0;
+ ReverseTrainDirection(v);
+}
+
+extern TileIndex CheckTunnelBusy(TileIndex tile, uint *length);
+
+/**
+ * Deletes/Clears the last wagon of a crashed train. It takes the engine of the
+ * train, then goes to the last wagon and deletes that. Each call to this function
+ * will remove the last wagon of a crashed train. If this wagon was on a crossing,
+ * or inside a tunnel, recalculate the signals as they might need updating
+ * @param v the @Vehicle of which last wagon is to be removed
+ */
+static void DeleteLastWagon(Vehicle *v)
+{
+ Vehicle *u = v;
+
+ /* Go to the last wagon and delete the link pointing there
+ * *u is then the one-before-last wagon, and *v the last
+ * one which will physicially be removed */
+ for (; v->next != NULL; v = v->next) u = v;
+ u->next = NULL;
+
+ InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+ DeleteWindowById(WC_VEHICLE_VIEW, v->index);
+ RebuildVehicleLists();
+ InvalidateWindow(WC_COMPANY, v->owner);
+
+ BeginVehicleMove(v);
+ EndVehicleMove(v);
+ DeleteVehicle(v);
+
+ if (!(v->u.rail.track & 0xC0))
+ SetSignalsOnBothDir(v->tile, FIND_FIRST_BIT(v->u.rail.track));
+
+ /* Check if the wagon was on a road/rail-crossing and disable it if no
+ * others are on it */
+ DisableTrainCrossing(v->tile);
+
+ if ( (v->u.rail.track == 0x40 && v->vehstatus & VS_HIDDEN) ) { // inside a tunnel
+ TileIndex endtile = CheckTunnelBusy(v->tile, NULL);
+
+ if (endtile == INVALID_TILE) return; // tunnel is busy (error returned)
+
+ switch (v->direction) {
+ case 1:
+ case 5:
+ SetSignalsOnBothDir(v->tile, 0);
+ SetSignalsOnBothDir(endtile, 0);
+ break;
+
+ case 3:
+ case 7:
+ SetSignalsOnBothDir(v->tile, 1);
+ SetSignalsOnBothDir(endtile, 1);
+ break;
+
+ default:
+ break;
+ }
+ }
+}
+
+static void ChangeTrainDirRandomly(Vehicle *v)
+{
+ static const DirDiff delta[] = {
+ DIRDIFF_45LEFT, DIRDIFF_SAME, DIRDIFF_SAME, DIRDIFF_45RIGHT
+ };
+
+ do {
+ /* We don't need to twist around vehicles if they're not visible */
+ if (!(v->vehstatus & VS_HIDDEN)) {
+ v->direction = ChangeDir(v->direction, delta[GB(Random(), 0, 2)]);
+ BeginVehicleMove(v);
+ UpdateTrainDeltaXY(v, v->direction);
+ v->cur_image = GetTrainImage(v, v->direction);
+ /* Refrain from updating the z position of the vehicle when on
+ a bridge, because AfterSetTrainPos will put the vehicle under
+ the bridge in that case */
+ if (!(v->u.rail.track & 0x40)) AfterSetTrainPos(v, false);
+ }
+ } while ((v = v->next) != NULL);
+}
+
+static void HandleCrashedTrain(Vehicle *v)
+{
+ int state = ++v->u.rail.crash_anim_pos;
+ uint32 r;
+ Vehicle *u;
+
+ if (state == 4 && !(v->u.rail.track & VS_HIDDEN)) {
+ CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
+ }
+
+ if (state <= 200 && CHANCE16R(1, 7, r)) {
+ int index = (r * 10 >> 16);
+
+ u = v;
+ do {
+ if (--index < 0) {
+ r = Random();
+
+ CreateEffectVehicleRel(u,
+ GB(r, 8, 3) + 2,
+ GB(r, 16, 3) + 2,
+ GB(r, 0, 3) + 5,
+ EV_EXPLOSION_SMALL);
+ break;
+ }
+ } while ((u = u->next) != NULL);
+ }
+
+ if (state <= 240 && !(v->tick_counter & 3)) ChangeTrainDirRandomly(v);
+
+ if (state >= 4440 && !(v->tick_counter&0x1F)) {
+ DeleteLastWagon(v);
+ InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Train);
+ }
+}
+
+static void HandleBrokenTrain(Vehicle *v)
+{
+ if (v->breakdown_ctr != 1) {
+ v->breakdown_ctr = 1;
+ v->cur_speed = 0;
+
+ if (v->breakdowns_since_last_service != 255)
+ v->breakdowns_since_last_service++;
+
+ InvalidateWindow(WC_VEHICLE_VIEW, v->index);
+ InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+
+ if (!PlayVehicleSound(v, VSE_BREAKDOWN)) {
+ SndPlayVehicleFx((_opt.landscape != LT_CANDY) ?
+ SND_10_TRAIN_BREAKDOWN : SND_3A_COMEDY_BREAKDOWN_2, v);
+ }
+
+ if (!(v->vehstatus & VS_HIDDEN)) {
+ Vehicle *u = CreateEffectVehicleRel(v, 4, 4, 5, EV_BREAKDOWN_SMOKE);
+ if (u != NULL) u->u.special.unk0 = v->breakdown_delay * 2;
+ }
+ }
+
+ if (!(v->tick_counter & 3)) {
+ if (!--v->breakdown_delay) {
+ v->breakdown_ctr = 0;
+ InvalidateWindow(WC_VEHICLE_VIEW, v->index);
+ }
+ }
+}
+
+static const byte _breakdown_speeds[16] = {
+ 225, 210, 195, 180, 165, 150, 135, 120, 105, 90, 75, 60, 45, 30, 15, 15
+};
+
+static bool TrainCheckIfLineEnds(Vehicle *v)
+{
+ TileIndex tile;
+ uint x,y;
+ uint16 break_speed;
+ DiagDirection dir;
+ int t;
+ uint32 ts;
+
+ t = v->breakdown_ctr;
+ if (t > 1) {
+ v->vehstatus |= VS_TRAIN_SLOWING;
+
+ break_speed = _breakdown_speeds[GB(~t, 4, 4)];
+ if (break_speed < v->cur_speed) v->cur_speed = break_speed;
+ } else {
+ v->vehstatus &= ~VS_TRAIN_SLOWING;
+ }
+
+ if (v->u.rail.track & 0x40) return true; // exit if inside a tunnel
+ if (v->u.rail.track & 0x80) return true; // exit if inside a depot
+
+ tile = v->tile;
+
+ if (IsTileType(tile, MP_TUNNELBRIDGE)) {
+ DiagDirection dir;
+
+ dir = IsTunnel(tile) ? GetTunnelDirection(tile) : GetBridgeRampDirection(tile);
+ if (DiagDirToDir(dir) == v->direction) return true;
+ }
+
+ // depot?
+ /* XXX -- When enabled, this makes it possible to crash trains of others
+ (by building a depot right against a station) */
+/* if (IsTileType(tile, MP_RAILWAY) && GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT)
+ return true;*/
+
+ /* Determine the non-diagonal direction in which we will exit this tile */
+ dir = DirToDiagDir(v->direction);
+ if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[dir]) {
+ dir = ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT);
+ }
+ /* Calculate next tile */
+ tile += TileOffsByDiagDir(dir);
+ // determine the track status on the next tile.
+ ts = GetTileTrackStatus(tile, TRANSPORT_RAIL) & _reachable_tracks[dir];
+
+ /* Calc position within the current tile ?? */
+ x = v->x_pos & 0xF;
+ y = v->y_pos & 0xF;
+
+ switch (v->direction) {
+ case DIR_N : x = ~x + ~y + 24; break;
+ case DIR_NW: x = y; /* FALLTHROUGH */
+ case DIR_NE: x = ~x + 16; break;
+ case DIR_E : x = ~x + y + 8; break;
+ case DIR_SE: x = y; break;
+ case DIR_S : x = x + y - 8; break;
+ case DIR_W : x = ~y + x + 8; break;
+ }
+
+ if (GB(ts, 0, 16) != 0) {
+ /* If we approach a rail-piece which we can't enter, or the back of a depot, don't enter it! */
+ if (x + 4 >= TILE_SIZE &&
+ (!CheckCompatibleRail(v, tile) ||
+ (IsTileDepotType(tile, TRANSPORT_RAIL) &&
+ GetRailDepotDirection(tile) == dir))) {
+ v->cur_speed = 0;
+ ReverseTrainDirection(v);
+ return false;
+ }
+ if ((ts &= (ts >> 16)) == 0) {
+ // make a rail/road crossing red
+ if (IsLevelCrossingTile(tile)) {
+ if (!IsCrossingBarred(tile)) {
+ BarCrossing(tile);
+ SndPlayVehicleFx(SND_0E_LEVEL_CROSSING, v);
+ MarkTileDirtyByTile(tile);
+ }
+ }
+ return true;
+ }
+ } else if (x + 4 >= TILE_SIZE) {
+ v->cur_speed = 0;
+ ReverseTrainDirection(v);
+ return false;
+ }
+
+ // slow down
+ v->vehstatus |= VS_TRAIN_SLOWING;
+ break_speed = _breakdown_speeds[x & 0xF];
+ if (!(v->direction & 1)) break_speed >>= 1;
+ if (break_speed < v->cur_speed) v->cur_speed = break_speed;
+
+ return true;
+}
+
+static void TrainLocoHandler(Vehicle *v, bool mode)
+{
+ int j;
+
+ /* train has crashed? */
+ if (v->u.rail.crash_anim_pos != 0) {
+ if (!mode) HandleCrashedTrain(v);
+ return;
+ }
+
+ if (v->u.rail.force_proceed != 0) v->u.rail.force_proceed--;
+
+ /* train is broken down? */
+ if (v->breakdown_ctr != 0) {
+ if (v->breakdown_ctr <= 2) {
+ HandleBrokenTrain(v);
+ return;
+ }
+ v->breakdown_ctr--;
+ }
+
+ if (HASBIT(v->u.rail.flags, VRF_REVERSING) && v->cur_speed == 0) {
+ ReverseTrainDirection(v);
+ }
+
+ /* exit if train is stopped */
+ if (v->vehstatus & VS_STOPPED && v->cur_speed == 0) return;
+
+ if (ProcessTrainOrder(v)) {
+ v->load_unload_time_rem = 0;
+ v->cur_speed = 0;
+ v->subspeed = 0;
+ ReverseTrainDirection(v);
+ return;
+ }
+
+ HandleTrainLoading(v, mode);
+
+ if (v->current_order.type == OT_LOADING) return;
+
+ if (CheckTrainStayInDepot(v)) return;
+
+ if (!mode) HandleLocomotiveSmokeCloud(v);
+
+ j = UpdateTrainSpeed(v);
+ if (j == 0) {
+ // if the vehicle has speed 0, update the last_speed field.
+ if (v->cur_speed != 0) return;
+ } else {
+ TrainCheckIfLineEnds(v);
+
+ do {
+ TrainController(v, true);
+ CheckTrainCollision(v);
+ if (v->cur_speed <= 0x100)
+ break;
+ } while (--j != 0);
+ }
+
+ SetLastSpeed(v, v->cur_speed);
+}
+
+
+void Train_Tick(Vehicle *v)
+{
+ if (_age_cargo_skip_counter == 0 && v->cargo_days != 0xff)
+ v->cargo_days++;
+
+ v->tick_counter++;
+
+ if (IsFrontEngine(v)) {
+ TrainLocoHandler(v, false);
+
+ // make sure vehicle wasn't deleted.
+ if (v->type == VEH_Train && IsFrontEngine(v))
+ TrainLocoHandler(v, true);
+ } else if (IsFreeWagon(v) && HASBITS(v->vehstatus, VS_CRASHED)) {
+ // Delete flooded standalone wagon
+ if (++v->u.rail.crash_anim_pos >= 4400)
+ DeleteVehicle(v);
+ }
+}
+
+#define MAX_ACCEPTABLE_DEPOT_DIST 16
+
+static void CheckIfTrainNeedsService(Vehicle *v)
+{
+ const Depot* depot;
+ TrainFindDepotData tfdd;
+
+ if (_patches.servint_trains == 0) return;
+ if (!VehicleNeedsService(v)) return;
+ if (v->vehstatus & VS_STOPPED) return;
+ if (_patches.gotodepot && VehicleHasDepotOrders(v)) return;
+
+ // Don't interfere with a depot visit scheduled by the user, or a
+ // depot visit by the order list.
+ if (v->current_order.type == OT_GOTO_DEPOT &&
+ (v->current_order.flags & (OF_HALT_IN_DEPOT | OF_PART_OF_ORDERS)) != 0)
+ return;
+
+ if (CheckTrainIsInsideDepot(v)) {
+ VehicleServiceInDepot(v);
+ return;
+ }
+
+ tfdd = FindClosestTrainDepot(v, MAX_ACCEPTABLE_DEPOT_DIST);
+ /* Only go to the depot if it is not too far out of our way. */
+ if (tfdd.best_length == (uint)-1 || tfdd.best_length > MAX_ACCEPTABLE_DEPOT_DIST) {
+ if (v->current_order.type == OT_GOTO_DEPOT) {
+ /* If we were already heading for a depot but it has
+ * suddenly moved farther away, we continue our normal
+ * schedule? */
+ v->current_order.type = OT_DUMMY;
+ v->current_order.flags = 0;
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+ }
+ return;
+ }
+
+ depot = GetDepotByTile(tfdd.tile);
+
+ if (v->current_order.type == OT_GOTO_DEPOT &&
+ v->current_order.dest != depot->index &&
+ !CHANCE16(3, 16)) {
+ return;
+ }
+
+ v->current_order.type = OT_GOTO_DEPOT;
+ v->current_order.flags = OF_NON_STOP;
+ v->current_order.dest = depot->index;
+ v->dest_tile = tfdd.tile;
+ InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+}
+
+int32 GetTrainRunningCost(const Vehicle *v)
+{
+ int32 cost = 0;
+
+ do {
+ const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
+ if (rvi->running_cost_base > 0)
+ cost += rvi->running_cost_base * _price.running_rail[rvi->running_cost_class];
+ } while ((v = GetNextVehicle(v)) != NULL);
+
+ return cost;
+}
+
+void OnNewDay_Train(Vehicle *v)
+{
+ TileIndex tile;
+
+ if ((++v->day_counter & 7) == 0) DecreaseVehicleValue(v);
+
+ if (IsFrontEngine(v)) {
+ CheckVehicleBreakdown(v);
+ AgeVehicle(v);
+
+ CheckIfTrainNeedsService(v);
+
+ CheckOrders(v);
+
+ /* update destination */
+ if (v->current_order.type == OT_GOTO_STATION &&
+ (tile = GetStation(v->current_order.dest)->train_tile) != 0) {
+ v->dest_tile = tile;
+ }
+
+ if ((v->vehstatus & VS_STOPPED) == 0) {
+ /* running costs */
+ int32 cost = GetTrainRunningCost(v) / 364;
+
+ v->profit_this_year -= cost >> 8;
+
+ SET_EXPENSES_TYPE(EXPENSES_TRAIN_RUN);
+ SubtractMoneyFromPlayerFract(v->owner, cost);
+
+ InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+ InvalidateWindowClasses(WC_TRAINS_LIST);
+ }
+ }
+}
+
+void TrainsYearlyLoop(void)
+{
+ Vehicle *v;
+
+ FOR_ALL_VEHICLES(v) {
+ if (v->type == VEH_Train && IsFrontEngine(v)) {
+
+ // show warning if train is not generating enough income last 2 years (corresponds to a red icon in the vehicle list)
+ if (_patches.train_income_warn && v->owner == _local_player && v->age >= 730 && v->profit_this_year < 0) {
+ SetDParam(1, v->profit_this_year);
+ SetDParam(0, v->unitnumber);
+ AddNewsItem(
+ STR_TRAIN_IS_UNPROFITABLE,
+ NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0),
+ v->index,
+ 0);
+ }
+
+ v->profit_last_year = v->profit_this_year;
+ v->profit_this_year = 0;
+ InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+ }
+ }
+}
+
+
+void InitializeTrains(void)
+{
+ _age_cargo_skip_counter = 1;
+}
+
+/*
+ * Link front and rear multiheaded engines to each other
+ * This is done when loading a savegame
+ */
+void ConnectMultiheadedTrains(void)
+{
+ Vehicle *v;
+
+ FOR_ALL_VEHICLES(v) {
+ if (v->type == VEH_Train) {
+ v->u.rail.other_multiheaded_part = NULL;
+ }
+ }
+
+ FOR_ALL_VEHICLES(v) {
+ if (v->type == VEH_Train && IsFrontEngine(v)) {
+ Vehicle *u = v;
+
+ BEGIN_ENUM_WAGONS(u) {
+ if (u->u.rail.other_multiheaded_part != NULL) continue; // we already linked this one
+
+ if (IsMultiheaded(u)) {
+ if (!IsTrainEngine(u)) {
+ /* we got a rear car without a front car. We will convert it to a front one */
+ SetTrainEngine(u);
+ u->spritenum--;
+ }
+
+ {
+ Vehicle *w;
+
+ for (w = u->next; w != NULL && (w->engine_type != u->engine_type || w->u.rail.other_multiheaded_part != NULL); w = GetNextVehicle(w));
+ if (w != NULL) {
+ /* we found a car to partner with this engine. Now we will make sure it face the right way */
+ if (IsTrainEngine(w)) {
+ ClearTrainEngine(w);
+ w->spritenum++;
+ }
+ }
+
+ if (w != NULL) {
+ w->u.rail.other_multiheaded_part = u;
+ u->u.rail.other_multiheaded_part = w;
+ } else {
+ /* we got a front car and no rear cars. We will fake this one for forget that it should have been multiheaded */
+ ClearMultiheaded(u);
+ }
+ }
+ }
+ } END_ENUM_WAGONS(u)
+ }
+ }
+}
+
+/*
+ * Converts all trains to the new subtype format introduced in savegame 16.2
+ * It also links multiheaded engines or make them forget they are multiheaded if no suitable partner is found
+ */
+void ConvertOldMultiheadToNew(void)
+{
+ Vehicle *v;
+ FOR_ALL_VEHICLES(v) {
+ if (v->type == VEH_Train) {
+ SETBIT(v->subtype, 7); // indicates that it's the old format and needs to be converted in the next loop
+ }
+ }
+
+ FOR_ALL_VEHICLES(v) {
+ if (v->type == VEH_Train) {
+ if (HASBIT(v->subtype, 7) && ((v->subtype & ~0x80) == 0 || (v->subtype & ~0x80) == 4)) {
+ Vehicle *u = v;
+
+ BEGIN_ENUM_WAGONS(u) {
+ const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);
+
+ CLRBIT(u->subtype, 7);
+ switch (u->subtype) {
+ case 0: /* TS_Front_Engine */
+ if (rvi->flags & RVI_MULTIHEAD) SetMultiheaded(u);
+ SetFrontEngine(u);
+ SetTrainEngine(u);
+ break;
+
+ case 1: /* TS_Artic_Part */
+ u->subtype = 0;
+ SetArticulatedPart(u);
+ break;
+
+ case 2: /* TS_Not_First */
+ u->subtype = 0;
+ if (rvi->flags & RVI_WAGON) {
+ // normal wagon
+ SetTrainWagon(u);
+ break;
+ }
+ if (rvi->flags & RVI_MULTIHEAD && rvi->image_index == u->spritenum - 1) {
+ // rear end of a multiheaded engine
+ SetMultiheaded(u);
+ break;
+ }
+ if (rvi->flags & RVI_MULTIHEAD) SetMultiheaded(u);
+ SetTrainEngine(u);
+ break;
+
+ case 4: /* TS_Free_Car */
+ u->subtype = 0;
+ SetTrainWagon(u);
+ SetFreeWagon(u);
+ break;
+ default: NOT_REACHED(); break;
+ }
+ } END_ENUM_WAGONS(u)
+ }
+ }
+ }
+}