openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:b5c2449616b5
+:66dde6412125
 #include "table/strings.h"
 #include "map.h"
 #include "tile.h"
 #include "tunnel_map.h"
 #include "vehicle.h"
+#include "timetable.h"
 #include "articulated_vehicles.h"
 #include "command.h"
 #include "pathfind.h"
 #include "npf.h"
 #include "station.h"
 static void TrainCargoChanged(Vehicle* v)
 {
 	uint32 weight = 0;
 	for (Vehicle *u = v; u != NULL; u = u->next) {
-		uint32 vweight = GetCargo(u->cargo_type)->weight * u->cargo_count * FreightWagonMult(u->cargo_type) / 16;
+		uint32 vweight = GetCargo(u->cargo_type)->weight * u->cargo.Count() * FreightWagonMult(u->cargo_type) / 16;
 		/* Vehicle weight is not added for articulated parts. */
 		if (!IsArticulatedPart(u)) {
 			/* vehicle weight is the sum of the weight of the vehicle and the weight of its cargo */
 			vweight += GetVehicleProperty(u, 0x16, RailVehInfo(u->engine_type)->weight);
 		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];
+	if (v->cargo.Count() >= v->cargo_cap / 2U) base += _wagon_full_adder[img];
 	return base;
 }
 void DrawTrainEngine(int x, int y, EngineID engine, SpriteID pal)
 {
 		}
 	}
 	DrawSprite(image, pal, x, y);
 }
-static int32 CmdBuildRailWagon(EngineID engine, TileIndex tile, uint32 flags)
+static CommandCost CmdBuildRailWagon(EngineID engine, TileIndex tile, uint32 flags)
 {
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	const RailVehicleInfo *rvi = RailVehInfo(engine);
-	int32 value = (GetEngineProperty(engine, 0x17, rvi->base_cost) * _price.build_railwagon) >> 8;
+	CommandCost value((GetEngineProperty(engine, 0x17, rvi->base_cost) * _price.build_railwagon) >> 8);
 	uint num_vehicles = 1 + CountArticulatedParts(engine);
 	if (!(flags & DC_QUERY_COST)) {
 		Vehicle *vl[11]; // Allow for wagon and upto 10 artic parts.
 			}
 			v->cargo_type = rvi->cargo_type;
 			v->cargo_subtype = 0;
 			v->cargo_cap = rvi->capacity;
-			v->value = value;
+			v->value = value.GetCost();
 //			v->day_counter = 0;
 			v->u.rail.railtype = rvi->railtype;
 			v->build_year = _cur_year;
 			}
 			GetPlayer(_current_player)->num_engines[engine]++;
 		}
 	}
-	return value;
+	return CommandCost(value);
 }
 /** Move all free vehicles in the depot to the train */
 static void NormalizeTrainVehInDepot(const Vehicle* u)
 {
 				break;
 		}
 	}
 }
-static int32 EstimateTrainCost(EngineID engine, const RailVehicleInfo* rvi)
+static CommandCost EstimateTrainCost(EngineID engine, const RailVehicleInfo* rvi)
 {
-	return GetEngineProperty(engine, 0x17, rvi->base_cost) * (_price.build_railvehicle >> 3) >> 5;
+	return CommandCost(GetEngineProperty(engine, 0x17, rvi->base_cost) * (_price.build_railvehicle >> 3) >> 5);
 }
 static void AddRearEngineToMultiheadedTrain(Vehicle* v, Vehicle* u, bool building)
 {
 	u->direction = v->direction;
 * @param flags type of operation
 * @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)
+CommandCost CmdBuildRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	/* Check if the engine-type is valid (for the player) */
 	if (!IsEngineBuildable(p1, VEH_TRAIN, _current_player)) return_cmd_error(STR_RAIL_VEHICLE_NOT_AVAILABLE);
 	/* Check if the train is actually being built in a depot belonging
 	/* We need to see if the engine got power on the tile to avoid eletric engines in non-electric depots */
 	if (!HasPowerOnRail(rvi->railtype, GetRailType(tile))) return CMD_ERROR;
 	if (rvi->railveh_type == RAILVEH_WAGON) return CmdBuildRailWagon(p1, tile, flags);
-	int32 value = EstimateTrainCost(p1, rvi);
+	CommandCost value = EstimateTrainCost(p1, rvi);
 	uint num_vehicles =
 		(rvi->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1) +
 		CountArticulatedParts(p1);
 			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->value = value.GetCost();
 			v->last_station_visited = INVALID_STATION;
 			v->dest_tile = 0;
 			v->engine_type = p1;
 * @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)
+CommandCost CmdMoveRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	VehicleID s = GB(p1, 0, 16);
 	VehicleID d = GB(p1, 16, 16);
 	if (!IsValidVehicleID(s)) return CMD_ERROR;
 	if (dst != NULL) {
 		while (IsArticulatedPart(dst)) dst = GetPrevVehicleInChain(dst);
 	}
 	/* don't move the same vehicle.. */
-	if (src == dst) return 0;
+	if (src == dst) return CommandCost();
 	/* locate the head of the two chains */
 	Vehicle *src_head = GetFirstVehicleInChain(src);
 	Vehicle *dst_head;
 	if (dst != NULL) {
 	}
 	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;
+	if (HASBIT(p2, 0) && src_head == dst_head) return CommandCost();
 	{
 		int max_len = _patches.mammoth_trains ? 100 : 9;
 		/* check if all vehicles in the source train are stopped inside a depot. */
 		}
 		RebuildVehicleLists();
 	}
-	return 0;
+	return CommandCost();
 }
 /** Start/Stop a train.
 * @param tile unused
 * @param flags type of operation
 * @param p1 train to start/stop
 * @param p2 unused
 */
-int32 CmdStartStopTrain(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdStartStopTrain(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
 		v->vehstatus ^= VS_STOPPED;
 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 	}
-	return 0;
+	return CommandCost();
 }
 /** Sell a (single) train wagon/engine.
 * @param tile unused
 * @param flags type of operation
 * - 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)
+CommandCost CmdSellRailWagon(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	/* Check if we deleted a vehicle window */
 	Window *w = NULL;
 	if (!IsValidVehicleID(p1) || p2 > 2) return CMD_ERROR;
 		}
 		InvalidateWindow(WC_VEHICLE_DEPOT, first->tile);
 		RebuildVehicleLists();
 	}
-	int32 cost = 0;
+	CommandCost cost;
 	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
 			 * 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;
+				cost.AddCost(-rear->value);
 				if (flags & DC_EXEC) {
 					UnlinkWagon(rear, first);
 					DeleteDepotHighlightOfVehicle(rear);
 					DeleteVehicle(rear);
 				}
 					if (IsLocalPlayer() && w != NULL) ShowTrainViewWindow(new_f);
 				}
 			}
 			/* 3. Delete the requested wagon */
-			cost -= v->value;
+			cost.AddCost(-v->value);
 			if (flags & DC_EXEC) {
 				first = UnlinkWagon(v, first);
 				DeleteDepotHighlightOfVehicle(v);
 				DeleteVehicle(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;
+							cost.AddCost(-rear->value);
 							/* If this is a multiheaded vehicle with nothing
 							 * between the parts, tmp will be pointing to the
 							 * rear part, which is unlinked from the train and
 							 * deleted here. However, because tmp has already
 						/* The front to this engine is earlier in this train. Do nothing */
 						continue;
 					}
 				}
-				cost -= v->value;
+				cost.AddCost(-v->value);
 				if (flags & DC_EXEC) {
 					first = UnlinkWagon(v, first);
 					DeleteDepotHighlightOfVehicle(v);
 					DeleteVehicle(v);
 					RemoveVehicleFromGroup(v);
 * @param tile unused
 * @param flags type of operation
 * @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)
+CommandCost CmdReverseTrainDirection(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
 				SetLastSpeed(v, 0);
 				ReverseTrainDirection(v);
 			}
 		}
 	}
-	return 0;
+	return CommandCost();
 }
 /** Force a train through a red signal
 * @param tile unused
 * @param flags type of operation
 * @param p1 train to ignore the red signal
 * @param p2 unused
 */
-int32 CmdForceTrainProceed(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdForceTrainProceed(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *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;
+	return CommandCost();
 }
 /** Refits a train to the specified cargo type.
 * @param tile unused
 * @param flags type of operation
 * - p2 = (bit 0-7) - the new cargo type to refit to
 * - p2 = (bit 8-15) - the new cargo subtype to refit to
 * - p2 = (bit 16) - refit only this vehicle
 * @return cost of refit or error
 */
-int32 CmdRefitRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+CommandCost CmdRefitRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	CargoID new_cid = GB(p2, 0, 8);
 	byte new_subtype = GB(p2, 8, 8);
 	bool only_this = HASBIT(p2, 16);
 	/* Check cargo */
 	if (new_cid >= NUM_CARGO) return CMD_ERROR;
 	SET_EXPENSES_TYPE(EXPENSES_TRAIN_RUN);
-	int32 cost = 0;
+	CommandCost cost;
 	uint 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
 				}
 			}
 			if (amount != 0) {
 				if (new_cid != v->cargo_type) {
-					cost += GetRefitCost(v->engine_type);
+					cost.AddCost(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.Truncate((v->cargo_type == new_cid) ? amount : 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);
 * @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)
+CommandCost CmdSendTrainToDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	if (p2 & DEPOT_MASS_SEND) {
 		/* Mass goto depot requested */
 		if (!ValidVLWFlags(p2 & VLW_MASK)) return CMD_ERROR;
 		return SendAllVehiclesToDepot(VEH_TRAIN, flags, p2 & DEPOT_SERVICE, _current_player, (p2 & VLW_MASK), p1);
 			 * 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;
+			return CommandCost();
 		}
 		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->current_order.type = OT_DUMMY;
 			v->current_order.flags = 0;
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 		}
-		return 0;
+		return CommandCost();
 	}
 	/* 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;
 		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;
+	return CommandCost();
 }
 void OnTick_Train()
 {
 	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)) {
+				UpdateVehicleTimetable(v, true);
 				v->cur_order_index++;
 			}
 			break;
 		case OT_LOADING:
 	}
 	/* check if we've reached the waypoint? */
 	bool at_waypoint = false;
 	if (v->current_order.type == OT_GOTO_WAYPOINT && v->tile == v->dest_tile) {
+		UpdateVehicleTimetable(v, true);
 		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)) {
+		UpdateVehicleTimetable(v, true);
 		v->cur_order_index++;
 	}
 	/* Get the current order */
 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
 	v->current_order.dest = 0;
 }
 static byte AfterSetTrainPos(Vehicle *v, bool new_tile)
 {
-	/* need this hint so it returns the right z coordinate on bridges. */
-	byte new_z = GetSlopeZ(v->x_pos, v->y_pos);
 	byte old_z = v->z_pos;
-	v->z_pos = new_z;
+	v->z_pos = GetSlopeZ(v->x_pos, v->y_pos);
 	if (new_tile) {
 		CLRBIT(v->u.rail.flags, VRF_GOINGUP);
 		CLRBIT(v->u.rail.flags, VRF_GOINGDOWN);
-		if (new_z != old_z) {
+		if (v->u.rail.track == TRACK_BIT_X || v->u.rail.track == TRACK_BIT_Y) {
-			TileIndex tile = TileVirtXY(v->x_pos, v->y_pos);
+			/* Any track that isn't TRACK_BIT_X or TRACK_BIT_Y cannot be sloped.
+			 * To check whether the current tile is sloped, and in which
-			/* XXX workaround, whole UP/DOWN detection needs overhaul */
+			 * direction it is sloped, we get the 'z' at the center of
-			if (!IsTunnelTile(tile)) {
+			 * the tile (middle_z) and the edge of the tile (old_z),
-				SETBIT(v->u.rail.flags, (new_z > old_z) ? VRF_GOINGUP : VRF_GOINGDOWN);
+			 * which we then can compare. */
+			static const int HALF_TILE_SIZE = TILE_SIZE / 2;
+			static const int INV_TILE_SIZE_MASK = ~(TILE_SIZE - 1);
+			byte middle_z = GetSlopeZ((v->x_pos & INV_TILE_SIZE_MASK) | HALF_TILE_SIZE, (v->y_pos & INV_TILE_SIZE_MASK) | HALF_TILE_SIZE);
+			/* For some reason tunnel tiles are always given as sloped :(
+			 * But they are not sloped... */
+			if (middle_z != v->z_pos && !IsTunnelTile(TileVirtXY(v->x_pos, v->y_pos))) {
+				SETBIT(v->u.rail.flags, (middle_z > old_z) ? VRF_GOINGUP : VRF_GOINGDOWN);
 			}
 		}
 	}
 	VehiclePositionChanged(v);
 		UpdateSignalsOnSegment(tile, _otherside_signal_directions[i]);
 	}
 }
+static void SetVehicleCrashed(Vehicle *v)
+{
+	if (v->u.rail.crash_anim_pos != 0) return;
+	v->u.rail.crash_anim_pos++;
+	Vehicle *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 (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) num += v->cargo.Count();
+	END_ENUM_WAGONS(v)
+	return num;
+}
 struct TrainCollideChecker {
-	const Vehicle *v;
+	Vehicle *v;
 	const Vehicle *v_skip;
+	uint num;
 };
 static void *FindTrainCollideEnum(Vehicle *v, void *data)
 {
-	const TrainCollideChecker* tcc = (TrainCollideChecker*)data;
+	TrainCollideChecker* tcc = (TrainCollideChecker*)data;
 	if (v != tcc->v &&
 			v != tcc->v_skip &&
 			v->type == VEH_TRAIN &&
 			v->u.rail.track != TRACK_BIT_DEPOT &&
 			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) {
+			myabs(v->y_pos - tcc->v->y_pos) < 6 ) {
-		return v;
-	} else {
+		Vehicle *coll = GetFirstVehicleInChain(v);
-		return NULL;
-	}
+		/* it can't collide with its own wagons */
-}
+		if (tcc->v == coll ||
+			(tcc->v->u.rail.track == TRACK_BIT_WORMHOLE && (tcc->v->direction & 2) != (v->direction & 2)))
-static void SetVehicleCrashed(Vehicle *v)
+			return NULL;
-{
-	if (v->u.rail.crash_anim_pos != 0) return;
+		/* two drivers + passengers killed in train tcc->v (if it was not crashed already) */
+		if (!(tcc->v->vehstatus & VS_CRASHED)) {
-	v->u.rail.crash_anim_pos++;
+			tcc->num += 2 + CountPassengersInTrain(tcc->v);
+			SetVehicleCrashed(tcc->v);
-	Vehicle *u = v;
+		}
-	BEGIN_ENUM_WAGONS(v)
-		v->vehstatus |= VS_CRASHED;
+		if (!(coll->vehstatus & VS_CRASHED)) {
-	END_ENUM_WAGONS(v)
+			/* two drivers + passengers killed in train coll (if it was not crashed already) */
+			tcc->num += 2 + CountPassengersInTrain(coll);
-	InvalidateWindowWidget(WC_VEHICLE_VIEW, u->index, STATUS_BAR);
+			SetVehicleCrashed(coll);
-}
+		}
+	}
-static uint CountPassengersInTrain(const Vehicle* v)
-{
+	return NULL;
-	uint num = 0;
-	BEGIN_ENUM_WAGONS(v)
-		if (IsCargoInClass(v->cargo_type, CC_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.
 	assert(v->u.rail.track == TRACK_BIT_WORMHOLE || TileVirtXY(v->x_pos, v->y_pos) == v->tile);
 	TrainCollideChecker tcc;
 	tcc.v = v;
 	tcc.v_skip = v->next;
+	tcc.num = 0;
-	/* find colliding vehicle */
-	Vehicle *realcoll = (Vehicle*)VehicleFromPosXY(v->x_pos, v->y_pos, &tcc, FindTrainCollideEnum);
+	/* find colliding vehicles */
-	if (realcoll == NULL) return;
+	VehicleFromPosXY(v->x_pos, v->y_pos, &tcc, FindTrainCollideEnum);
-	Vehicle *coll = GetFirstVehicleInChain(realcoll);
+	/* any dead -> no crash */
+	if (tcc.num == 0) return;
-	/* it can't collide with its own wagons */
-	if (v == coll ||
+	SetDParam(0, tcc.num);
-			(v->u.rail.track == TRACK_BIT_WORMHOLE && (v->direction & 2) != (realcoll->direction & 2)))
-		return;
-	/* two drivers + passengers killed in train v */
-	uint num = 2 + CountPassengersInTrain(v);
-	if (!(coll->vehstatus & VS_CRASHED))
-		/* two drivers + passengers 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
 	);
 }
 void Train_Tick(Vehicle *v)
 {
-	if (_age_cargo_skip_counter == 0 && v->cargo_days != 0xff)
+	if (_age_cargo_skip_counter == 0) v->cargo.AgeCargo();
-		v->cargo_days++;
 	v->tick_counter++;
 	if (IsFrontEngine(v)) {
+		v->current_order_time++;
 		TrainLocoHandler(v, false);
 		/* make sure vehicle wasn't deleted. */
 		if (v->type == VEH_TRAIN && IsFrontEngine(v))
 			TrainLocoHandler(v, true);
 	v->current_order.dest = depot->index;
 	v->dest_tile = tfdd.tile;
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 }
-int32 GetTrainRunningCost(const Vehicle *v)
+Money GetTrainRunningCost(const Vehicle *v)
 {
-	int32 cost = 0;
+	Money cost = 0;
 	do {
 		const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
 		byte cost_factor = GetVehicleProperty(v, 0x0D, rvi->running_cost_base);
 			if (tile != 0) v->dest_tile = tile;
 		}
 		if ((v->vehstatus & VS_STOPPED) == 0) {
 			/* running costs */
-			int32 cost = GetTrainRunningCost(v) / 364;
+			CommandCost cost(GetTrainRunningCost(v) / 364);
-			v->profit_this_year -= cost >> 8;
+			v->profit_this_year -= cost.GetCost() >> 8;
 			SET_EXPENSES_TYPE(EXPENSES_TRAIN_RUN);
 			SubtractMoneyFromPlayerFract(v->owner, cost);
 			InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 			InvalidateWindowClasses(WC_TRAINS_LIST);
 		}
+	} else if (IsTrainEngine(v)) {
+		/* Also age engines that aren't front engines */
+		AgeVehicle(v);
 	}
 }
 void TrainsYearlyLoop()
 {

branch	noai
changeset 9629	66dde6412125
parent 9628	b5c2449616b5
child 9631	8a2d1c2ceb88