if (mode != 0) return;

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

			SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC);

				InvalidateWindow(WC_AIRCRAFT_LIST, v->owner);

				MarkAircraftDirty(v);

			}

	}

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC);

	MarkAircraftDirty(v);

	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

#include "train.h"

#include "newgrf_engine.h"

#include "newgrf_sound.h"

#include "unmovable.h"

#include "date.h"

	return false;

}

{

	int profit = 0;

	int v_profit = 0; //virtual profit for feeder systems

	uint count, cap;

	PlayerID old_player;

	bool completely_empty = true;

	assert(v->current_order.type == OT_LOADING);

	v->cur_speed = 0;

	old_player = _current_player;

	_current_player = v->owner;

	for (; v != NULL; v = v->next) {

		GoodsEntry* ge;

		if (v->cargo_cap == 0) continue;

		ge = &st->goods[v->cargo_type];

		/* unload? */

			if (v->cargo_source != last_visited && ge->waiting_acceptance & 0x8000 && !(u->current_order.flags & OF_TRANSFER)) {

				// deliver goods to the station

				st->time_since_unload = 0;

				unloading_time += v->cargo_count; /* TTDBUG: bug in original TTD */

				result |= 1;

			} else if (u->current_order.flags & (OF_UNLOAD | OF_TRANSFER)) {

				/* unload goods and let it wait at the station */

				st->time_since_unload = 0;

					v_profit = GetTransportedGoodsIncome(

						v->cargo_count,

						DistanceManhattan(GetStation(v->cargo_source)->xy, GetStation(last_visited)->xy),

						ge->enroute_from = v->cargo_source;

				}

				// Update amount of waiting cargo

				if (u->current_order.flags & OF_TRANSFER) {

					ge->feeder_profit += v_profit;

					u->profit_this_year += v_profit;

				}

				result |= 2;

			}

			if (v->cargo_count != 0) completely_empty = false;

		/* don't pick up goods that we unloaded */

		if (u->current_order.flags & OF_UNLOAD) continue;

		/* update stats */

		ge->days_since_pickup = 0;

		switch (u->type) {

		// If there's goods waiting at the station, and the vehicle

		//  has capacity for it, load it on the vehicle.

		if (count != 0 &&

				(cap = v->cargo_cap - v->cargo_count) != 0) {

			int cargoshare;

			/* Skip loading this vehicle if another train/vehicle is already handling

			 * the same cargo type at this station */

			/* TODO: Regarding this, when we do gradual loading, we

			 * should first unload all vehicles and then start

			completely_empty = false;

			if (cap > count) cap = count;

			cargoshare = cap * 10000 / ge->waiting_acceptance;

			feeder_profit_share = ge->feeder_profit * cargoshare / 10000;

			v->cargo_count += cap;

		}

	}

	if (v_profit_total > 0) {

		ShowFeederIncomeAnimation(v->x_pos, v->y_pos, v->z_pos, v_profit_total);

	byte unk2;              ///< Carriages have the highest bit set in this one

	Year lifelength;

	Year base_life;

	byte railtype:4;

	byte climates:4;

	uint32 refit_mask;

STR_CONFIG_PATCHES_JOINSTATIONS                                 :{LTBLUE}Join train stations built next to each other: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_FULLLOADANY                                  :{LTBLUE}Leave station when any cargo is full, if 'full load': {ORANGE}{STRING1}

STR_CONFIG_PATCHES_IMPROVEDLOAD                                 :{LTBLUE}Use improved loading algorithm: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_INFLATION                                    :{LTBLUE}Inflation: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_SELECTGOODS                                  :{LTBLUE}Deliver cargo to a station only when there is a demand: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_LONGBRIDGES                                  :{LTBLUE}Allow building very long bridges: {ORANGE}{STRING1}

						break;

					case 0x07: /* Loading speed */

						/* Hyronymus explained me what does

						 * this mean and insists on having a

						 * credit ;-). --pasky */

						break;

					default:

	                   |        ((_patches.mammoth_trains ? 1 : 0) << 0x08)  // mammothtrains

	                   |                                        (1 << 0x09)  // trainrefit

	                   |                                        (0 << 0x0B)  // subsidiaries

	                   |                                        (1 << 0x12)  // unifiedmaglevmode - set bit 0 mode. Not revelant to OTTD

	                   |                                        (1 << 0x13)  // unifiedmaglevmode - set bit 1 mode

	                   |                                        (1 << 0x14)  // bridgespeedlimits

	// only for train vehicles

	CBID_TRAIN_VEHICLE_LENGTH       = 0x11,

	/* Called (if appropriate bit in callback mask is set) to determine if a

	 * newstation should be made available to build */

	CBID_STATION_AVAILABILITY       = 0x13,

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

				SET_EXPENSES_TYPE(EXPENSES_ROADVEH_INC);

					InvalidateWindow(WC_ROADVEH_LIST, v->owner);

					MarkRoadVehDirty(v);

				}

			}

			SET_EXPENSES_TYPE(EXPENSES_ROADVEH_INC);

				InvalidateWindow(WC_ROADVEH_LIST, v->owner);

				MarkRoadVehDirty(v);

			}

#include "variables.h"

#include <setjmp.h>

uint16 _sl_version;       /// the major savegame version identifier

byte   _sl_minor_version; /// the minor savegame version, DO NOT USE!

	 SDT_VAR(Patches, station_spread,SLE_UINT8,0, 0, 12, 4, 64, 0, STR_CONFIG_PATCHES_STATION_SPREAD,     InvalidateStationBuildWindow),

	SDT_BOOL(Patches, serviceathelipad,        0, 0,  true,        STR_CONFIG_PATCHES_SERVICEATHELIPAD,   NULL),

	SDT_BOOL(Patches, modified_catchment,      0, 0,  true,        STR_CONFIG_PATCHES_CATCHMENT,          NULL),

	/***************************************************************************/

	/* Economy section of the GUI-configure patches window */

	"station_spread",

	"serviceathelipad",

	"modified_catchment",

};

static const char *_patches_economy[] = {

		if (v->current_order.type != OT_LOADING) return;

		if (--v->load_unload_time_rem) return;

			SET_EXPENSES_TYPE(EXPENSES_SHIP_INC);

				InvalidateWindow(WC_SHIPS_LIST, v->owner);

				MarkShipDirty(v);

			}

								ShipArrivesAt(v, st);

								SET_EXPENSES_TYPE(EXPENSES_SHIP_INC);

									InvalidateWindow(WC_SHIPS_LIST, v->owner);

									MarkShipDirty(v);

								}

#include "../sound.h"

 * @see EngineInfo

 * @param a Introduction date

 * @param e Rail Type of the vehicle

 * @param f Bitmask of the climates

 */

/** Writes the properties of a train carriage into the EngineInfo struct.

 * @see EngineInfo

 * @param a Introduction date

 * @param e Rail Type of the vehicle

 * @param f Bitmask of the climates

 * @note the 0x80 in parameter b sets the "is carriage bit"

 */

// Rail types

// R = Conventional railway

	MK(  5479,  20,  15,  55, 0,       Y), /* 201 MightyMover Bubble Truck */

	MK( 20970,  20,  15,  55, 0,       Y), /* 202 Powernaught Bubble Truck */

	MK( 33023,  20,  15,  85, 0,       Y), /* 203 Wizzowow Bubble Truck */

	MK( 13575,  20,  20,  99, 0,       Y), /* 255  */

};

#undef Y

#undef M

#undef R

#undef E

/** Writes the properties of a rail vehicle into the RailVehicleInfo struct.

 * @see RailVehicleInfo

		if (--v->load_unload_time_rem) return;

			v->u.rail.days_since_order_progr = 0; /* Prevent a train lost message for full loading trains */

			SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);

				InvalidateWindow(WC_TRAINS_LIST, v->owner);

				MarkTrainDirty(v);

	v->current_order.dest = 0;

	SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);

		InvalidateWindow(WC_TRAINS_LIST, v->owner);

		TrainCargoChanged(v);

		UpdateTrainAcceleration(v);

	bool join_stations;                 // allow joining of train stations

	bool full_load_any;                 // new full load calculation, any cargo must be full

	bool improved_load;                 // improved loading algorithm

	byte station_spread;                // amount a station may spread

	bool inflation;                     // disable inflation

	bool selectgoods;                   // only send the goods to station if a train has been there

			))) {

		// If patch is active, use alternative CanFillVehicle-function

		do {

			if (v->cargo_count != v->cargo_cap) return true;

	SLE_CONDVAR(Vehicle, build_year,           SLE_INT32,                 31, SL_MAX_VERSION),

	    SLE_VAR(Vehicle, load_unload_time_rem, SLE_UINT16),

	    SLE_VAR(Vehicle, profit_this_year,     SLE_INT32),

	    SLE_VAR(Vehicle, profit_last_year,     SLE_INT32),

	VS_CRASHED         = 0x80,

};

/* Effect vehicle types */

typedef enum EffectVehicle {

	EV_CHIMNEY_SMOKE   = 0,

	bool leave_depot_instantly; // NOSAVE: stores if the vehicle needs to leave the depot it just entered. Used by autoreplace

	uint16 load_unload_time_rem;

	int32 profit_this_year;

	int32 profit_last_year;

UnitID GetFreeUnitNumber(byte type);

void TrainConsistChanged(Vehicle *v);

void TrainPowerChanged(Vehicle *v);