openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:e442ce398e83
+:d1ac22c62f64
 void TrainPowerChanged(Vehicle* v)
 {
 	uint32 total_power = 0;
 	uint32 max_te = 0;
-	for (const Vehicle *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 = GetRailType(u->tile);
 		bool engine_has_power = HasPowerOnRail(u->u.rail.railtype, railtype);
 */
 static void TrainCargoChanged(Vehicle* v)
 {
 	uint32 weight = 0;
-	for (Vehicle *u = v; u != NULL; u = u->next) {
+	for (Vehicle *u = v; u != NULL; u = u->Next()) {
 		uint32 vweight = GetCargo(u->cargo_type)->weight * u->cargo.Count() * FreightWagonMult(u->cargo_type) / 16;
 		/* Vehicle weight is not added for articulated parts. */
 		if (!IsArticulatedPart(u)) {
 			/* vehicle weight is the sum of the weight of the vehicle and the weight of its cargo */
 	const RailVehicleInfo *rvi_v = RailVehInfo(v->engine_type);
 	EngineID first_engine = IsFrontEngine(v) ? v->engine_type : INVALID_ENGINE;
 	v->u.rail.cached_total_length = 0;
 	v->u.rail.compatible_railtypes = 0;
-	for (Vehicle *u = v; u != NULL; u = u->next) {
+	for (Vehicle *u = v; u != NULL; u = u->Next()) {
 		const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);
-		/* Update the v->first cache. This is faster than having to brute force it later. */
+		/* Check the v->first cache. */
-		if (u->first == NULL) u->first = v;
+		assert(u->First() == v);
 		/* update the 'first engine' */
 		u->u.rail.first_engine = v == u ? INVALID_ENGINE : first_engine;
 		u->u.rail.railtype = rvi_u->railtype;
 		uint16 veh_len = CALLBACK_FAILED;
 		if (HASBIT(EngInfo(u->engine_type)->callbackmask, CBM_VEHICLE_LENGTH)) {
 			veh_len = GetVehicleCallback(CBID_VEHICLE_LENGTH, 0, 0, u->engine_type, u);
 		}
 		if (veh_len == CALLBACK_FAILED) veh_len = rvi_u->shorten_factor;
-		veh_len = 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
+		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 */
 /** new acceleration*/
 static int GetTrainAcceleration(Vehicle *v, bool mode)
 {
 	int max_speed = 2000;
-	int speed = v->cur_speed * 10 / 16; //[mph]
+	int speed = v->GetDisplaySpeed(); //[mph]
 	int curvecount[2] = {0, 0};
 	/*first find the curve speed limit */
 	int numcurve = 0;
 	int sum = 0;
 	int pos = 0;
 	int lastpos = -1;
-	for (const Vehicle *u = v; u->next != NULL; u = u->next, pos++) {
+	for (const Vehicle *u = v; u->Next() != NULL; u = u->Next(), pos++) {
 		Direction dir = u->direction;
-		Direction ndir = u->next->direction;
+		Direction ndir = u->Next()->direction;
 		int i;
 		for (i = 0; i < 2; i++) {
 			if ( _curve_neighbours45[dir][i] == ndir) {
 				curvecount[i]++;
 	max_speed = min(max_speed, v->u.rail.cached_max_speed);
 	int num = 0; //number of vehicles, change this into the number of axles later
 	int incl = 0;
 	int drag_coeff = 20; //[1e-4]
-	for (const Vehicle *u = v; u != NULL; u = u->next) {
+	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 = new (v) Train();
 			v->subtype = 0;
 			SetTrainWagon(v);
 			if (u != NULL) {
-				u->next = v;
+				u->SetNext(v);
 			} else {
 				SetFreeWagon(v);
 				InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 			}
 			AddArticulatedParts(vl, VEH_TRAIN);
 			_new_vehicle_id = v->index;
 			VehiclePositionChanged(v);
-			TrainConsistChanged(GetFirstVehicleInChain(v));
+			TrainConsistChanged(v->First());
-			UpdateTrainGroupID(GetFirstVehicleInChain(v));
+			UpdateTrainGroupID(v->First());
 			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 			if (IsLocalPlayer()) {
-				InvalidateAutoreplaceWindow(VEH_TRAIN, v->group_id); // updates the replace Train window
+				InvalidateAutoreplaceWindow(v->engine_type, v->group_id); // updates the replace Train window
 			}
 			GetPlayer(_current_player)->num_engines[engine]++;
 		}
 	}
 	return CommandCost(GetEngineProperty(engine, 0x17, rvi->base_cost) * (_price.build_railvehicle >> 3) >> 5);
 }
 static void AddRearEngineToMultiheadedTrain(Vehicle* v, Vehicle* u, bool building)
 {
+	u = new (u) Train();
 	u->direction = v->direction;
 	u->owner = v->owner;
 	u->tile = v->tile;
 	u->x_pos = v->x_pos;
 	u->y_pos = v->y_pos;
 	u->z_pos = v->z_pos;
 	u->u.rail.track = TRACK_BIT_DEPOT;
 	u->vehstatus = v->vehstatus & ~VS_STOPPED;
-	u = new (u) Train();
 	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;
+	if (building) v->SetNext(u);
 	u->engine_type = v->engine_type;
 	u->build_year = v->build_year;
 	if (building) v->value >>= 1;
 	u->value = v->value;
 	u->cur_image = 0xAC2;
 			InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 			RebuildVehicleLists();
 			InvalidateWindow(WC_COMPANY, v->owner);
 			if (IsLocalPlayer())
-				InvalidateAutoreplaceWindow(VEH_TRAIN, v->group_id); // updates the replace Train window
+				InvalidateAutoreplaceWindow(v->engine_type, v->group_id); // updates the replace Train window
 			GetPlayer(_current_player)->num_engines[p1]++;
 		}
 	}
 	/* check if stopped in a depot */
 	if (!IsTileDepotType(tile, TRANSPORT_RAIL) || v->cur_speed != 0) return -1;
 	int count = 0;
-	for (; v != NULL; v = v->next) {
+	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 */
 		return v;
 	}
 	Vehicle *u;
 	for (u = first; GetNextVehicle(u) != v; u = GetNextVehicle(u)) {}
-	GetLastEnginePart(u)->next = GetNextVehicle(v);
+	GetLastEnginePart(u)->SetNext(GetNextVehicle(v));
-	v->first = NULL; // we shouldn't point to the old first, since the vehicle isn't in that chain anymore
 	return first;
 }
 static Vehicle *FindGoodVehiclePos(const Vehicle *src)
 {
 		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;
+				v = v->Next();
 				if (v == NULL) return dst;
 			}
 		}
 	}
 * 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));
+	UnlinkWagon(v, v->First());
 	if (dest == NULL) return;
-	v->next = dest->next;
+	Vehicle *next = dest->Next();
-	dest->next = v;
+	dest->SetNext(v);
+	v->SetNext(next);
 	ClearFreeWagon(v);
 	ClearFrontEngine(v);
 }
 /*
 	for (; v != NULL; v = GetNextVehicle(v)) {
 		if (!IsMultiheaded(v) || !IsTrainEngine(v)) continue;
 		/* make sure that there are no free cars before next engine */
 		Vehicle *u;
-		for (u = v; u->next != NULL && !IsTrainEngine(u->next); u = u->next) {}
+		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);
 	}
 }
 		dst = GetVehicle(d);
 		if (dst->type != VEH_TRAIN || !CheckOwnership(dst->owner)) return CMD_ERROR;
 	}
 	/* if an articulated part is being handled, deal with its parent vehicle */
-	while (IsArticulatedPart(src)) src = GetPrevVehicleInChain(src);
+	while (IsArticulatedPart(src)) src = src->Previous();
 	if (dst != NULL) {
-		while (IsArticulatedPart(dst)) dst = GetPrevVehicleInChain(dst);
+		while (IsArticulatedPart(dst)) dst = dst->Previous();
 	}
 	/* don't move the same vehicle.. */
 	if (src == dst) return CommandCost();
 	/* locate the head of the two chains */
-	Vehicle *src_head = GetFirstVehicleInChain(src);
+	Vehicle *src_head = src->First();
 	Vehicle *dst_head;
 	if (dst != NULL) {
-		dst_head = GetFirstVehicleInChain(dst);
+		dst_head = dst->First();
 		if (dst_head->tile != src_head->tile) return CMD_ERROR;
 		/* Now deal with articulated part of destination wagon */
 		dst = GetLastEnginePart(dst);
 	} else {
 		dst_head = NULL;
 		}
 	}
 	/* do it? */
 	if (flags & DC_EXEC) {
-		/* clear the ->first cache */
-		for (Vehicle *u = src_head; u != NULL; u = u->next) u->first = NULL;
-		for (Vehicle *u = dst_head; u != NULL; u = u->next) u->first = NULL;
 		/* If we move the front Engine and if the second vehicle is not an engine
 		   add the whole vehicle to the DEFAULT_GROUP */
 		if (IsFrontEngine(src) && !IsDefaultGroupID(src->group_id)) {
 			const Vehicle *v = GetNextVehicle(src);
 		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;
+				GetLastEnginePart(v)->SetNext(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;
+			GetLastEnginePart(src)->SetNext(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);
 			/* link in the wagon(s) in the chain. */
 			{
 				Vehicle *v;
 				for (v = src; GetNextVehicle(v) != NULL; v = GetNextVehicle(v));
-				GetLastEnginePart(v)->next = dst->next;
+				GetLastEnginePart(v)->SetNext(dst->Next());
 			}
-			dst->next = src;
+			dst->SetNext(src);
 		}
 		if (src->u.rail.other_multiheaded_part != NULL) {
 			if (src->u.rail.other_multiheaded_part == src_head) {
-				src_head = src_head->next;
+				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 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 (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
-	while (IsArticulatedPart(v)) v = GetPrevVehicleInChain(v);
+	while (IsArticulatedPart(v)) v = v->Previous();
-	Vehicle *first = GetFirstVehicleInChain(v);
+	Vehicle *first = v->First();
 	/* make sure the vehicle is stopped in the depot */
 	if (CheckTrainStoppedInDepot(first) < 0) {
 		return_cmd_error(STR_881A_TRAINS_CAN_ONLY_BE_ALTERED);
 	}
 			/* 2. We are selling the first engine, some special action might be required
 			 * here, so take attention */
 			if ((flags & DC_EXEC) && v == first) {
 				Vehicle *new_f = GetNextVehicle(first);
-				/* 2.1 If the first wagon is sold, update the first-> pointers to 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 && IsTrainEngine(new_f)) {
 					first->orders      = NULL;
 					first->prev_shared = NULL;
 					first->next_shared = NULL;
 					/* If we deleted a window then open a new one for the 'new' train */
-					if (IsLocalPlayer() && w != NULL) ShowTrainViewWindow(new_f);
+					if (IsLocalPlayer() && w != NULL) ShowVehicleViewWindow(new_f);
 				}
 			}
 			/* 3. Delete the requested wagon */
 			cost.AddCost(-v->value);
 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 (a = v; l != 0; l--) a = a->Next();
-	for (b = v; r != 0; r--) b = b->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);
 * @param before Set to true for the call before reversing, false otherwise
 */
 static void AdvanceWagons(Vehicle *v, bool before)
 {
 	Vehicle *base = v;
-	Vehicle *first = base->next;
+	Vehicle *first = base->Next();
 	uint length = CountVehiclesInChain(v);
 	while (length > 2) {
 		/* find pairwise matching wagon
 		 * start<>end, start+1<>end-1, ... */
 		Vehicle *last = first;
-		for (uint i = length - 3; i > 0; i--) last = last->next;
+		for (uint i = length - 3; i > 0; i--) last = last->Next();
 		int differential = last->u.rail.cached_veh_length - base->u.rail.cached_veh_length;
 		if (before) differential *= -1;
 		if (differential > 0) {
 			/* disconnect last car to make sure only this subset moves */
-			Vehicle *tempnext = last->next;
+			Vehicle *tempnext = last->Next();
-			last->next = NULL;
+			last->SetNext(NULL);
 			for (int i = 0; i < differential; i++) TrainController(first, false);
-			last->next = tempnext;
+			last->SetNext(tempnext);
 		}
 		base = first;
-		first = first->next;
+		first = first->Next();
 		length -= 2;
 	}
 }
 	}
 	/* count number of vehicles */
 	int r = -1;
 	const Vehicle *u = v;
-	do r++; while ( (u = u->next) != NULL );
+	do r++; while ((u = u->Next()) != NULL);
 	AdvanceWagons(v, true);
 	/* swap start<>end, start+1<>end-1, ... */
 	int l = 0;
 		if (IsMultiheaded(v) || HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_ARTIC_ENGINE)) {
 			return_cmd_error(STR_ONLY_TURN_SINGLE_UNIT);
 		}
-		Vehicle *front = GetFirstVehicleInChain(v);
+		Vehicle *front = v->First();
 		/* make sure the vehicle is stopped in the depot */
 		if (CheckTrainStoppedInDepot(front) < 0) {
 			return_cmd_error(STR_881A_TRAINS_CAN_ONLY_BE_ALTERED);
 		}
 			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 */
+		/* turn the whole train around */
-		if (v->u.rail.crash_anim_pos != 0 || v->breakdown_ctr != 0) return CMD_ERROR;
+		if (v->vehstatus & VS_CRASHED || 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 {
 					InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 					RebuildVehicleLists();
 				}
 			}
 		}
-	} while ((v = v->next) != NULL && !only_this);
+	} while ((v = v->Next()) != NULL && !only_this);
 	_returned_refit_capacity = num;
 	/* Update the train's cached variables */
-	if (flags & DC_EXEC) TrainConsistChanged(GetFirstVehicleInChain(GetVehicle(p1)));
+	if (flags & DC_EXEC) TrainConsistChanged(GetVehicle(p1)->First());
 	return cost;
 }
 struct TrainFindDepotData {
 				CreateEffectVehicleRel(v, 0, 0, 10, EV_ELECTRIC_SPARK);
 				sound = true;
 			}
 			break;
 		}
-	} while ((v = v->next) != NULL);
+	} while ((v = v->Next()) != NULL);
 	if (sound) PlayVehicleSound(u, VSE_TRAIN_EFFECT);
 }
 static void TrainPlayLeaveStationSound(const Vehicle* v)
 }
 static bool CheckTrainStayInDepot(Vehicle *v)
 {
 	/* bail out if not all wagons are in the same depot or not in a depot at all */
-	for (const Vehicle *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) {
 {
 	Vehicle *v = this;
 	do {
 		v->cur_image = v->GetImage(v->direction);
 		MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
-	} while ((v = v->next) != NULL);
+	} while ((v = v->Next()) != NULL);
 	/* need to update acceleration and cached values since the goods on the train changed. */
 	TrainCargoChanged(this);
 	UpdateTrainAcceleration(this);
 }
 			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 ) {
-		Vehicle *coll = GetFirstVehicleInChain(v);
+		Vehicle *coll = v->First();
 		/* 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)))
 			return NULL;
 	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.v_skip = v->Next();
 	tcc.num = 0;
 	/* find colliding vehicles */
 	if (v->u.rail.track == TRACK_BIT_WORMHOLE) {
 		VehicleFromPos(v->tile, &tcc, FindTrainCollideEnum);
 static void TrainController(Vehicle *v, bool update_image)
 {
 	Vehicle *prev;
 	/* For every vehicle after and including the given vehicle */
-	for (prev = GetPrevVehicleInChain(v); v != NULL; prev = v, v = v->next) {
+	for (prev = v->Previous(); v != NULL; prev = v, v = v->Next()) {
 		DiagDirection enterdir = DIAGDIR_BEGIN;
 		bool update_signals = false;
 		BeginVehicleMove(v);
 		GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 				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) {
+				if (IsLevelCrossingTile(v->tile) && v->Next() == NULL) {
 					UnbarCrossing(v->tile);
 					MarkTileDirtyByTile(v->tile);
 				}
 				if (IsFrontEngine(v)) v->load_unload_time_rem = 0;
 				if (!HASBIT(r, VETS_ENTERED_WORMHOLE)) {
 					v->tile = gp.new_tile;
 					if (GetTileRailType(gp.new_tile) != GetTileRailType(gp.old_tile)) {
-						TrainPowerChanged(GetFirstVehicleInChain(v));
+						TrainPowerChanged(v->First());
 					}
 					v->u.rail.track = chosen_track;
 					assert(v->u.rail.track);
 				}
 		if (update_signals) {
 			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 (v->Next() == NULL) TrainMovedChangeSignals(gp.old_tile, ReverseDiagDir(enterdir));
 		}
 	}
 	return;
 invalid_rail:
 {
 	/* 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;
+	for (; v->Next() != NULL; v = v->Next()) u = v;
-	u->next = NULL;
+	u->SetNext(NULL);
 	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 	DeleteWindowById(WC_VEHICLE_VIEW, v->index);
 	RebuildVehicleLists();
 	InvalidateWindow(WC_COMPANY, v->owner);
 			/* 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 != TRACK_BIT_WORMHOLE) AfterSetTrainPos(v, false);
 		}
-	} while ((v = v->next) != NULL);
+	} while ((v = v->Next()) != NULL);
 }
 static void HandleCrashedTrain(Vehicle *v)
 {
 	int state = ++v->u.rail.crash_anim_pos;
 					GB(r, 16, 3) + 2,
 					GB(r,  0, 3) + 5,
 					EV_EXPLOSION_SMALL);
 				break;
 			}
-		} while ((u = u->next) != NULL);
+		} while ((u = u->Next()) != NULL);
 	}
 	if (state <= 240 && !(v->tick_counter & 3)) ChangeTrainDirRandomly(v);
 	if (state >= 4440 && !(v->tick_counter&0x1F)) {
 }
 static void TrainLocoHandler(Vehicle *v, bool mode)
 {
 	/* train has crashed? */
-	if (v->u.rail.crash_anim_pos != 0) {
+	if (v->vehstatus & VS_CRASHED) {
 		if (!mode) HandleCrashedTrain(v);
 		return;
 	}
 	if (v->u.rail.force_proceed != 0) v->u.rail.force_proceed--;
 	SetLastSpeed(v, v->cur_speed);
 }
+Money Train::GetRunningCost() const
+{
+	Money cost = 0;
+	const Vehicle *v = this;
+	do {
+		const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
+		byte cost_factor = GetVehicleProperty(v, 0x0D, rvi->running_cost_base);
+		if (cost_factor == 0) continue;
+		cost += cost_factor * _price.running_rail[rvi->running_cost_class];
+	} while ((v = GetNextVehicle(v)) != NULL);
+	return cost;
+}
 void Train::Tick()
 {
 	if (_age_cargo_skip_counter == 0) this->cargo.AgeCargo();
 	this->tick_counter++;
 #define MAX_ACCEPTABLE_DEPOT_DIST 16
 static void CheckIfTrainNeedsService(Vehicle *v)
 {
-	if (_patches.servint_trains == 0)                   return;
+	if (_patches.servint_trains == 0 || !VehicleNeedsService(v)) return;
-	if (!VehicleNeedsService(v))                        return;
+	if (v->IsInDepot()) {
-	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;
 	}
 	TrainFindDepotData tfdd = FindClosestTrainDepot(v, MAX_ACCEPTABLE_DEPOT_DIST);
 			v->current_order.dest != depot->index &&
 			!CHANCE16(3, 16)) {
 		return;
 	}
-	if (v->current_order.type == OT_LOADING) v->LeaveStation();
 	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);
 }
-Money GetTrainRunningCost(const Vehicle *v)
-{
-	Money cost = 0;
-	do {
-		const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
-		byte cost_factor = GetVehicleProperty(v, 0x0D, rvi->running_cost_base);
-		if (cost_factor == 0) continue;
-		cost += cost_factor * _price.running_rail[rvi->running_cost_class];
-	} while ((v = GetNextVehicle(v)) != NULL);
-	return cost;
-}
 void OnNewDay_Train(Vehicle *v)
 {
 	if ((++v->day_counter & 7) == 0) DecreaseVehicleValue(v);
 	if (IsFrontEngine(v)) {
 			if (tile != 0) v->dest_tile = tile;
 		}
 		if ((v->vehstatus & VS_STOPPED) == 0) {
 			/* running costs */
-			CommandCost cost(GetTrainRunningCost(v) / 364);
+			CommandCost cost(v->GetRunningCost() / 364);
 			v->profit_this_year -= cost.GetCost() >> 8;
 			SET_EXPENSES_TYPE(EXPENSES_TRAIN_RUN);
 			SubtractMoneyFromPlayerFract(v->owner, cost);
 						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));
+					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++;

branch	noai
changeset 9701	d1ac22c62f64
parent 9694	e72987579514
child 9703	d2a6acdbd665