openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:f80c51a83069
+:5bd4843b681b
 * 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) {
+	for (const Vehicle *u = v; u != NULL; u = u->next) {
 		/* Power is not added for articulated parts */
 		if (IsArticulatedPart(u)) continue;
 		RailType railtype = (IsLevelCrossingTile(u->tile) ? GetRailTypeCrossing(u->tile) : GetRailType(u->tile));
 		bool engine_has_power = HasPowerOnRail(u->u.rail.railtype, railtype);
 * 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) {
+	for (Vehicle *u = v; u != NULL; u = u->next) {
-		const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);
+		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 += rvi->weight;
+			vweight += RailVehInfo(u->engine_type)->weight;
 			// powered wagons have extra weight added
 			if (HASBIT(u->u.rail.flags, VRF_POWEREDWAGON))
 				vweight += RailVehInfo(u->u.rail.first_engine)->pow_wag_weight;
 		}
 		// consist weight is the sum of the weight of all vehicles in the consist
 		weight += vweight;
 		// store vehicle weight in cache
 		u->u.rail.cached_veh_weight = vweight;
-	};
+	}
 	// store consist weight in cache
 	v->u.rail.cached_weight = weight;
 	/* Now update train power (tractive effort is dependent on weight) */
 * 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);
+	const RailVehicleInfo *rvi_v = RailVehInfo(v->engine_type);
-	first_engine = IsFrontEngine(v) ? v->engine_type : INVALID_ENGINE;
+	EngineID 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) {
+	for (Vehicle *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) ? (EngineID)INVALID_ENGINE : first_engine;
+		u->u.rail.first_engine = v == u ? INVALID_ENGINE : first_engine;
 		u->u.rail.railtype = rvi_u->railtype;
 		if (IsTrainEngine(u)) first_engine = u->engine_type;
 		if (rvi_u->visual_effect != 0) {
 				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->railveh_type == RAILVEH_WAGON &&
 				UsesWagonOverride(u) && (u->u.rail.cached_vis_effect < 0x40)) {
 				/* wagon is powered */
 				SETBIT(u->u.rail.flags, VRF_POWEREDWAGON); // cache 'powered' status
+			} else {
+				CLRBIT(u->u.rail.flags, VRF_POWEREDWAGON);
 			}
 			/* Do not count powered wagons for the compatible railtypes, as wagons always
 			   have railtype normal */
 			if (rvi_u->power > 0) {
 				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;
+		uint16 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)
 }
 //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 speed = v->cur_speed * 10 / 16; //[mph]
-	int friction = 35; //[1e-3]
+	int curvecount[2] = {0, 0};
-	int drag_coeff = 20; //[1e-4]
-	int incl = 0;
+	//first find the curve speed limit
-	int resistance;
+	int numcurve = 0;
-	int speed = v->cur_speed; //[mph]
+	int sum = 0;
-	int force = 0x3FFFFFFF;
 	int pos = 0;
 	int lastpos = -1;
-	int curvecount[2] = {0, 0};
+	for (const Vehicle *u = v; u->next != NULL; u = u->next, pos++) {
-	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++) {
 			max_speed = max(max_speed, 25 * station_length);
 		}
 	}
-	mass = v->u.rail.cached_weight;
+	int mass = v->u.rail.cached_weight;
-	power = v->u.rail.cached_power * 746;
+	int 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) {
+	int num = 0; //number of vehicles, change this into the number of axles later
+	int incl = 0;
+	int drag_coeff = 20; //[1e-4]
+	for (const Vehicle *u = v; u != NULL; u = u->next) {
 		num++;
 		drag_coeff += 3;
 		if (u->u.rail.track == TRACK_BIT_DEPOT) max_speed = min(max_speed, 61);
 		}
 	}
 	v->max_speed = max_speed;
+	const int area = 120;
+	const int friction = 35; //[1e-3]
+	int resistance;
 	if (v->u.rail.railtype != RAILTYPE_MAGLEV) {
 		resistance = 13 * mass / 10;
 		resistance += 60 * num;
 		resistance += friction * mass * speed / 1000;
 		resistance += (area * drag_coeff * speed * speed) / 10000;
 	resistance += incl;
 	resistance *= 4; //[N]
 	/* Due to the mph to m/s conversion below, at speeds below 3 mph the force is
 	 * actually double the train's power */
+	const int max_te = v->u.rail.cached_max_te; // [N]
+	int force;
 	if (speed > 2) {
 		switch (v->u.rail.railtype) {
 			case RAILTYPE_RAIL:
 			case RAILTYPE_ELECTRIC:
 			case RAILTYPE_MONO:
 				force *= 22;
 				force /= 10;
 				if (mode == AM_ACCEL && force > max_te) force = max_te;
 				break;
+			default: NOT_REACHED();
 			case RAILTYPE_MAGLEV:
 				force = power / 25;
 				break;
-			default: NOT_REACHED();
 		}
 	} else {
 		//"kickoff" acceleration
 		force = (mode == AM_ACCEL && v->u.rail.railtype != RAILTYPE_MAGLEV) ? min(max_te, power) : power;
 		force = max(force, (mass * 8) + resistance);
 	}
 }
 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;
+	uint power = v->u.rail.cached_power;
+	uint weight = v->u.rail.cached_weight;
 	assert(weight != 0);
 	v->acceleration = clamp(power / weight * 4, 1, 255);
 }
 int GetTrainImage(const Vehicle* v, Direction direction)
 {
 	DrawSprite(image, pal, x, y);
 }
 uint CountArticulatedParts(EngineID engine_type)
 {
-	uint16 callback;
+	if (!HASBIT(EngInfo(engine_type)->callbackmask, CBM_ARTIC_ENGINE)) return 0;
 	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);
+		uint16 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;
+	const Vehicle *v = vl[0];
-	EngineID engine_type;
+	Vehicle *u = vl[0];
-	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++) {
+	for (uint i = 1; i < 10; i++) {
-		callback = GetVehicleCallback(CBID_TRAIN_ARTIC_ENGINE, i, 0, v->engine_type, v);
+		uint16 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);
+		EngineID engine_type = GB(callback, 0, 7);
-		flip_image = HASBIT(callback, 7);
+		bool flip_image = HASBIT(callback, 7);
-		rvi_artic = RailVehInfo(engine_type);
+		const RailVehicleInfo *rvi_artic = RailVehInfo(engine_type);
 		// get common values from first engine
 		u->direction = v->direction;
 		u->owner = v->owner;
 		u->tile = v->tile;
 	}
 }
 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);
+	const RailVehicleInfo *rvi = RailVehInfo(engine);
-	value = (rvi->base_cost * _price.build_railwagon) >> 8;
+	int32 value = (rvi->base_cost * _price.build_railwagon) >> 8;
-	num_vehicles = 1 + CountArticulatedParts(engine);
+	uint 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;
+			Vehicle *v = vl[0];
-			DiagDirection dir;
-			v = vl[0];
 			v->spritenum = rvi->image_index;
-			u = NULL;
+			Vehicle *u = NULL;
+			Vehicle *w;
 			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);
+			DiagDirection dir = GetRailDepotDirection(tile);
 			v->direction = DiagDirToDir(dir);
 			v->tile = tile;
-			x = TileX(tile) * TILE_SIZE | _vehicle_initial_x_fract[dir];
+			int x = TileX(tile) * TILE_SIZE | _vehicle_initial_x_fract[dir];
-			y = TileY(tile) * TILE_SIZE | _vehicle_initial_y_fract[dir];
+			int y = TileY(tile) * TILE_SIZE | _vehicle_initial_y_fract[dir];
 			v->x_pos = x;
 			v->y_pos = y;
-			v->z_pos = GetSlopeZ(x,y);
+			v->z_pos = GetSlopeZ(x, y);
 			v->owner = _current_player;
 			v->z_height = 6;
 			v->u.rail.track = TRACK_BIT_DEPOT;
 			v->vehstatus = VS_HIDDEN | VS_DEFPAL;
 * @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;
-	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 (!IsTileOwner(tile, _current_player)) return CMD_ERROR;
 	}
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
-	rvi = RailVehInfo(p1);
+	const RailVehicleInfo *rvi = RailVehInfo(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(rvi->railtype, GetRailType(tile))) return CMD_ERROR;
 	if (rvi->railveh_type == RAILVEH_WAGON) return CmdBuildRailWagon(p1, tile, flags);
-	value = EstimateTrainCost(rvi);
+	int32 value = EstimateTrainCost(rvi);
-	num_vehicles = (rvi->railveh_type == RAILVEH_MULTIHEAD) ? 2 : 1;
+	uint num_vehicles =
-	num_vehicles += CountArticulatedParts(p1);
+		(rvi->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1) +
+		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))
 			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
-		v = vl[0];
+		Vehicle *v = vl[0];
-		unit_num = HASBIT(p2, 0) ? 0 : GetFreeUnitNumber(VEH_Train);
+		UnitID 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);
 			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_pos = GetSlopeZ(x, y);
 			v->z_height = 6;
 			v->u.rail.track = TRACK_BIT_DEPOT;
 			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
 			v->spritenum = rvi->image_index;
 			v->cargo_type = rvi->cargo_type;
 /* 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;
+	int count = 0;
 	for (; v != NULL; v = v->next) {
 		/* This count is used by the depot code to determine the number of engines
 		 * in the consist. Exclude articulated parts so that autoreplacing to
 		 * engines with more articulated parts than before works correctly.
 		 *
 }
 /* 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);
+	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;
 	}
+	Vehicle *u;
 	for (u = first; GetNextVehicle(u) != v; u = GetNextVehicle(u)) {}
 	GetLastEnginePart(u)->next = GetNextVehicle(v);
 	return first;
 }
 * 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);
+		Vehicle *u;
+		for (u = v; u->next != NULL && !IsTrainEngine(u->next); u = u->next) {}
 		if (u == v->u.rail.other_multiheaded_part) continue;
 		AddWagonToConsist(v->u.rail.other_multiheaded_part, u);
 	}
 }
 */
 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);
+	Vehicle *src = GetVehicle(s);
 	if (src->type != VEH_Train || !CheckOwnership(src->owner)) return CMD_ERROR;
 	// if nothing is selected as destination, try and find a matching vehicle to drag to.
+	Vehicle *dst;
 	if (d == INVALID_VEHICLE) {
 		dst = IsTrainEngine(src) ? NULL : FindGoodVehiclePos(src);
 	} else {
 		if (!IsValidVehicleID(d)) return CMD_ERROR;
 		dst = GetVehicle(d);
 	// don't move the same vehicle..
 	if (src == dst) return 0;
 	/* locate the head of the two chains */
-	src_head = GetFirstVehicleInChain(src);
+	Vehicle *src_head = GetFirstVehicleInChain(src);
+	Vehicle *dst_head;
 	if (dst != NULL) {
 		dst_head = GetFirstVehicleInChain(dst);
 		if (dst_head->tile != src_head->tile) return CMD_ERROR;
 		// Now deal with articulated part of destination wagon
 		dst = GetLastEnginePart(dst);
 		}
 	}
 	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;
+		Vehicle *engine = NULL;
-		for (u = dst_head; u != NULL; u = u->next) {
+		for (Vehicle *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;
 	// 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);
+		int 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;
 	}
 	/* do it? */
 	if (flags & DC_EXEC) {
 		/* clear the ->first cache */
-		{
+		for (Vehicle *u = src_head; u != NULL; u = u->next) u->first = NULL;
-			Vehicle *u;
+		for (Vehicle *u = dst_head; u != NULL; u = u->next) u->first = NULL;
-			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;
 				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)) {
 * @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);
+	Vehicle *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);
+	uint16 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);
 	}
 * - 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);
+	Vehicle *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);
+	Vehicle *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);
 	}
 		}
 		InvalidateWindow(WC_VEHICLE_DEPOT, first->tile);
 		RebuildVehicleLists();
 	}
+	int32 cost = 0;
 	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
 			}
 			/* 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);
+				Vehicle *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;
+				for (Vehicle *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) {
 				/* (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)) {
+					Vehicle *tmp;
 					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 */
+			Vehicle *tmp;
 			for (; v != NULL; v = tmp) {
 				tmp = GetNextVehicle(v);
 				if (IsMultiheaded(v)) {
 					if (IsTrainEngine(v)) {
 	}
 }
 static void SwapTrainFlags(byte *swap_flag1, byte *swap_flag2)
 {
-	byte flag1, flag2;
+	byte flag1 = *swap_flag1;
+	byte flag2 = *swap_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);
 * @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 *base = v;
-	Vehicle* first;
+	Vehicle *first = base->next;
-	int length;
+	uint length = CountVehiclesInChain(v);
-	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;
+		Vehicle *last = first;
-		for (i = length - 3; i > 0; i--) last = last->next;
+		for (uint i = length - 3; i > 0; i--) last = last->next;
-		differential = last->u.rail.cached_veh_length - base->u.rail.cached_veh_length;
+		int 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;
+			Vehicle *tempnext = last->next;
 			last->next = NULL;
-			for (i = 0; i < differential; i++) TrainController(first, false);
+			for (int i = 0; i < differential; i++) TrainController(first, false);
 			last->next = tempnext;
 		}
 		base = first;
 }
 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 */
 		/* Check if the train left a rail/road-crossing */
 		DisableTrainCrossing(tile);
 	}
 	// count number of vehicles
-	u = v;
+	int r = -1;
+	const Vehicle *u = v;
 	do r++; while ( (u = u->next) != NULL );
 	AdvanceWagons(v, true);
 	/* swap start<>end, start+1<>end-1, ... */
+	int l = 0;
 	do {
 		ReverseTrainSwapVeh(v, l++, r--);
 	} while (l <= r);
 	AdvanceWagons(v, false);
 * @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);
+	Vehicle *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);
+		Vehicle *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);
 		}
 * @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);
+	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;
 */
 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);
+	Vehicle *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;
+	int32 cost = 0;
-	num = 0;
+	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
 		 * 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;
 				v->cargo_type = temp_cid;
 				v->cargo_subtype = temp_subtype;
 			}
 			if (amount == CALLBACK_FAILED) { // callback failed or not used, use default
+				const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
 				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
 				 */
 					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);
 				}
 // returns the tile of a depot to goto to. The given vehicle must not be
 // crashed!
 static TrainFindDepotData FindClosestTrainDepot(Vehicle *v, int max_distance)
 {
+	assert(!(v->vehstatus & VS_CRASHED));
 	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)){
+	TileIndex tile = v->tile;
+	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);
+		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);
+		NPFFoundTargetData 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
 			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;
+		DiagDirection i = DirToDiagDir(v->direction);
-		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){
 * - 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);
+	Vehicle *v = GetVehicle(p1);
 	if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
 	/* 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);
+	TrainFindDepotData 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;
 	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;
+	const Vehicle* u = v;
 	do {
 		const RailVehicleInfo *rvi = RailVehInfo(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 ((rvi->railveh_type == RAILVEH_WAGON && effect_type == 0) ||
 				disable_effect ||
 				rvi->railtype > RAILTYPE_ELECTRIC ||
 			effect_type = rvi->engclass;
 		} else {
 			effect_type--;
 		}
-		x = _vehicle_smoke_pos[v->direction] * effect_offset;
+		int x = _vehicle_smoke_pos[v->direction] * effect_offset;
-		y = _vehicle_smoke_pos[(v->direction + 2) % 8] * effect_offset;
+		int y = _vehicle_smoke_pos[(v->direction + 2) % 8] * effect_offset;
 		if (HASBIT(v->u.rail.flags, VRF_REVERSE_DIRECTION)) {
 			x = -x;
 			y = -y;
 		}
 		SND_04_TRAIN,
 		SND_0A_TRAIN_HORN,
 		SND_0A_TRAIN_HORN
 	};
+	if (PlayVehicleSound(v, VSE_START)) return;
 	EngineID engtype = v->engine_type;
-	if (PlayVehicleSound(v, VSE_START)) return;
 	switch (RailVehInfo(engtype)->railtype) {
 		case RAILTYPE_RAIL:
 		case RAILTYPE_ELECTRIC:
 			SndPlayVehicleFx(sfx[RailVehInfo(engtype)->engclass], 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) {
+	for (const Vehicle *u = v; u != NULL; u = u->next) {
 		if (u->u.rail.track != TRACK_BIT_DEPOT || 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) {
 		 * 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);
+		uint dist = DistanceManhattan(tile, ttfd->dest_coords);
 		if (dist < ttfd->best_bird_dist) {
 			ttfd->best_bird_dist = dist;
 			ttfd->best_track = track;
 		}
 		return false;
 static const byte _pick_track_table[6] = {1, 3, 2, 2, 0, 0};
 /* choose a track */
 static Track ChooseTrainTrack(Vehicle* v, TileIndex tile, DiagDirection enterdir, TrackBits tracks)
 {
-	TrainTrackFollowerData fd;
 	Track best_track;
 	// pathfinders are able to tell that route was only 'guessed'
 	bool path_not_found = false;
 #ifdef PF_BENCHMARK
 		} else {
 			best_track = FindFirstTrack(tracks);
 		}
 	} 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);
+		Trackdir trackdir = GetVehicleTrackdir(v);
 		assert(trackdir != 0xff);
-		ftd = NPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.compatible_railtypes);
+		NPFFoundTargetData 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?
 			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);
+		int 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;
+		TrainTrackFollowerData fd;
 		FillWithStationData(&fd, v);
 		/* New train pathfinding */
 		fd.best_bird_dist = (uint)-1;
 		fd.best_track_dist = (uint)-1;
 			best_track = FindFirstTrack(tracks);
 		} else {
 			best_track = TrackdirToTrack(fd.best_track);
 		}
-		time = NpfEndInterval(perf);
+		int 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
 }
 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 == TRACK_BIT_DEPOT || v->u.rail.track == TRACK_BIT_WORMHOLE ||
 			!(v->direction & 1))
 		return false;
+	TrainTrackFollowerData fd;
 	FillWithStationData(&fd, v);
-	best_track = -1;
+	uint reverse_best = 0;
-	reverse_best = reverse = 0;
 	assert(v->u.rail.track);
-	i = _search_directions[FIND_FIRST_BIT(v->u.rail.track)][DirToDiagDir(v->direction)];
+	int 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;
 			} else {
 				reverse_best = false;
 			}
 		}
 	} else {
+		int best_track = -1;
+		uint reverse = 0;
+		uint best_bird_dist  = 0;
+		uint best_track_dist = 0;
 		for (;;) {
 			fd.best_bird_dist = (uint)-1;
 			fd.best_track_dist = (uint)-1;
 			NewTrainPathfind(v->tile, v->dest_tile, v->u.rail.compatible_railtypes, (DiagDirection)(reverse ^ i), (NTPEnumProc*)NtpCallbFindStation, &fd);
 					}
 				}
 				/* if we reach this position, there's two paths of equal value so far.
 				 * pick one randomly. */
-				r = GB(Random(), 0, 8);
+				int 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:;
 	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)) {
 		default: break;
 	}
 	// check if we've reached the waypoint?
+	bool at_waypoint = false;
 	if (v->current_order.type == OT_GOTO_WAYPOINT && v->tile == v->dest_tile) {
 		v->cur_order_index++;
 		at_waypoint = true;
 	}
 	}
 	// Get the current order
 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
-	order = GetVehicleOrder(v, v->cur_order_index);
+	const Order *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;
 	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;
 		}
 	}
-	spd = v->subspeed + accel * 2;
+	uint 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;
 	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);
+	Station *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);
+		uint32 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
 	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);
+	byte new_z = GetSlopeZ(v->x_pos, v->y_pos);
-	old_z = v->z_pos;
+	byte 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);
 };
 /* 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);
+	DirDiff diff = DirDifference(v->direction, new_dir);
 	if (diff == DIRDIFF_SAME) return;
-	rsp = &_railtype_slowdown[v->u.rail.railtype];
+	const RailtypeSlowdownParams *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];
+	const RailtypeSlowdownParams *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;
 	}
 }
 static void SetVehicleCrashed(Vehicle *v)
 {
-	Vehicle *u;
 	if (v->u.rail.crash_anim_pos != 0) return;
 	v->u.rail.crash_anim_pos++;
-	u = v;
+	Vehicle *u = v;
 	BEGIN_ENUM_WAGONS(v)
 		v->vehstatus |= VS_CRASHED;
 	END_ENUM_WAGONS(v)
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, u->index, STATUS_BAR);
 * 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 == TRACK_BIT_DEPOT) return;
 	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;
 	/* find colliding vehicle */
-	realcoll = (Vehicle*)VehicleFromPos(TileVirtXY(v->x_pos, v->y_pos), &tcc, FindTrainCollideEnum);
+	Vehicle *realcoll = (Vehicle*)VehicleFromPos(TileVirtXY(v->x_pos, v->y_pos), &tcc, FindTrainCollideEnum);
 	if (realcoll == NULL) return;
-	coll = GetFirstVehicleInChain(realcoll);
+	Vehicle *coll = GetFirstVehicleInChain(realcoll);
 	/* it can't collide with its own wagons */
 	if (v == coll ||
 			(v->u.rail.track == TRACK_BIT_WORMHOLE && (v->direction & 2) != (realcoll->direction & 2)))
 		return;
 	//two drivers + passangers killed in train v
-	num = 2 + CountPassengersInTrain(v);
+	uint 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);
 static void TrainController(Vehicle *v, bool update_image)
 {
 	Vehicle *prev;
 	GetNewVehiclePosResult gp;
-	uint32 r, tracks, ts;
+	uint32 ts;
-	Trackdir i;
 	DiagDirection enterdir;
 	Direction dir;
-	Direction newdir;
-	Direction chosen_dir;
-	TrackBits 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);
 				} else {
 					/* Not inside depot */
 					if (IsFrontEngine(v) && !TrainCheckIfLineEnds(v)) return;
-					r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);
+					uint32 r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);
 					if (HASBIT(r, VETS_CANNOT_ENTER)) {
 						goto invalid_rail;
 					}
 					if (HASBIT(r, VETS_ENTERED_STATION)) {
 						TrainEnterStation(v, r >> VETS_STATION_ID_OFFSET);
 				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);
+				uint32 tracks = ts | (ts >> 8);
 				bits = (TrackBits)(tracks & TRACK_BIT_MASK);
 				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(FindFirstTrack(v->u.rail.track));
 				/* Check if the new tile contrains tracks that are compatible
 				 * with the current train, if not, bail out. */
 				if (!CheckCompatibleRail(v, gp.new_tile)) goto invalid_rail;
+				TrackBits chosen_track;
 				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);
 						chosen_track == TRACK_BIT_X     || chosen_track == TRACK_BIT_Y ||
 						chosen_track == TRACK_BIT_UPPER || chosen_track == TRACK_BIT_LOWER ||
 						chosen_track == TRACK_BIT_LEFT  || chosen_track == TRACK_BIT_RIGHT);
 				/* 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];
-					const byte *b = _initial_tile_subcoord[FIND_FIRST_BIT(chosen_track)][enterdir];
+				gp.x = (gp.x & ~0xF) | b[0];
-					gp.x = (gp.x & ~0xF) | b[0];
+				gp.y = (gp.y & ~0xF) | b[1];
-					gp.y = (gp.y & ~0xF) | b[1];
+				Direction chosen_dir = (Direction)b[2];
-					chosen_dir = (Direction)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);
+				uint32 r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);
 				if (HASBIT(r, VETS_CANNOT_ENTER)) {
 					goto invalid_rail;
 				}
 				if (IsLevelCrossingTile(v->tile) && v->next == NULL) {
 				continue;
 			}
 		}
 		/* update image of train, as well as delta XY */
-		newdir = GetNewVehicleDirection(v, gp.x, gp.y);
+		Direction 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));
+		byte 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);
 		}
 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 = FindFirstTrackdir((TrackdirBits)(uint16)ts);
+		Trackdir i = FindFirstTrackdir((TrackdirBits)(uint16)ts);
 		if (!HasSignalOnTrackdir(gp.new_tile, ReverseTrackdir(i))) {
 			v->cur_speed = 0;
 			v->subspeed = 0;
 			v->progress = 255 - 100;
 * 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 */
+	Vehicle *u = v;
 	for (; v->next != NULL; v = v->next) u = v;
 	u->next = NULL;
 	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 	DeleteWindowById(WC_VEHICLE_VIEW, v->index);
 }
 static void HandleCrashedTrain(Vehicle *v)
 {
 	int state = ++v->u.rail.crash_anim_pos;
-	uint32 r;
-	Vehicle *u;
 	if (state == 4 && !(v->vehstatus & VS_HIDDEN)) {
 		CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
 	}
+	uint32 r;
 	if (state <= 200 && CHANCE16R(1, 7, r)) {
 		int index = (r * 10 >> 16);
-		u = v;
+		Vehicle *u = v;
 		do {
 			if (--index < 0) {
 				r = Random();
 				CreateEffectVehicleRel(u,
 	225, 210, 195, 180, 165, 150, 135, 120, 105, 90, 75, 60, 45, 30, 15, 15
 };
 static bool TrainCheckIfLineEnds(Vehicle *v)
 {
-	TileIndex tile;
+	int t = v->breakdown_ctr;
-	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)];
+		uint16 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 == TRACK_BIT_WORMHOLE) return true; // exit if inside a tunnel
 	if (v->u.rail.track == TRACK_BIT_DEPOT) return true; // exit if inside a depot
-	tile = v->tile;
+	TileIndex tile = v->tile;
 	if (IsTileType(tile, MP_TUNNELBRIDGE)) {
-		DiagDirection dir;
+		DiagDirection dir = IsTunnel(tile) ? GetTunnelDirection(tile) : GetBridgeRampDirection(tile);
-		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);
+	DiagDirection 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];
+	uint32 ts = GetTileTrackStatus(tile, TRANSPORT_RAIL) & _reachable_tracks[dir];
 	/* Calc position within the current tile ?? */
-	x = v->x_pos & 0xF;
+	uint x = v->x_pos & 0xF;
-	y = v->y_pos & 0xF;
+	uint 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;
 		return false;
 	}
 	// slow down
 	v->vehstatus |= VS_TRAIN_SLOWING;
-	break_speed = _breakdown_speeds[x & 0xF];
+	uint16 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 (CheckTrainStayInDepot(v)) return;
 	if (!mode) HandleLocomotiveSmokeCloud(v);
-	j = UpdateTrainSpeed(v);
+	int 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);
 #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;
 	if (CheckTrainIsInsideDepot(v)) {
 		VehicleServiceInDepot(v);
 		return;
 	}
-	tfdd = FindClosestTrainDepot(v, MAX_ACCEPTABLE_DEPOT_DIST);
+	TrainFindDepotData 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
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 		}
 		return;
 	}
-	depot = GetDepotByTile(tfdd.tile);
+	const Depot* depot = GetDepotByTile(tfdd.tile);
 	if (v->current_order.type == OT_GOTO_DEPOT &&
 			v->current_order.dest != depot->index &&
 			!CHANCE16(3, 16)) {
 		return;
 	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 &&
+		if (v->current_order.type == OT_GOTO_STATION) {
-				(tile = GetStation(v->current_order.dest)->train_tile) != 0) {
+			TileIndex tile = GetStation(v->current_order.dest)->train_tile;
-			v->dest_tile = tile;
+			if (tile != 0) v->dest_tile = tile;
 		}
 		if ((v->vehstatus & VS_STOPPED) == 0) {
 			/* running costs */
 			int32 cost = GetTrainRunningCost(v) / 364;
 {
 	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(
 						/* we got a rear car without a front car. We will convert it to a front one */
 						SetTrainEngine(u);
 						u->spritenum--;
 					}
-					{
+					Vehicle *w;
-						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) {
-						for (w = u->next; w != NULL && (w->engine_type != u->engine_type || w->u.rail.other_multiheaded_part != NULL); w = GetNextVehicle(w));
+						/* we found a car to partner with this engine. Now we will make sure it face the right way */
-						if (w != NULL) {
+						if (IsTrainEngine(w)) {
-							/* we found a car to partner with this engine. Now we will make sure it face the right way */
+							ClearTrainEngine(w);
-							if (IsTrainEngine(w)) {
+							w->spritenum++;
-								ClearTrainEngine(w);
-								w->spritenum++;
-							}
 						}
+						w->u.rail.other_multiheaded_part = u;
-						if (w != NULL) {
+						u->u.rail.other_multiheaded_part = w;
-							w->u.rail.other_multiheaded_part = u;
+					} else {
-							u->u.rail.other_multiheaded_part = w;
+						/* we got a front car and no rear cars. We will fake this one for forget that it should have been multiheaded */
-						} else {
+						ClearMultiheaded(u);
-							/* 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)
 		}
 	}

changeset 6476	5bd4843b681b
parent 6467	6228b576422d
child 6477	c0add302a009