openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:4bf29d14edba
+:c30fe89622df
 */
 void TrainConsistChanged(Vehicle* v)
 {
 	uint16 max_speed = 0xFFFF;
-	assert(v->type == VEH_Train);
+	assert(v->type == VEH_TRAIN);
 	assert(IsFrontEngine(v) || IsFreeWagon(v));
 	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;
 static bool TrainShouldStop(const Vehicle* v, TileIndex tile)
 {
 	const Order* o = &v->current_order;
 	StationID sid = GetStationIndex(tile);
-	assert(v->type == VEH_Train);
+	assert(v->type == VEH_TRAIN);
 	//When does a train drive through a station
 	//first we deal with the "new nonstop handling"
 	if (_patches.new_nonstop && o->flags & OF_NON_STOP && sid == o->dest) {
 		return false;
 	}
 		u->cargo_cap = rvi_artic->capacity;
 		u->max_speed = 0;
 		u->max_age = 0;
 		u->engine_type = engine_type;
 		u->value = 0;
-		u->type = VEH_Train;
+		u->type = VEH_TRAIN;
 		u->subtype = 0;
 		SetArticulatedPart(u);
 		u->cur_image = 0xAC2;
 		u->random_bits = VehicleRandomBits();
 			Vehicle *u = NULL;
 			Vehicle *w;
 			FOR_ALL_VEHICLES(w) {
-				if (w->type == VEH_Train && w->tile == tile &&
+				if (w->type == VEH_TRAIN && w->tile == tile &&
 				    IsFreeWagon(w) && w->engine_type == engine) {
 					u = GetLastVehicleInChain(w);
 					break;
 				}
 			}
 //			v->day_counter = 0;
 			v->u.rail.railtype = rvi->railtype;
 			v->build_year = _cur_year;
-			v->type = VEH_Train;
+			v->type = VEH_TRAIN;
 			v->cur_image = 0xAC2;
 			v->random_bits = VehicleRandomBits();
 			AddArticulatedParts(vl);
 			VehiclePositionChanged(v);
 			TrainConsistChanged(GetFirstVehicleInChain(v));
 			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 			if (IsLocalPlayer()) {
-				InvalidateAutoreplaceWindow(VEH_Train); // updates the replace Train window
+				InvalidateAutoreplaceWindow(VEH_TRAIN); // updates the replace Train window
 			}
 			GetPlayer(_current_player)->num_engines[engine]++;
 		}
 	}
 static void NormalizeTrainVehInDepot(const Vehicle* u)
 {
 	const Vehicle* v;
 	FOR_ALL_VEHICLES(v) {
-		if (v->type == VEH_Train && IsFreeWagon(v) &&
+		if (v->type == VEH_TRAIN && IsFreeWagon(v) &&
 				v->tile == u->tile &&
 				v->u.rail.track == TRACK_BIT_DEPOT) {
 			if (CmdFailed(DoCommand(0, v->index | (u->index << 16), 1, DC_EXEC,
 					CMD_MOVE_RAIL_VEHICLE)))
 				break;
 	if (building) v->next = u;
 	u->engine_type = v->engine_type;
 	u->build_year = v->build_year;
 	if (building) v->value >>= 1;
 	u->value = v->value;
-	u->type = VEH_Train;
+	u->type = VEH_TRAIN;
 	u->cur_image = 0xAC2;
 	u->random_bits = VehicleRandomBits();
 	VehiclePositionChanged(u);
 }
 *           bit 1 prevents any free cars from being added to the train
 */
 int32 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_ENGINE_NOT_BUILDABLE);
+	if (!IsEngineBuildable(p1, VEH_TRAIN, _current_player)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
 	/* Check if the train is actually being built in a depot belonging
 	 * to the player. Doesn't matter if only the cost is queried */
 	if (!(flags & DC_QUERY_COST)) {
 		if (!IsTileDepotType(tile, TRANSPORT_RAIL)) return CMD_ERROR;
 		if (!AllocateVehicles(vl, num_vehicles))
 			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
 		Vehicle *v = vl[0];
-		UnitID 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);
 			_new_vehicle_id = v->index;
 			v->service_interval = _patches.servint_trains;
 			v->date_of_last_service = _date;
 			v->build_year = _cur_year;
-			v->type = VEH_Train;
+			v->type = VEH_TRAIN;
 			v->cur_image = 0xAC2;
 			v->random_bits = VehicleRandomBits();
 			v->vehicle_flags = 0;
 			if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SETBIT(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
 			InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 			RebuildVehicleLists();
 			InvalidateWindow(WC_COMPANY, v->owner);
 			if (IsLocalPlayer())
-				InvalidateAutoreplaceWindow(VEH_Train); // updates the replace Train window
+				InvalidateAutoreplaceWindow(VEH_TRAIN); // updates the replace Train window
 			GetPlayer(_current_player)->num_engines[p1]++;
 		}
 	}
 	Vehicle *dst;
 	EngineID eng = src->engine_type;
 	TileIndex tile = src->tile;
 	FOR_ALL_VEHICLES(dst) {
-		if (dst->type == VEH_Train && IsFreeWagon(dst) && dst->tile == tile) {
+		if (dst->type == VEH_TRAIN && IsFreeWagon(dst) && dst->tile == tile) {
 			// check so all vehicles in the line have the same engine.
 			Vehicle *v = dst;
 			while (v->engine_type == eng) {
 				v = v->next;
 	if (!IsValidVehicleID(s)) return CMD_ERROR;
 	Vehicle *src = GetVehicle(s);
-	if (src->type != VEH_Train || !CheckOwnership(src->owner)) return CMD_ERROR;
+	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);
-		if (dst->type != VEH_Train || !CheckOwnership(dst->owner)) return CMD_ERROR;
+		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);
 	if (dst != NULL) {
 		}
 	}
 	// moving a loco to a new line?, then we need to assign a unitnumber.
 	if (dst == NULL && !IsFrontEngine(src) && IsTrainEngine(src)) {
-		UnitID unit_num = GetFreeUnitNumber(VEH_Train);
+		UnitID unit_num = GetFreeUnitNumber(VEH_TRAIN);
 		if (unit_num > _patches.max_trains)
 			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
 		if (flags & DC_EXEC) src->unitnumber = unit_num;
 	}
 {
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
-	if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+	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. */
 	uint16 callback = GetVehicleCallback(CBID_VEHICLE_START_STOP_CHECK, 0, 0, v->engine_type, v);
 	if (callback != CALLBACK_FAILED && callback != 0xFF) {
 {
 	if (!IsValidVehicleID(p1) || p2 > 2) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
-	if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	while (IsArticulatedPart(v)) v = GetPrevVehicleInChain(v);
 	Vehicle *first = GetFirstVehicleInChain(v);
 }
 /* Check if the vehicle is a train and is on the tile we are testing */
 static void *TestTrainOnCrossing(Vehicle *v, void *data)
 {
-	if (v->tile != *(const TileIndex*)data || v->type != VEH_Train) return NULL;
+	if (v->tile != *(const TileIndex*)data || v->type != VEH_TRAIN) return NULL;
 	return v;
 }
 static void DisableTrainCrossing(TileIndex tile)
 {
 {
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
-	if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (p2) {
 		// turn a single unit around
 		if (IsMultiheaded(v) || HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_ARTIC_ENGINE)) {
 {
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
-	if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (flags & DC_EXEC) v->u.rail.force_proceed = 0x50;
 	return 0;
 }
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
-	if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+	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;
 	if (flags & DC_EXEC) TrainConsistChanged(GetFirstVehicleInChain(GetVehicle(p1)));
 	return cost;
 }
-typedef struct TrainFindDepotData {
+struct TrainFindDepotData {
 	uint best_length;
 	TileIndex tile;
 	PlayerID owner;
 	/**
 	 * true if reversing is necessary for the train to get to this depot
 	 * This value is unused when new depot finding and NPF are both disabled
 	 */
 	bool reverse;
-} TrainFindDepotData;
+};
 static bool NtpCallbFindDepot(TileIndex tile, TrainFindDepotData *tfdd, int track, uint length)
 {
 	if (IsTileType(tile, MP_RAILWAY) &&
 			IsTileOwner(tile, tfdd->owner) &&
 int32 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);
+		return SendAllVehiclesToDepot(VEH_TRAIN, flags, p2 & DEPOT_SERVICE, _current_player, (p2 & VLW_MASK), p1);
 	}
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
-	if (v->type != VEH_Train || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
 	if (v->current_order.type == OT_GOTO_DEPOT) {
 		if (!!(p2 & DEPOT_SERVICE) == HASBIT(v->current_order.flags, OFB_HALT_IN_DEPOT)) {
 	return 0;
 }
-void OnTick_Train(void)
+void OnTick_Train()
 {
 	_age_cargo_skip_counter = (_age_cargo_skip_counter == 0) ? 184 : (_age_cargo_skip_counter - 1);
 }
 static const int8 _vehicle_smoke_pos[8] = {
 	return false;
 }
 /* Check for station tiles */
-typedef struct TrainTrackFollowerData {
+struct TrainTrackFollowerData {
 	TileIndex dest_coords;
 	StationID station_index; // station index we're heading for
 	uint best_bird_dist;
 	uint best_track_dist;
 	TrackdirByte best_track;
-} TrainTrackFollowerData;
+};
 static bool NtpCallbFindStation(TileIndex tile, TrainTrackFollowerData *ttfd, Trackdir track, uint length)
 {
 	// heading for nowhere?
 	if (ttfd->dest_coords == 0) return false;
 	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.Free();
-		v->current_order.flags = 0;
 		v->dest_tile = 0;
 		return false;
 	}
 	// If it is unchanged, keep it.
 			!IsFrontEngine(v) ||
 			HASBIT(v->u.rail.compatible_railtypes, GetRailType(tile))
 		);
 }
-typedef struct {
+struct RailtypeSlowdownParams {
 	byte small_turn, large_turn;
 	byte z_up; // fraction to remove when moving up
 	byte z_down; // fraction to remove when moving down
-} RailtypeSlowdownParams;
+};
 static const RailtypeSlowdownParams _railtype_slowdown[] = {
 	// normal accel
 	{256 / 4, 256 / 2, 256 / 4, 2}, // normal
 	{256 / 4, 256 / 2, 256 / 4, 2}, // electrified
 		UpdateSignalsOnSegment(tile, _otherside_signal_directions[i]);
 	}
 }
-typedef struct TrainCollideChecker {
+struct TrainCollideChecker {
 	const Vehicle *v;
 	const Vehicle *v_skip;
-} TrainCollideChecker;
+};
 static void *FindTrainCollideEnum(Vehicle *v, void *data)
 {
 	const TrainCollideChecker* tcc = (TrainCollideChecker*)data;
 	if (v != tcc->v &&
 			v != tcc->v_skip &&
-			v->type == VEH_Train &&
+			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) {
 		return v;
 	ModifyStationRatingAround(v->tile, v->owner, -160, 30);
 	SndPlayVehicleFx(SND_13_BIG_CRASH, v);
 }
-typedef struct VehicleAtSignalData {
+struct VehicleAtSignalData {
 	TileIndex tile;
 	Direction direction;
-} VehicleAtSignalData;
+};
 static void *CheckVehicleAtSignal(Vehicle *v, void *data)
 {
 	const VehicleAtSignalData* vasd = (VehicleAtSignalData*)data;
-	if (v->type == VEH_Train && IsFrontEngine(v) && v->tile == vasd->tile) {
+	if (v->type == VEH_TRAIN && IsFrontEngine(v) && v->tile == vasd->tile) {
 		DirDiff diff = ChangeDirDiff(DirDifference(v->direction, vasd->direction), DIRDIFF_90RIGHT);
 		if (diff == DIRDIFF_90RIGHT || (v->cur_speed <= 5 && diff <= DIRDIFF_REVERSE)) return v;
 	}
 	return NULL;
 						TrainEnterStation(v, r >> VETS_STATION_ID_OFFSET);
 						return;
 					}
 					if (v->current_order.type == OT_LEAVESTATION) {
-						v->current_order.type = OT_NOTHING;
+						v->current_order.Free();
-						v->current_order.flags = 0;
 						InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 					}
 				}
 			} else {
 				/* A new tile is about to be entered. */
 	if (IsFrontEngine(v)) {
 		TrainLocoHandler(v, false);
 		// make sure vehicle wasn't deleted.
-		if (v->type == VEH_Train && IsFrontEngine(v))
+		if (v->type == VEH_TRAIN && IsFrontEngine(v))
 			TrainLocoHandler(v, true);
 	} else if (IsFreeWagon(v) && HASBITS(v->vehstatus, VS_CRASHED)) {
 		// Delete flooded standalone wagon
 		if (++v->u.rail.crash_anim_pos >= 4400)
 			DeleteVehicle(v);
 			InvalidateWindowClasses(WC_TRAINS_LIST);
 		}
 	}
 }
-void TrainsYearlyLoop(void)
+void TrainsYearlyLoop()
 {
 	Vehicle *v;
 	FOR_ALL_VEHICLES(v) {
-		if (v->type == VEH_Train && IsFrontEngine(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(
 		}
 	}
 }
-void InitializeTrains(void)
+void InitializeTrains()
 {
 	_age_cargo_skip_counter = 1;
 }
 /*
 * Link front and rear multiheaded engines to each other
 * This is done when loading a savegame
 */
-void ConnectMultiheadedTrains(void)
+void ConnectMultiheadedTrains()
 {
 	Vehicle *v;
 	FOR_ALL_VEHICLES(v) {
-		if (v->type == VEH_Train) {
+		if (v->type == VEH_TRAIN) {
 			v->u.rail.other_multiheaded_part = NULL;
 		}
 	}
 	FOR_ALL_VEHICLES(v) {
-		if (v->type == VEH_Train && IsFrontEngine(v)) {
+		if (v->type == VEH_TRAIN && IsFrontEngine(v)) {
 			Vehicle *u = v;
 			BEGIN_ENUM_WAGONS(u) {
 				if (u->u.rail.other_multiheaded_part != NULL) continue; // we already linked this one
 /*
 *  Converts all trains to the new subtype format introduced in savegame 16.2
 *  It also links multiheaded engines or make them forget they are multiheaded if no suitable partner is found
 */
-void ConvertOldMultiheadToNew(void)
+void ConvertOldMultiheadToNew()
 {
 	Vehicle *v;
 	FOR_ALL_VEHICLES(v) {
-		if (v->type == VEH_Train) {
+		if (v->type == VEH_TRAIN) {
 			SETBIT(v->subtype, 7); // indicates that it's the old format and needs to be converted in the next loop
 		}
 	}
 	FOR_ALL_VEHICLES(v) {
-		if (v->type == VEH_Train) {
+		if (v->type == VEH_TRAIN) {
 			if (HASBIT(v->subtype, 7) && ((v->subtype & ~0x80) == 0 || (v->subtype & ~0x80) == 4)) {
 				Vehicle *u = v;
 				BEGIN_ENUM_WAGONS(u) {
 					const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);

branch	cpp_gui
changeset 6298	c30fe89622df
parent 6285	187e3ef04cc9
child 6303	84c215fc8eb8