openttd-ottdgrfs: comparison src/build_vehicle

equal deleted inserted replaced

-:5a8b295aa345
+:4cc327ad39d5
 #include "table/sprites.h"
 #include "table/strings.h"
 #include "window.h"
 #include "gui.h"
 #include "vehicle.h"
+#include "articulated_vehicles.h"
 #include "gfx.h"
 #include "station.h"
 #include "command.h"
 #include "engine.h"
 #include "player.h"
 #include "vehicle_gui.h"
 #include "newgrf_engine.h"
 #include "date.h"
 #include "strings.h"
 #include "cargotype.h"
+#include "group.h"
+#include "road_map.h"
 enum BuildVehicleWidgets {
 	BUILD_VEHICLE_WIDGET_CLOSEBOX = 0,
 	BUILD_VEHICLE_WIDGET_CAPTION,
 	int r = ListPositionOfEngine(va) - ListPositionOfEngine(vb);
 	return _internal_sort_order ? -r : r;
 }
+static int CDECL TrainEngineCapacitySorter(const void *a, const void *b)
+{
+	int va = RailVehInfo(*(const EngineID*)a)->capacity;
+	int vb = RailVehInfo(*(const EngineID*)b)->capacity;
+	int r = va - vb;
+	if (r == 0) {
+		/* Use EngineID to sort instead since we want consistent sorting */
+		return EngineNumberSorter(a, b);
+	}
+	return _internal_sort_order ? -r : r;
+}
 static int CDECL TrainEnginesThenWagonsSorter(const void *a, const void *b)
 {
 	EngineID va = *(const EngineID*)a;
 	EngineID vb = *(const EngineID*)b;
 	int val_a = (RailVehInfo(va)->railveh_type == RAILVEH_WAGON ? 1 : 0);
 	if (r == 0) return EngineNumberSorter(a, b);
 	return _internal_sort_order ? -r : r;
 }
+static int CDECL RoadVehEngineCapacitySorter(const void *a, const void *b)
+{
+	int va = RoadVehInfo(*(const EngineID*)a)->capacity;
+	int vb = RoadVehInfo(*(const EngineID*)b)->capacity;
+	int r = va - vb;
+	if (r == 0) {
+		/* Use EngineID to sort instead since we want consistent sorting */
+		return EngineNumberSorter(a, b);
+	}
+	return _internal_sort_order ? -r : r;
+}
+static int CDECL ShipEngineCapacitySorter(const void *a, const void *b)
+{
+	int va = ShipVehInfo(*(const EngineID*)a)->capacity;
+	int vb = ShipVehInfo(*(const EngineID*)b)->capacity;
+	int r = va - vb;
+	if (r == 0) {
+		/* Use EngineID to sort instead since we want consistent sorting */
+		return EngineNumberSorter(a, b);
+	}
+	return _internal_sort_order ? -r : r;
+}
 /* Aircraft sorting functions */
 static int CDECL AircraftEngineCostSorter(const void *a, const void *b)
 {
 	const int va = AircraftVehInfo(*(const EngineID*)a)->base_cost;
 	return _internal_sort_order ? -r : r;
 }
 static int CDECL AircraftEngineCargoSorter(const void *a, const void *b)
 {
-	const int va = AircraftVehInfo(*(const EngineID*)a)->passenger_capacity;
+	int va = AircraftVehInfo(*(const EngineID*)a)->passenger_capacity;
-	const int vb = AircraftVehInfo(*(const EngineID*)b)->passenger_capacity;
+	int vb = AircraftVehInfo(*(const EngineID*)b)->passenger_capacity;
-	const int r = va - vb;
+	int r = va - vb;
 	if (r == 0) {
-		/* Use EngineID to sort instead since we want consistent sorting */
+		/* The planes has the same passenger capacity. Check mail capacity instead */
-		return EngineNumberSorter(a, b);
+		va = AircraftVehInfo(*(const EngineID*)a)->mail_capacity;
-	}
+		vb = AircraftVehInfo(*(const EngineID*)b)->mail_capacity;
-	return _internal_sort_order ? -r : r;
+		r = va - vb;
-}
+		if (r == 0) {
-static EngList_SortTypeFunction * const _sorter[][9] = {{
+			/* Use EngineID to sort instead since we want consistent sorting */
+			return EngineNumberSorter(a, b);
+		}
+	}
+	return _internal_sort_order ? -r : r;
+}
+static EngList_SortTypeFunction * const _sorter[][10] = {{
 	/* Trains */
 	&TrainEngineNumberSorter,
 	&TrainEngineCostSorter,
 	&TrainEngineSpeedSorter,
 	&TrainEnginePowerSorter,
 	&EngineIntroDateSorter,
 	&EngineNameSorter,
 	&TrainEngineRunningCostSorter,
 	&TrainEnginePowerVsRunningCostSorter,
 	&EngineReliabilitySorter,
-},{
+	&TrainEngineCapacitySorter,
+}, {
 	/* Road vehicles */
 	&EngineNumberSorter,
 	&EngineIntroDateSorter,
 	&EngineNameSorter,
 	&EngineReliabilitySorter,
-},{
+	&RoadVehEngineCapacitySorter,
+}, {
 	/* Ships */
 	&EngineNumberSorter,
 	&EngineIntroDateSorter,
 	&EngineNameSorter,
 	&EngineReliabilitySorter,
-},{
+	&ShipEngineCapacitySorter,
+}, {
 	/* Aircraft */
 	&EngineNumberSorter,
 	&AircraftEngineCostSorter,
 	&AircraftEngineSpeedSorter,
 	&EngineIntroDateSorter,
 	&AircraftEngineRunningCostSorter,
 	&EngineReliabilitySorter,
 	&AircraftEngineCargoSorter,
 }};
-static const StringID _sort_listing[][10] = {{
+static const StringID _sort_listing[][11] = {{
 	/* Trains */
 	STR_ENGINE_SORT_ENGINE_ID,
 	STR_ENGINE_SORT_COST,
 	STR_SORT_BY_MAX_SPEED,
 	STR_ENGINE_SORT_POWER,
 	STR_ENGINE_SORT_INTRO_DATE,
 	STR_SORT_BY_DROPDOWN_NAME,
 	STR_ENGINE_SORT_RUNNING_COST,
 	STR_ENGINE_SORT_POWER_VS_RUNNING_COST,
 	STR_SORT_BY_RELIABILITY,
+	STR_ENGINE_SORT_CARGO_CAPACITY,
 	INVALID_STRING_ID
-},{
+}, {
 	/* Road vehicles */
 	STR_ENGINE_SORT_ENGINE_ID,
 	STR_ENGINE_SORT_INTRO_DATE,
 	STR_SORT_BY_DROPDOWN_NAME,
 	STR_SORT_BY_RELIABILITY,
+	STR_ENGINE_SORT_CARGO_CAPACITY,
 	INVALID_STRING_ID
-},{
+}, {
 	/* Ships */
 	STR_ENGINE_SORT_ENGINE_ID,
 	STR_ENGINE_SORT_INTRO_DATE,
 	STR_SORT_BY_DROPDOWN_NAME,
 	STR_SORT_BY_RELIABILITY,
+	STR_ENGINE_SORT_CARGO_CAPACITY,
 	INVALID_STRING_ID
-},{
+}, {
 	/* Aircraft */
 	STR_ENGINE_SORT_ENGINE_ID,
 	STR_ENGINE_SORT_COST,
 	STR_SORT_BY_MAX_SPEED,
 	STR_ENGINE_SORT_INTRO_DATE,
 /* Draw rail wagon specific details */
 static int DrawRailWagonPurchaseInfo(int x, int y, EngineID engine_number, const RailVehicleInfo *rvi)
 {
 	/* Purchase cost */
-	SetDParam(0, (rvi->base_cost * _price.build_railwagon) >> 8);
+	SetDParam(0, (GetEngineProperty(engine_number, 0x17, rvi->base_cost) * _price.build_railwagon) >> 8);
 	DrawString(x, y, STR_PURCHASE_INFO_COST, 0);
 	y += 10;
 	/* Wagon weight - (including cargo) */
-	SetDParam(0, rvi->weight);
+	uint weight = GetEngineProperty(engine_number, 0x16, rvi->weight);
-	SetDParam(1, (GetCargo(rvi->cargo_type)->weight * rvi->capacity >> 4) + rvi->weight);
+	SetDParam(0, weight);
+	SetDParam(1, (GetCargo(rvi->cargo_type)->weight * GetEngineProperty(engine_number, 0x14, rvi->capacity) >> 4) + weight);
 	DrawString(x, y, STR_PURCHASE_INFO_WEIGHT_CWEIGHT, 0);
 	y += 10;
 	/* Wagon speed limit, displayed if above zero */
-	if (rvi->max_speed > 0 && _patches.wagon_speed_limits) {
+	if (_patches.wagon_speed_limits) {
-		SetDParam(0, rvi->max_speed * 10 / 16);
+		uint max_speed = GetEngineProperty(engine_number, 0x09, rvi->max_speed);
-		DrawString(x,y, STR_PURCHASE_INFO_SPEED, 0);
+		if (max_speed > 0) {
-		y += 10;
+			SetDParam(0, max_speed * 10 / 16);
+			DrawString(x, y, STR_PURCHASE_INFO_SPEED, 0);
+			y += 10;
+		}
 	}
 	return y;
 }
 /* Draw locomotive specific details */
 static int DrawRailEnginePurchaseInfo(int x, int y, EngineID engine_number, const RailVehicleInfo *rvi)
 {
 	int multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);
+	uint weight = GetEngineProperty(engine_number, 0x16, rvi->weight);
 	/* Purchase Cost - Engine weight */
-	SetDParam(0, rvi->base_cost * (_price.build_railvehicle >> 3) >> 5);
+	SetDParam(0, GetEngineProperty(engine_number, 0x17, rvi->base_cost) * (_price.build_railvehicle >> 3) >> 5);
-	SetDParam(1, rvi->weight << multihead);
+	SetDParam(1, weight << multihead);
-	DrawString(x,y, STR_PURCHASE_INFO_COST_WEIGHT, 0);
+	DrawString(x, y, STR_PURCHASE_INFO_COST_WEIGHT, 0);
 	y += 10;
 	/* Max speed - Engine power */
-	SetDParam(0, rvi->max_speed * 10 / 16);
+	SetDParam(0, GetEngineProperty(engine_number, 0x09, rvi->max_speed) * 10 / 16);
-	SetDParam(1, rvi->power << multihead);
+	SetDParam(1, GetEngineProperty(engine_number, 0x0B, rvi->power) << multihead);
-	DrawString(x,y, STR_PURCHASE_INFO_SPEED_POWER, 0);
+	DrawString(x, y, STR_PURCHASE_INFO_SPEED_POWER, 0);
 	y += 10;
 	/* Max tractive effort - not applicable if old acceleration or maglev */
 	if (_patches.realistic_acceleration && rvi->railtype != RAILTYPE_MAGLEV) {
-		SetDParam(0, ((rvi->weight << multihead) * 10 * rvi->tractive_effort) / 256);
+		SetDParam(0, ((weight << multihead) * 10 * GetEngineProperty(engine_number, 0x1F, rvi->tractive_effort)) / 256);
 		DrawString(x, y, STR_PURCHASE_INFO_MAX_TE, 0);
 		y += 10;
 	}
 	/* Running cost */
-	SetDParam(0, (rvi->running_cost_base * _price.running_rail[rvi->running_cost_class] >> 8) << multihead);
+	SetDParam(0, (GetEngineProperty(engine_number, 0x0D, rvi->running_cost_base) * _price.running_rail[rvi->running_cost_class] >> 8) << multihead);
-	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);
+	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);
 	y += 10;
 	/* Powered wagons power - Powered wagons extra weight */
 	if (rvi->pow_wag_power != 0) {
 		SetDParam(0, rvi->pow_wag_power);
 		SetDParam(1, rvi->pow_wag_weight);
-		DrawString(x,y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);
+		DrawString(x, y, STR_PURCHASE_INFO_PWAGPOWER_PWAGWEIGHT, 0);
 		y += 10;
 	};
 	return y;
 }
 static int DrawRoadVehPurchaseInfo(int x, int y, EngineID engine_number, const RoadVehicleInfo *rvi)
 {
 	bool refittable = (_engine_info[engine_number].refit_mask != 0);
 	/* Purchase cost - Max speed */
-	SetDParam(0, rvi->base_cost * (_price.roadveh_base>>3)>>5);
+	SetDParam(0, GetEngineProperty(engine_number, 0x11, rvi->base_cost) * (_price.roadveh_base >> 3) >> 5);
 	SetDParam(1, rvi->max_speed * 10 / 32);
 	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);
 	y += 10;
 	/* Running cost */
 	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);
 	y += 10;
 	/* Cargo type + capacity */
 	SetDParam(0, rvi->cargo_type);
-	SetDParam(1, rvi->capacity);
+	SetDParam(1, GetEngineProperty(engine_number, 0x0F, rvi->capacity));
 	SetDParam(2, refittable ? STR_9842_REFITTABLE : STR_EMPTY);
 	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);
 	y += 10;
 	return y;
 /* Draw ship specific details */
 static int DrawShipPurchaseInfo(int x, int y, EngineID engine_number, const ShipVehicleInfo *svi)
 {
 	/* Purchase cost - Max speed */
-	SetDParam(0, svi->base_cost * (_price.ship_base>>3)>>5);
+	SetDParam(0, GetEngineProperty(engine_number, 0x0A, svi->base_cost) * (_price.ship_base >> 3) >> 5);
-	SetDParam(1, svi->max_speed * 10 / 32);
+	SetDParam(1, GetEngineProperty(engine_number, 0x0B, svi->max_speed) * 10 / 32);
-	DrawString(x,y, STR_PURCHASE_INFO_COST_SPEED, 0);
+	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);
 	y += 10;
 	/* Cargo type + capacity */
 	SetDParam(0, svi->cargo_type);
-	SetDParam(1, svi->capacity);
+	SetDParam(1, GetEngineProperty(engine_number, 0x0D, svi->capacity));
 	SetDParam(2, svi->refittable ? STR_9842_REFITTABLE : STR_EMPTY);
-	DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);
+	DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);
 	y += 10;
 	/* Running cost */
-	SetDParam(0, svi->running_cost * _price.ship_running >> 8);
+	SetDParam(0, GetEngineProperty(engine_number, 0x0F, svi->running_cost) * _price.ship_running >> 8);
-	DrawString(x,y, STR_PURCHASE_INFO_RUNNINGCOST, 0);
+	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);
 	y += 10;
 	return y;
 }
 static int DrawAircraftPurchaseInfo(int x, int y, EngineID engine_number, const AircraftVehicleInfo *avi)
 {
 	CargoID cargo;
 	/* Purchase cost - Max speed */
-	SetDParam(0, avi->base_cost * (_price.aircraft_base>>3)>>5);
+	SetDParam(0, GetEngineProperty(engine_number, 0x0B, avi->base_cost) * (_price.aircraft_base >> 3) >> 5);
 	SetDParam(1, avi->max_speed * 10 / 16);
 	DrawString(x, y, STR_PURCHASE_INFO_COST_SPEED, 0);
 	y += 10;
 	/* Cargo capacity */
 		DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);
 	}
 	y += 10;
 	/* Running cost */
-	SetDParam(0, avi->running_cost * _price.aircraft_running >> 8);
+	SetDParam(0, GetEngineProperty(engine_number, 0x0E, avi->running_cost) * _price.aircraft_running >> 8);
 	DrawString(x, y, STR_PURCHASE_INFO_RUNNINGCOST, 0);
 	y += 10;
 	return y;
 }
 	YearMonthDay ymd;
 	ConvertDateToYMD(e->intro_date, &ymd);
 	bool refitable = false;
 	switch (e->type) {
+		default: NOT_REACHED();
 		case VEH_TRAIN: {
 			const RailVehicleInfo *rvi = RailVehInfo(engine_number);
+			uint capacity = GetEngineProperty(engine_number, 0x14, rvi->capacity);
-			refitable = (EngInfo(engine_number)->refit_mask != 0) && (rvi->capacity > 0);
+			refitable = (EngInfo(engine_number)->refit_mask != 0) && (capacity > 0);
 			if (rvi->railveh_type == RAILVEH_WAGON) {
 				y = DrawRailWagonPurchaseInfo(x, y, engine_number, rvi);
 			} else {
 				y = DrawRailEnginePurchaseInfo(x, y, engine_number, rvi);
 				SetDParam(2, STR_EMPTY);
 			} else {
 				int multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);
 				SetDParam(0, rvi->cargo_type);
-				SetDParam(1, (rvi->capacity * (CountArticulatedParts(engine_number) + 1)) << multihead);
+				SetDParam(1, (capacity * (CountArticulatedParts(engine_number) + 1)) << multihead);
 				SetDParam(2, refitable ? STR_9842_REFITTABLE : STR_EMPTY);
 			}
-			DrawString(x,y, STR_PURCHASE_INFO_CAPACITY, 0);
+			DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);
 			y += 10;
 		}
 			break;
 		case VEH_ROAD:
 			y = DrawRoadVehPurchaseInfo(x, y, engine_number, RoadVehInfo(engine_number));
 	sel_id = INVALID_ENGINE;
 	for (eid = ROAD_ENGINES_INDEX; eid < ROAD_ENGINES_INDEX + NUM_ROAD_ENGINES; eid++) {
 		if (!IsEngineBuildable(eid, VEH_ROAD, _local_player)) continue;
+		if (!HASBIT(bv->filter.roadtypes, HASBIT(EngInfo(eid)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD)) continue;
 		EngList_Add(&bv->eng_list, eid);
 		if (eid == bv->sel_engine) sel_id = eid;
 	}
 	bv->sel_engine = sel_id;
 static void GenerateBuildList(Window *w)
 {
 	buildvehicle_d *bv = &WP(w, buildvehicle_d);
 	switch (bv->vehicle_type) {
+		default: NOT_REACHED();
 		case VEH_TRAIN:
 			GenerateBuildTrainList(w);
 			return; // trains should not reach the last sorting
 		case VEH_ROAD:
 			GenerateBuildRoadVehList(w);
 * @param min where to start in the list
 * @param max where in the list to end
 * @param selected_id what engine to highlight as selected, if any
 * @param show_count Display the number of vehicles (used by autoreplace)
 */
-void DrawEngineList(byte type, int x, int y, const EngineList eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count)
+void DrawEngineList(VehicleType type, int x, int y, const EngineList eng_list, uint16 min, uint16 max, EngineID selected_id, bool show_count, GroupID selected_group)
 {
 	byte step_size = GetVehicleListHeight(type);
 	byte x_offset = 0;
 	byte y_offset = 0;
 	Player *p = GetPlayer(_local_player);
 		default: NOT_REACHED();
 	}
 	for (; min < max; min++, y += step_size) {
 		const EngineID engine = eng_list[min];
+		const uint num_engines = IsDefaultGroupID(selected_group) ? p->num_engines[engine] : GetGroup(selected_group)->num_engines[engine];
 		DrawString(x + x_offset, y, GetCustomEngineName(engine), engine == selected_id ? 0xC : 0x10);
-		DrawVehicleEngine(type, x, y + y_offset, engine, (show_count && p->num_engines[engine] == 0) ? PALETTE_CRASH : GetEnginePalette(engine, _local_player));
+		DrawVehicleEngine(type, x, y + y_offset, engine, (show_count && num_engines == 0) ? PALETTE_CRASH : GetEnginePalette(engine, _local_player));
 		if (show_count) {
-			SetDParam(0, p->num_engines[engine]);
+			SetDParam(0, num_engines);
 			DrawStringRightAligned(213, y + (GetVehicleListHeight(type) == 14 ? 3 : 8), STR_TINY_BLACK, 0);
 		}
 	}
 }
 	SetVScrollCount(w, EngList_Count(&bv->eng_list));
 	SetDParam(0, bv->filter.railtype + STR_881C_NEW_RAIL_VEHICLES); // This should only affect rail vehicles
 	DrawWindowWidgets(w);
-	DrawEngineList(bv->vehicle_type, 2, 27, bv->eng_list, w->vscroll.pos, max, bv->sel_engine, false);
+	DrawEngineList(bv->vehicle_type, 2, 27, bv->eng_list, w->vscroll.pos, max, bv->sel_engine, false, DEFAULT_GROUP);
 	if (bv->sel_engine != INVALID_ENGINE) {
 		const Widget *wi = &w->widget[BUILD_VEHICLE_WIDGET_PANEL];
 		int text_end = DrawVehiclePurchaseInfo(2, wi->top + 1, wi->right - wi->left - 2, bv->sel_engine);
 		case BUILD_VEHICLE_WIDGET_BUILD: {
 			EngineID sel_eng = bv->sel_engine;
 			if (sel_eng != INVALID_ENGINE) {
 				switch (bv->vehicle_type) {
+					default: NOT_REACHED();
 					case VEH_TRAIN:
 						DoCommandP(w->window_number, sel_eng, 0, (RailVehInfo(sel_eng)->railveh_type == RAILVEH_WAGON) ? CcBuildWagon : CcBuildLoco,
 								   CMD_BUILD_RAIL_VEHICLE | CMD_MSG(STR_882B_CAN_T_BUILD_RAILROAD_VEHICLE));
 						break;
 					case VEH_ROAD:
 			if (sel_eng != INVALID_ENGINE) {
 				StringID str = STR_NULL;
 				bv->rename_engine = sel_eng;
 				switch (bv->vehicle_type) {
+					default: NOT_REACHED();
 					case VEH_TRAIN:    str = STR_886A_RENAME_TRAIN_VEHICLE_TYPE; break;
 					case VEH_ROAD:     str = STR_9036_RENAME_ROAD_VEHICLE_TYPE;  break;
 					case VEH_SHIP:     str = STR_9838_RENAME_SHIP_TYPE;          break;
 					case VEH_AIRCRAFT: str = STR_A039_RENAME_AIRCRAFT_TYPE;      break;
 				}
 		case WE_ON_EDIT_TEXT: {
 			if (e->we.edittext.str[0] != '\0') {
 				StringID str = STR_NULL;
 				_cmd_text = e->we.edittext.str;
 				switch (bv->vehicle_type) {
+					default: NOT_REACHED();
 					case VEH_TRAIN:    str = STR_886B_CAN_T_RENAME_TRAIN_VEHICLE; break;
 					case VEH_ROAD:     str = STR_9037_CAN_T_RENAME_ROAD_VEHICLE;  break;
 					case VEH_SHIP:     str = STR_9839_CAN_T_RENAME_SHIP_TYPE;     break;
 					case VEH_AIRCRAFT: str = STR_A03A_CAN_T_RENAME_AIRCRAFT_TYPE; break;
 				}
 	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS | WDF_RESIZABLE,
 	_build_vehicle_widgets,
 	NewVehicleWndProc
 };
-void ShowBuildVehicleWindow(TileIndex tile, byte type)
+void ShowBuildVehicleWindow(TileIndex tile, VehicleType type)
 {
 	buildvehicle_d *bv;
 	Window *w;
 	assert(IsPlayerBuildableVehicleType(type));
 	bv->sort_criteria         = _last_sort_criteria[type];
 	bv->descending_sort_order = _last_sort_order[type];
 	switch (type) {
+		default: NOT_REACHED();
 		case VEH_TRAIN:
-			WP(w,buildvehicle_d).filter.railtype = (tile == 0) ? RAILTYPE_END : GetRailType(tile);
+			WP(w, buildvehicle_d).filter.railtype = (tile == 0) ? RAILTYPE_END : GetRailType(tile);
 			ResizeWindow(w, 0, 16);
 			break;
 		case VEH_ROAD:
+			WP(w, buildvehicle_d).filter.roadtypes = (tile == 0) ? ROADTYPES_ALL : GetRoadTypes(tile);
 			ResizeWindow(w, 0, 16);
 		case VEH_SHIP:
 			break;
 		case VEH_AIRCRAFT:
 			bv->filter.flags =

branch	NewGRF_ports
changeset 6719	4cc327ad39d5
parent 6712	d100bbf7f752
child 6720	35756db7e577