openttd-ottdgrfs: comparison src/station

equal deleted inserted replaced

-:eba00e1551eb
+:4f7e3408936b
 	}
 	return false;
 }
-RoadStop* GetRoadStopByTile(TileIndex tile, RoadStopType type)
+RoadStop *GetRoadStopByTile(TileIndex tile, RoadStopType type)
 {
-	const Station* st = GetStationByTile(tile);
+	const Station *st = GetStationByTile(tile);
 	for (RoadStop *rs = st->GetPrimaryRoadStop(type);; rs = rs->next) {
 		if (rs->xy == tile) return rs;
 		assert(rs->next != NULL);
 	}
 }
-static uint GetNumRoadStopsInStation(const Station* st, RoadStopType type)
+static uint GetNumRoadStopsInStation(const Station *st, RoadStopType type)
 {
 	uint num = 0;
 	assert(st != NULL);
 	for (const RoadStop *rs = st->GetPrimaryRoadStop(type); rs != NULL; rs = rs->next) {
 /** Calculate the radius of the station. Basicly it is the biggest
 *  radius that is available within the station
 * @param st Station to query
 * @return the so calculated radius
 */
-static uint FindCatchmentRadius(const Station* st)
+static uint FindCatchmentRadius(const Station *st)
 {
 	uint ret = CA_NONE;
 	if (st->bus_stops   != NULL) ret = max<uint>(ret, CA_BUS);
 	if (st->truck_stops != NULL) ret = max<uint>(ret, CA_TRUCK);
 	return ret;
 }
 #define CHECK_STATIONS_ERR ((Station*)-1)
-static Station* GetStationAround(TileIndex tile, int w, int h, StationID closest_station)
+static Station *GetStationAround(TileIndex tile, int w, int h, StationID closest_station)
 {
 	/* check around to see if there's any stations there */
 	BEGIN_TILE_LOOP(tile_cur, w + 2, h + 2, tile - TileDiffXY(1, 1))
 		if (IsTileType(tile_cur, MP_STATION)) {
 			StationID t = GetStationIndex(tile_cur);
 		1 << M(STR_SV_STNAME_DOCKS),            /* 3 */
 		0x1FF << M(STR_SV_STNAME_BUOY_1),       /* 4 */
 		1 << M(STR_SV_STNAME_HELIPORT),         /* 5 */
 	};
-	Town *t = st->town;
+	const Town *t = st->town;
-	uint32 free_names = (uint32)-1;
+	uint32 free_names = UINT32_MAX;
-	int found;
-	unsigned long tmp;
 	{
-		Station *s;
+		const Station *s;
 		FOR_ALL_STATIONS(s) {
 			if (s != st && s->town == t) {
 				uint str = M(s->string_id);
 				if (str <= 0x20) {
-					if (str == M(STR_SV_STNAME_FOREST))
+					if (str == M(STR_SV_STNAME_FOREST)) {
 						str = M(STR_SV_STNAME_WOODS);
+					}
 					ClrBit(free_names, str);
 				}
 			}
 		}
 	}
 	/* check default names */
-	tmp = free_names & _gen_station_name_bits[flag];
+	uint32 tmp = free_names & _gen_station_name_bits[flag];
+	int found;
 	if (tmp != 0) {
 		found = FindFirstBit(tmp);
 		goto done;
 	}
 	st->string_id = found + STR_SV_STNAME;
 	return true;
 }
 #undef M
-static Station* GetClosestStationFromTile(TileIndex tile)
+static Station *GetClosestStationFromTile(TileIndex tile)
 {
 	uint threshold = 8;
-	Station* best_station = NULL;
+	Station *best_station = NULL;
-	Station* st;
+	Station *st;
 	FOR_ALL_STATIONS(st) {
 		if (st->facilities == 0 && st->owner == _current_player) {
 			uint cur_dist = DistanceManhattan(tile, st->xy);
 }
 /** Update the virtual coords needed to draw the station sign for all stations. */
 void UpdateAllStationVirtCoord()
 {
-	Station* st;
+	Station *st;
 	FOR_ALL_STATIONS(st) {
 		UpdateStationVirtCoord(st);
 	}
 }
 	uint min_y;
 	uint max_x;
 	uint max_y;
 };
-static inline void MergePoint(ottd_Rectangle* rect, TileIndex tile)
+static inline void MergePoint(ottd_Rectangle *rect, TileIndex tile)
 {
 	uint x = TileX(tile);
 	uint y = TileY(tile);
 	if (rect->min_x > x) rect->min_x = x;
 	uint old_acc = GetAcceptanceMask(st);
 	/* Put all the tiles that span an area in the table. */
 	if (st->train_tile != 0) {
 		MergePoint(&rect, st->train_tile);
-		MergePoint(&rect,
+		MergePoint(&rect, st->train_tile + TileDiffXY(st->trainst_w - 1, st->trainst_h - 1));
-			st->train_tile + TileDiffXY(st->trainst_w - 1, st->trainst_h - 1)
-		);
 	}
 	if (st->airport_tile != 0) {
-		const AirportFTAClass* afc = st->Airport();
+		const AirportFTAClass *afc = st->Airport();
 		MergePoint(&rect, st->airport_tile);
-		MergePoint(&rect,
+		MergePoint(&rect, st->airport_tile + TileDiffXY(afc->size_x - 1, afc->size_y - 1));
-			st->airport_tile + TileDiffXY(afc->size_x - 1, afc->size_y - 1)
-		);
 	}
 	if (st->dock_tile != 0) MergePoint(&rect, st->dock_tile);
 	for (const RoadStop *rs = st->bus_stops; rs != NULL; rs = rs->next) {
 		uint amt = min(accepts[i], 15);
 		/* Make sure the station can accept the goods type. */
 		bool is_passengers = IsCargoInClass(i, CC_PASSENGERS);
 		if ((!is_passengers && !(st->facilities & (byte)~FACIL_BUS_STOP)) ||
-				(is_passengers && !(st->facilities & (byte)~FACIL_TRUCK_STOP)))
+				(is_passengers && !(st->facilities & (byte)~FACIL_TRUCK_STOP))) {
 			amt = 0;
+		}
 		SB(st->goods[i].acceptance_pickup, GoodsEntry::ACCEPTANCE, 1, amt >= 8);
 	}
 	/* Only show a message in case the acceptance was actually changed. */
 	uint new_acc = GetAcceptanceMask(st);
-	if (old_acc == new_acc)
+	if (old_acc == new_acc) return;
-		return;
 	/* show a message to report that the acceptance was changed? */
 	if (show_msg && st->owner == _local_player && st->facilities) {
 		/* List of accept and reject strings for different number of
 		 * cargo types */
 	} END_TILE_LOOP(tile_cur, w, h, tile)
 	return cost;
 }
-static bool CanExpandRailroadStation(const Station* st, uint* fin, Axis axis)
+static bool CanExpandRailroadStation(const Station *st, uint *fin, Axis axis)
 {
 	uint curw = st->trainst_w;
 	uint curh = st->trainst_h;
 	TileIndex tile = fin[0];
 	uint w = fin[1];
 * - p2 = (bit  8-15) - custom station class
 * - p2 = (bit 16-23) - custom station id
 */
 CommandCost CmdBuildRailroadStation(TileIndex tile_org, uint32 flags, uint32 p1, uint32 p2)
 {
-	int w_org, h_org;
-	CommandCost ret;
 	/* Does the authority allow this? */
 	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile_org)) return CMD_ERROR;
 	if (!ValParamRailtype((RailType)(p2 & 0xF))) return CMD_ERROR;
 	/* unpack parameters */
 	Axis axis = Extract<Axis, 0>(p1);
 	uint numtracks = GB(p1,  8, 8);
 	uint plat_len  = GB(p1, 16, 8);
+	int w_org, h_org;
 	if (axis == AXIS_X) {
 		w_org = plat_len;
 		h_org = numtracks;
 	} else {
 		h_org = plat_len;
 	/* Make sure the area below consists of clear tiles. (OR tiles belonging to a certain rail station) */
 	StationID est = INVALID_STATION;
 	/* If DC_EXEC is in flag, do not want to pass it to CheckFlatLandBelow, because of a nice bug
 	 * for detail info, see:
 	 * https://sourceforge.net/tracker/index.php?func=detail&aid=1029064&group_id=103924&atid=636365 */
-	ret = CheckFlatLandBelow(tile_org, w_org, h_org, flags & ~DC_EXEC, 5 << axis, _patches.nonuniform_stations ? &est : NULL);
+	CommandCost ret = CheckFlatLandBelow(tile_org, w_org, h_org, flags & ~DC_EXEC, 5 << axis, _patches.nonuniform_stations ? &est : NULL);
 	if (CmdFailed(ret)) return ret;
 	CommandCost cost(EXPENSES_CONSTRUCTION, ret.GetCost() + (numtracks * _price.train_station_track + _price.train_station_length) * plat_len);
 	Station *st = NULL;
 	bool check_surrounding = true;
 static CommandCost RemoveRailroadStation(Station *st, TileIndex tile, uint32 flags)
 {
 	/* if there is flooding and non-uniform stations are enabled, remove platforms tile by tile */
-	if (_current_player == OWNER_WATER && _patches.nonuniform_stations)
+	if (_current_player == OWNER_WATER && _patches.nonuniform_stations) {
 		return DoCommand(tile, 0, 0, DC_EXEC, CMD_REMOVE_FROM_RAILROAD_STATION);
+	}
 	/* Current player owns the station? */
-	if (_current_player != OWNER_WATER && !CheckOwnership(st->owner))
+	if (_current_player != OWNER_WATER && !CheckOwnership(st->owner)) return CMD_ERROR;
-		return CMD_ERROR;
 	/* determine width and height of platforms */
 	tile = st->train_tile;
 	int w = st->trainst_w;
 	int h = st->trainst_h;
 /**
 * @param truck_station Determines whether a stop is ROADSTOP_BUS or ROADSTOP_TRUCK
 * @param st The Station to do the whole procedure for
 * @return a pointer to where to link a new RoadStop*
 */
-static RoadStop **FindRoadStopSpot(bool truck_station, Station* st)
+static RoadStop **FindRoadStopSpot(bool truck_station, Station *st)
 {
 	RoadStop **primary_stop = (truck_station) ? &st->truck_stops : &st->bus_stops;
 	if (*primary_stop == NULL) {
 		/* we have no roadstop of the type yet, so write a "primary stop" */
 	/* Road bits in the wrong direction */
 	if (build_over_road && (GetAllRoadBits(tile) & ((Axis)p1 == AXIS_X ? ROAD_Y : ROAD_X)) != 0) return_cmd_error(STR_DRIVE_THROUGH_ERROR_DIRECTION);
 	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile)) return CMD_ERROR;
-	CommandCost cost;
 	/* Not allowed to build over this road */
 	if (build_over_road) {
 		if (IsTileOwner(tile, OWNER_TOWN) && !_patches.road_stop_on_town_road) return_cmd_error(STR_DRIVE_THROUGH_ERROR_ON_TOWN_ROAD);
 		RoadTypes cur_rts = GetRoadTypes(tile);
 		if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 		/* Do not remove roadtypes! */
 		rts |= cur_rts;
 	}
-	cost = CheckFlatLandBelow(tile, 1, 1, flags, is_drive_through ? 5 << p1 : 1 << p1, NULL, !build_over_road);
+	CommandCost cost = CheckFlatLandBelow(tile, 1, 1, flags, is_drive_through ? 5 << p1 : 1 << p1, NULL, !build_over_road);
 	if (CmdFailed(cost)) return cost;
 	Station *st = NULL;
 	if (!_patches.adjacent_stations || !HasBit(p2, 5)) {
 	bool airport_upgrade = true;
 	/* Check if a valid, buildable airport was chosen for construction */
 	if (p1 > lengthof(_airport_sections) || !HasBit(GetValidAirports(), p1)) return CMD_ERROR;
-	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile))
+	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile)) {
 		return CMD_ERROR;
+	}
-	Town *t = ClosestTownFromTile(tile, (uint)-1);
+	Town *t = ClosestTownFromTile(tile, UINT_MAX);
 	/* Check if local auth refuses a new airport */
 	{
 		uint num = 0;
 		const Station *st;
 		FOR_ALL_STATIONS(st) {
-			if (st->town == t && st->facilities&FACIL_AIRPORT && st->airport_type != AT_OILRIG)
+			if (st->town == t && st->facilities & FACIL_AIRPORT && st->airport_type != AT_OILRIG) num++;
-				num++;
 		}
 		if (num >= 2) {
 			SetDParam(0, t->index);
 			return_cmd_error(STR_2035_LOCAL_AUTHORITY_REFUSES);
 		}
 	/* In case of new station if DC_EXEC is NOT set we still need to create the station
 	 * to test if everything is OK. In this case we need to delete it before return. */
 	AutoPtrT<Station> st_auto_delete;
 	if (st != NULL) {
-		if (st->owner != _current_player)
+		if (st->owner != _current_player) {
 			return_cmd_error(STR_3009_TOO_CLOSE_TO_ANOTHER_STATION);
+		}
 		if (!st->rect.BeforeAddRect(tile, w, h, StationRect::ADD_TEST)) return CMD_ERROR;
-		if (st->airport_tile != 0)
+		if (st->airport_tile != 0) {
 			return_cmd_error(STR_300D_TOO_CLOSE_TO_ANOTHER_AIRPORT);
+		}
 	} else {
 		airport_upgrade = false;
 		/* allocate and initialize new station */
 		st = new Station(tile);
 	return cost;
 }
 static CommandCost RemoveAirport(Station *st, uint32 flags)
 {
-	if (_current_player != OWNER_WATER && !CheckOwnership(st->owner))
+	if (_current_player != OWNER_WATER && !CheckOwnership(st->owner)) {
 		return CMD_ERROR;
+	}
 	TileIndex tile = st->airport_tile;
 	const AirportFTAClass *afc = st->Airport();
 	int w = afc->size_x;
 	int h = afc->size_y;
 	CommandCost cost(EXPENSES_CONSTRUCTION, w * h * _price.remove_airport);
-	Vehicle *v;
+	const Vehicle *v;
 	FOR_ALL_VEHICLES(v) {
 		if (!(v->type == VEH_AIRCRAFT && IsNormalAircraft(v))) continue;
 		if (v->u.air.targetairport == st->index && v->u.air.state != FLYING) return CMD_ERROR;
 	}
 }
 static CommandCost RemoveBuoy(Station *st, uint32 flags)
 {
 	/* XXX: strange stuff */
-	if (!IsValidPlayer(_current_player))  return_cmd_error(INVALID_STRING_ID);
+	if (!IsValidPlayer(_current_player)) return_cmd_error(INVALID_STRING_ID);
 	TileIndex tile = st->dock_tile;
 	if (HasStationInUse(st->index, INVALID_PLAYER)) return_cmd_error(STR_BUOY_IS_IN_USE);
 	/* remove the buoy if there is a ship on tile when company goes bankrupt... */
 * @param p1 (bit 0) - allow docks directly adjacent to other docks.
 * @param p2 unused
 */
 CommandCost CmdBuildDock(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	CommandCost cost;
 	DiagDirection direction = GetInclinedSlopeDirection(GetTileSlope(tile, NULL));
 	if (direction == INVALID_DIAGDIR) return_cmd_error(STR_304B_SITE_UNSUITABLE);
 	direction = ReverseDiagDir(direction);
 	/* Docks cannot be placed on rapids */
 	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile)) return CMD_ERROR;
 	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
-	cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
+	if (CmdFailed(DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR))) return CMD_ERROR;
-	if (CmdFailed(cost)) return CMD_ERROR;
 	TileIndex tile_cur = tile + TileOffsByDiagDir(direction);
 	if (!IsTileType(tile_cur, MP_WATER) || GetTileSlope(tile_cur, NULL) != SLOPE_FLAT) {
 		return_cmd_error(STR_304B_SITE_UNSUITABLE);
 	if (MayHaveBridgeAbove(tile_cur) && IsBridgeAbove(tile_cur)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
 	/* Get the water class of the water tile before it is cleared.*/
 	WaterClass wc = GetWaterClass(tile_cur);
-	cost = DoCommand(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
+	if (CmdFailed(DoCommand(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR))) return CMD_ERROR;
-	if (CmdFailed(cost)) return CMD_ERROR;
 	tile_cur += TileOffsByDiagDir(direction);
 	if (!IsTileType(tile_cur, MP_WATER) || GetTileSlope(tile_cur, NULL) != SLOPE_FLAT) {
 		return_cmd_error(STR_304B_SITE_UNSUITABLE);
 	}
 	/* In case of new station if DC_EXEC is NOT set we still need to create the station
 	 * to test if everything is OK. In this case we need to delete it before return. */
 	AutoPtrT<Station> st_auto_delete;
 	if (st != NULL) {
-		if (st->owner != _current_player)
+		if (st->owner != _current_player) {
 			return_cmd_error(STR_3009_TOO_CLOSE_TO_ANOTHER_STATION);
+		}
 		if (!st->rect.BeforeAddRect(tile, _dock_w_chk[direction], _dock_h_chk[direction], StationRect::ADD_TEST)) return CMD_ERROR;
 		if (st->dock_tile != 0) return_cmd_error(STR_304C_TOO_CLOSE_TO_ANOTHER_DOCK);
 	} else {
 		InvalidateWindow(WC_STATION_LIST, st->owner);
 		InvalidateWindowWidget(WC_STATION_VIEW, st->index, SVW_SHIPS);
 		/* success, so don't delete the new station */
 		st_auto_delete.Detach();
 	}
 	return CommandCost(EXPENSES_CONSTRUCTION, _price.build_dock);
 }
 static CommandCost RemoveDock(Station *st, uint32 flags)
 {
 	if (IsCustomStationSpecIndex(ti->tile)) {
 		/* look for customization */
 		st = GetStationByTile(ti->tile);
 		statspec = st->speclist[GetCustomStationSpecIndex(ti->tile)].spec;
-		//debug("Cust-o-mized %p", statspec);
 		if (statspec != NULL) {
 			uint tile = GetStationGfx(ti->tile);
 			relocation = GetCustomStationRelocation(statspec, st, ti->tile);
 	if (st->facilities == 0 && ++st->delete_ctr >= 8) delete st;
 }
-static inline void byte_inc_sat(byte *p) { byte b = *p + 1; if (b != 0) *p = b; }
+static inline void byte_inc_sat(byte *p)
+{
+	byte b = *p + 1;
+	if (b != 0) *p = b;
+}
 static void UpdateStationRating(Station *st)
 {
 	bool waiting_changed = false;
 	FOR_ALL_STATIONS(st) StationHandleSmallTick(st);
 }
 void StationMonthlyLoop()
 {
+	/* not used */
 }
 void ModifyStationRatingAround(TileIndex tile, PlayerID owner, int amount, uint radius)
 {
 	FOR_ALL_STATIONS(st) {
 		if (st->owner == owner &&
 				DistanceManhattan(tile, st->xy) <= radius) {
 			for (CargoID i = 0; i < NUM_CARGO; i++) {
-				GoodsEntry* ge = &st->goods[i];
+				GoodsEntry *ge = &st->goods[i];
 				if (ge->acceptance_pickup != 0) {
 					ge->rating = Clamp(ge->rating + amount, 0, 255);
 				}
 			}
 	return CommandCost();
 }
 /**
 * Find all (non-buoy) stations around an industry tile
 *
 * @param tile: Center tile to search from
 * @param w: Width of the center
 * @param h: Height of the center
 *
 * @return: Set of found stations
 */
 StationSet FindStationsAroundIndustryTile(TileIndex tile, int w, int h)
 {
 	StationSet station_set;
 	int w_prod; // width and height of the "producer" of the cargo
 	UpdateStationAcceptance(st, false);
 }
 void DeleteOilRig(TileIndex tile)
 {
-	Station* st = GetStationByTile(tile);
+	Station *st = GetStationByTile(tile);
 	MakeWater(tile);
 	st->dock_tile = 0;
 	st->airport_tile = 0;
 static void ChangeTileOwner_Station(TileIndex tile, PlayerID old_player, PlayerID new_player)
 {
 	if (!IsTileOwner(tile, old_player)) return;
 	if (new_player != PLAYER_SPECTATOR) {
-		Station* st = GetStationByTile(tile);
+		Station *st = GetStationByTile(tile);
 		SetTileOwner(tile, new_player);
 		if (!IsBuoy(tile)) st->owner = new_player; // do not set st->owner for buoys
 		RebuildStationLists();
 		InvalidateWindowClasses(WC_STATION_LIST);
 	/* Clean the roadstop pool and create 1 block in it */
 	_RoadStop_pool.CleanPool();
 	_RoadStop_pool.AddBlockToPool();
 	_station_tick_ctr = 0;
 }
 void AfterLoadStations()
 {
 };
 static const SaveLoad _station_desc[] = {
 	SLE_CONDVAR(Station, xy,                         SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
 	SLE_CONDVAR(Station, xy,                         SLE_UINT32,                  6, SL_MAX_VERSION),
-	SLE_CONDNULL(4, 0, 5), // bus/lorry tile
+	SLE_CONDNULL(4, 0, 5),  ///< bus/lorry tile
 	SLE_CONDVAR(Station, train_tile,                 SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
 	SLE_CONDVAR(Station, train_tile,                 SLE_UINT32,                  6, SL_MAX_VERSION),
 	SLE_CONDVAR(Station, airport_tile,               SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
 	SLE_CONDVAR(Station, airport_tile,               SLE_UINT32,                  6, SL_MAX_VERSION),
 	SLE_CONDVAR(Station, dock_tile,                  SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
 	SLE_CONDVAR(Station, dock_tile,                  SLE_UINT32,                  6, SL_MAX_VERSION),
 	    SLE_REF(Station, town,                       REF_TOWN),
 	    SLE_VAR(Station, trainst_w,                  SLE_UINT8),
 	SLE_CONDVAR(Station, trainst_h,                  SLE_UINT8,                   2, SL_MAX_VERSION),
-	/* alpha_order was stored here in savegame format 0 - 3 */
+	SLE_CONDNULL(1, 0, 3),  ///< alpha_order
-	SLE_CONDNULL(1, 0, 3),
 	    SLE_VAR(Station, string_id,                  SLE_STRINGID),
 	SLE_CONDSTR(Station, name,                       SLE_STR, 0,                 84, SL_MAX_VERSION),
 	    SLE_VAR(Station, had_vehicle_of_type,        SLE_UINT16),
 	    SLE_VAR(Station, delete_ctr,                 SLE_UINT8),
 	    SLE_VAR(Station, owner,                      SLE_UINT8),
 	    SLE_VAR(Station, facilities,                 SLE_UINT8),
 	    SLE_VAR(Station, airport_type,               SLE_UINT8),
-	SLE_CONDNULL(2, 0, 5), // Truck/bus stop status
+	SLE_CONDNULL(2, 0, 5),  ///< Truck/bus stop status
-	SLE_CONDNULL(1, 0, 4), // Blocked months
+	SLE_CONDNULL(1, 0, 4),  ///< Blocked months
 	SLE_CONDVAR(Station, airport_flags,              SLE_VAR_U64 | SLE_FILE_U16,  0,  2),
 	SLE_CONDVAR(Station, airport_flags,              SLE_VAR_U64 | SLE_FILE_U32,  3, 45),
 	SLE_CONDVAR(Station, airport_flags,              SLE_UINT64,                 46, SL_MAX_VERSION),
-	SLE_CONDNULL(2, 0, 25), /* Ex last-vehicle */
+	SLE_CONDNULL(2, 0, 25), ///< last-vehicle
 	SLE_CONDVAR(Station, last_vehicle_type,          SLE_UINT8,                  26, SL_MAX_VERSION),
-	/* Was custom station class and id */
+	SLE_CONDNULL(2, 3, 25), ///< custom station class and id
-	SLE_CONDNULL(2, 3, 25),
 	SLE_CONDVAR(Station, build_date,                 SLE_FILE_U16 | SLE_VAR_I32,  3, 30),
 	SLE_CONDVAR(Station, build_date,                 SLE_INT32,                  31, SL_MAX_VERSION),
 	SLE_CONDREF(Station, bus_stops,                  REF_ROADSTOPS,               6, SL_MAX_VERSION),
 	SLE_CONDREF(Station, truck_stops,                REF_ROADSTOPS,               6, SL_MAX_VERSION),

changeset 10224	4f7e3408936b
parent 10222	b6919c94cc77
child 10229	fba3f9fa44d7