openttd-ottdgrfs: comparison src/roadveh

equal deleted inserted replaced

-:5a9dc001e1ad
+:1c4a4a609f85
 /** @file roadveh_cmd.cpp */
 #include "stdafx.h"
 #include "openttd.h"
 #include "debug.h"
-#include "functions.h"
+#include "tile_cmd.h"
 #include "landscape.h"
 #include "road_map.h"
 #include "roadveh.h"
 #include "station_map.h"
-#include "table/strings.h"
-#include "strings.h"
-#include "map.h"
-#include "tile.h"
-#include "vehicle.h"
 #include "timetable.h"
 #include "engine.h"
-#include "command.h"
+#include "command_func.h"
 #include "station.h"
 #include "news.h"
 #include "pathfind.h"
 #include "npf.h"
-#include "player.h"
+#include "player_func.h"
-#include "sound.h"
+#include "player_base.h"
 #include "depot.h"
 #include "bridge.h"
 #include "tunnel_map.h"
 #include "bridge_map.h"
 #include "vehicle_gui.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_engine.h"
 #include "newgrf_text.h"
 #include "newgrf_sound.h"
 #include "yapf/yapf.h"
-#include "date.h"
 #include "cargotype.h"
+#include "strings_func.h"
+#include "tunnelbridge_map.h"
+#include "functions.h"
+#include "window_func.h"
+#include "date_func.h"
+#include "vehicle_func.h"
+#include "sound_func.h"
+#include "variables.h"
+#include "autoreplace_gui.h"
+#include "gfx_func.h"
+#include "settings_type.h"
+#include "table/strings.h"
 static const uint16 _roadveh_images[63] = {
 	0xCD4, 0xCDC, 0xCE4, 0xCEC, 0xCF4, 0xCFC, 0xD0C, 0xD14,
 	0xD24, 0xD1C, 0xD2C, 0xD04, 0xD1C, 0xD24, 0xD6C, 0xD74,
 	0xD7C, 0xC14, 0xC1C, 0xC24, 0xC2C, 0xC34, 0xC3C, 0xC4C,
 	int image;
 	if (is_custom_sprite(img)) {
 		image = GetCustomVehicleSprite(this, (Direction)(direction + 4 * IS_CUSTOM_SECONDHEAD_SPRITE(img)));
 		if (image != 0) return image;
-		img = orig_road_vehicle_info[this->engine_type - ROAD_ENGINES_INDEX].image_index;
+		img = _orig_road_vehicle_info[this->engine_type - ROAD_ENGINES_INDEX].image_index;
 	}
 	image = direction + _roadveh_images[img];
 	if (this->cargo.Count() >= this->cargo_cap / 2U) image += _roadveh_full_adder[img];
 	return image;
 		if (sprite != 0) {
 			DrawSprite(sprite, pal, x, y);
 			return;
 		}
-		spritenum = orig_road_vehicle_info[engine - ROAD_ENGINES_INDEX].image_index;
+		spritenum = _orig_road_vehicle_info[engine - ROAD_ENGINES_INDEX].image_index;
 	}
 	DrawSprite(6 + _roadveh_images[spritenum], pal, x, y);
 }
 static CommandCost EstimateRoadVehCost(EngineID engine_type)
 {
-	return CommandCost(((_price.roadveh_base >> 3) * GetEngineProperty(engine_type, 0x11, RoadVehInfo(engine_type)->base_cost)) >> 5);
+	return CommandCost(EXPENSES_NEW_VEHICLES, ((_price.roadveh_base >> 3) * GetEngineProperty(engine_type, 0x11, RoadVehInfo(engine_type)->base_cost)) >> 5);
 }
 byte GetRoadVehLength(const Vehicle *v)
 {
 	byte length = 8;
 	Vehicle *v;
 	UnitID unit_num;
 	Engine *e;
 	if (!IsEngineBuildable(p1, VEH_ROAD, _current_player)) return_cmd_error(STR_ROAD_VEHICLE_NOT_AVAILABLE);
-	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	cost = EstimateRoadVehCost(p1);
 	if (flags & DC_QUERY_COST) return cost;
 	/* The ai_new queries the vehicle cost before building the route,
 //	v->u.road.unk2 = 0;
 //	v->u.road.overtaking = 0;
 		v->last_station_visited = INVALID_STATION;
 		v->max_speed = rvi->max_speed;
-		v->engine_type = (byte)p1;
+		v->engine_type = (EngineID)p1;
 		e = GetEngine(p1);
 		v->reliability = e->reliability;
 		v->reliability_spd_dec = e->reliability_spd_dec;
 		v->max_age = e->lifelength * 366;
 		_new_vehicle_id = v->index;
-		v->string_id = STR_SV_ROADVEH_NAME;
+		v->name = NULL;
 		v->service_interval = _patches.servint_roadveh;
 		v->date_of_last_service = _date;
 		v->build_year = _cur_year;
 			InvalidateAutoreplaceWindow(v->engine_type, v->group_id); // updates the replace Road window
 		GetPlayer(_current_player)->num_engines[p1]++;
 	}
-	return CommandCost(cost);
+	return cost;
 }
 /** Start/Stop a road vehicle.
 * @param tile unused
 * @param flags operation to perform
 			DeleteVehicleNews(p1, STR_9016_ROAD_VEHICLE_IS_WAITING);
 		}
 		v->vehstatus ^= VS_STOPPED;
 		v->cur_speed = 0;
-		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 	}
 	return CommandCost();
 }
 	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (HASBITS(v->vehstatus, VS_CRASHED)) return_cmd_error(STR_CAN_T_SELL_DESTROYED_VEHICLE);
-	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	if (!CheckRoadVehInDepotStopped(v)) {
 		return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
 	}
-	CommandCost ret(-v->value);
+	CommandCost ret(EXPENSES_NEW_VEHICLES, -v->value);
 	if (flags & DC_EXEC) {
 		// Invalidate depot
 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 		RebuildVehicleLists();
 	} else if (_patches.new_pathfinding_all) {
 		NPFFoundTargetData ftd;
 		/* See where we are now */
 		Trackdir trackdir = GetVehicleTrackdir(v);
-		ftd = NPFRouteToDepotBreadthFirstTwoWay(v->tile, trackdir, v->tile, ReverseTrackdir(trackdir), TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPE, 0);
+		ftd = NPFRouteToDepotBreadthFirstTwoWay(v->tile, trackdir, v->tile, ReverseTrackdir(trackdir), TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPES, 0);
 		if (ftd.best_bird_dist == 0) {
 			return GetDepotByTile(ftd.node.tile); /* Target found */
 		} else {
 			return NULL; /* Target not found */
 		}
 	if (v->IsInDepot()) return CMD_ERROR;
 	/* If the current orders are already goto-depot */
 	if (v->current_order.type == OT_GOTO_DEPOT) {
-		if (!!(p2 & DEPOT_SERVICE) == HasBit(v->current_order.flags, OFB_HALT_IN_DEPOT)) {
+		if (!!(p2 & DEPOT_SERVICE) == HasBit(v->current_order.flags, OF_HALT_IN_DEPOT)) {
 			/* We called with a different DEPOT_SERVICE setting.
 			 * Now we change the setting to apply the new one and let the vehicle head for the same depot.
 			 * Note: the if is (true for requesting service == true for ordered to stop in depot) */
 			if (flags & DC_EXEC) {
-				ClrBit(v->current_order.flags, OFB_PART_OF_ORDERS);
+				ClrBit(v->current_order.flags, OF_PART_OF_ORDERS);
-				ToggleBit(v->current_order.flags, OFB_HALT_IN_DEPOT);
+				ToggleBit(v->current_order.flags, OF_HALT_IN_DEPOT);
-				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 			}
 			return CommandCost();
 		}
 		if (p2 & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of depot orders
 		if (flags & DC_EXEC) {
 			/* If the orders to 'goto depot' are in the orders list (forced servicing),
 			 * then skip to the next order; effectively cancelling this forced service */
-			if (HasBit(v->current_order.flags, OFB_PART_OF_ORDERS))
+			if (HasBit(v->current_order.flags, OF_PART_OF_ORDERS))
 				v->cur_order_index++;
 			v->current_order.type = OT_DUMMY;
 			v->current_order.flags = 0;
-			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 		return CommandCost();
 	}
 	dep = FindClosestRoadDepot(v);
 	if (flags & DC_EXEC) {
 		if (v->current_order.type == OT_LOADING) v->LeaveStation();
 		ClearSlot(v);
 		v->current_order.type = OT_GOTO_DEPOT;
-		v->current_order.flags = OF_NON_STOP;
+		v->current_order.flags = OFB_NON_STOP;
-		if (!(p2 & DEPOT_SERVICE)) SetBit(v->current_order.flags, OFB_HALT_IN_DEPOT);
+		if (!(p2 & DEPOT_SERVICE)) SetBit(v->current_order.flags, OF_HALT_IN_DEPOT);
 		v->current_order.refit_cargo = CT_INVALID;
 		v->current_order.dest = dep->index;
 		v->dest_tile = dep->xy;
-		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 	}
 	return CommandCost();
 }
 		return CMD_ERROR;
 	}
 	if (IsTileType(v->tile, MP_ROAD) && GetRoadTileType(v->tile) == ROAD_TILE_NORMAL && GetDisallowedRoadDirections(v->tile) != DRD_NONE) return CMD_ERROR;
-	if (IsTunnelTile(v->tile) && DirToDiagDir(v->direction) == GetTunnelDirection(v->tile)) return CMD_ERROR;
+	if (IsTileType(v->tile, MP_TUNNELBRIDGE) && DirToDiagDir(v->direction) == GetTunnelBridgeDirection(v->tile)) return CMD_ERROR;
-	if (IsBridgeTile(v->tile) && DirToDiagDir(v->direction) == GetBridgeRampDirection(v->tile)) return CMD_ERROR;
 	if (flags & DC_EXEC) v->u.road.reverse_ctr = 180;
 	return CommandCost();
 }
 void RoadVehicle::MarkDirty()
 {
 	for (Vehicle *v = this; v != NULL; v = v->Next()) {
 		v->cur_image = v->GetImage(v->direction);
-		MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
+		MarkSingleVehicleDirty(v);
 	}
 }
 void RoadVehicle::UpdateDeltaXY(Direction direction)
 {
 	RebuildVehicleLists();
 	InvalidateWindow(WC_COMPANY, v->owner);
 	if (IsTileType(v->tile, MP_STATION)) ClearCrashedStation(v);
-	BeginVehicleMove(v);
+	MarkSingleVehicleDirty(v);
-	EndVehicleMove(v);
 	delete v;
 }
 static byte SetRoadVehPosition(Vehicle *v, int x, int y)
 	for (Vehicle *u = v; u != NULL; u = u->Next()) {
 		if (IsCargoInClass(u->cargo_type, CC_PASSENGERS)) pass += u->cargo.Count();
 		u->vehstatus |= VS_CRASHED;
-		MarkAllViewportsDirty(u->left_coord, u->top_coord, u->right_coord + 1, u->bottom_coord + 1);
+		MarkSingleVehicleDirty(u);
 	}
 	ClearSlot(v);
-	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 	SetDParam(0, pass);
 	AddNewsItem(
 		(pass == 1) ?
 			STR_9031_ROAD_VEHICLE_CRASH_DRIVER : STR_9032_ROAD_VEHICLE_CRASH_DIE,
 	const Order *order;
 	switch (v->current_order.type) {
 		case OT_GOTO_DEPOT:
 			/* Let a depot order in the orderlist interrupt. */
-			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return;
+			if (!(v->current_order.flags & OFB_PART_OF_ORDERS)) return;
-			if (v->current_order.flags & OF_SERVICE_IF_NEEDED &&
+			if (v->current_order.flags & OFB_SERVICE_IF_NEEDED &&
 					!VehicleNeedsService(v)) {
 				UpdateVehicleTimetable(v, true);
 				v->cur_order_index++;
 			}
 			break;
 	rvf.y = y;
 	rvf.dir = dir;
 	rvf.veh = v;
 	if (front->u.road.state == RVSB_WORMHOLE) {
 		u = (Vehicle*)VehicleFromPos(v->tile, &rvf, EnumCheckRoadVehClose);
+		if (u == NULL) u = (Vehicle*)VehicleFromPos(GetOtherTunnelBridgeEnd(v->tile), &rvf, EnumCheckRoadVehClose);
 	} else {
 		u = (Vehicle*)VehicleFromPosXY(x, y, &rvf, EnumCheckRoadVehClose);
 	}
 	/* This code protects a roadvehicle from being blocked for ever
 	/* updates statusbar only if speed have changed to save CPU time */
 	if (spd != v->cur_speed) {
 		v->cur_speed = spd;
 		if (_patches.vehicle_speed) {
-			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 	}
 	/* Decrease somewhat when turning */
 	if (!(v->direction & 1)) spd = spd * 3 >> 2;
 static void* EnumFindVehToOvertake(Vehicle* v, void* data)
 {
 	const OvertakeData* od = (OvertakeData*)data;
 	return
-		v->tile == od->tile && v->type == VEH_ROAD && v->First() == v && v != od->u && v != od->v ?
+		v->type == VEH_ROAD && v->First() == v && v != od->u && v != od->v ?
 			v : NULL;
 }
 static bool FindRoadVehToOvertake(OvertakeData *od)
 {
 		frd->mindist = dist;
 	}
 	return false;
 }
-static inline NPFFoundTargetData PerfNPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, uint sub_type, Owner owner, RailTypeMask railtypes)
+static inline NPFFoundTargetData PerfNPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, uint sub_type, Owner owner, RailTypes railtypes)
 {
 	void* perf = NpfBeginInterval();
 	NPFFoundTargetData ret = NPFRouteToStationOrTile(tile, trackdir, target, type, sub_type, owner, railtypes);
 	int t = NpfEndInterval(perf);
 		NPFFillWithOrderData(&fstd, v);
 		trackdir = DiagdirToDiagTrackdir(enterdir);
 		//debug("Finding path. Enterdir: %d, Trackdir: %d", enterdir, trackdir);
-		ftd = PerfNPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, &fstd, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPE);
+		ftd = PerfNPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, &fstd, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPES);
 		if (ftd.best_trackdir == INVALID_TRACKDIR) {
 			/* We are already at our target. Just do something
 			 * @todo: maybe display error?
 			 * @todo: go straight ahead if possible? */
 			return_track(FindFirstBit2x64(trackdirs));
 		assert(trackdir != INVALID_TRACKDIR);
 		fstd.dest_coords = tile;
 		fstd.station_index = INVALID_STATION; // indicates that the destination is a tile, not a station
-		dist = NPFRouteToStationOrTile(v->tile, trackdir, &fstd, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPE).best_path_dist;
+		dist = NPFRouteToStationOrTile(v->tile, trackdir, &fstd, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPES).best_path_dist;
 		/* change units from NPF_TILE_LENGTH to # of tiles */
 		if (dist != UINT_MAX)
 			dist = (dist + NPF_TILE_LENGTH - 1) / NPF_TILE_LENGTH;
 	}
 	return dist;
 	Trackdir dir;
 	if (prev_state == RVSB_WORMHOLE || prev_state == RVSB_IN_DEPOT) {
 		DiagDirection diag_dir = INVALID_DIAGDIR;
-		if (IsTunnelTile(tile)) {
+		if (IsTileType(tile, MP_TUNNELBRIDGE)) {
-			diag_dir = GetTunnelDirection(tile);
+			diag_dir = GetTunnelBridgeDirection(tile);
-		} else if (IsBridgeTile(tile)) {
-			diag_dir = GetBridgeRampDirection(tile);
 		} else if (IsTileType(tile, MP_ROAD) && GetRoadTileType(tile) == ROAD_TILE_DEPOT) {
 			diag_dir = ReverseDiagDir(GetRoadDepotDirection(tile));
 		}
 		if (diag_dir == INVALID_DIAGDIR) return INVALID_TRACKDIR;
 		dir = DiagdirToDiagTrackdir(diag_dir);
-	} else if (HasBit(prev_state, RVS_IN_DT_ROAD_STOP)) {
+	} else {
-		dir = (Trackdir)(prev_state & RVSB_ROAD_STOP_TRACKDIR_MASK);
-	} else if (prev_state < TRACKDIR_END) {
 		if (already_reversed && prev->tile != tile) {
 			/*
 			 * The vehicle has reversed, but did not go straight back.
 			 * It immediatelly turn onto another tile. This means that
 			 * the roadstate of the previous vehicle cannot be used
 			 */
 			Trackdir reversed_turn_lookup[2][DIAGDIR_END] = {
 				{ TRACKDIR_UPPER_W, TRACKDIR_RIGHT_N, TRACKDIR_LEFT_N,  TRACKDIR_UPPER_E },
 				{ TRACKDIR_RIGHT_S, TRACKDIR_LOWER_W, TRACKDIR_LOWER_E, TRACKDIR_LEFT_S  }};
 			dir = reversed_turn_lookup[prev->tile < tile ? 0 : 1][ReverseDiagDir(entry_dir)];
+		} else if (HasBit(prev_state, RVS_IN_DT_ROAD_STOP)) {
+			dir = (Trackdir)(prev_state & RVSB_ROAD_STOP_TRACKDIR_MASK);
+		} else if (prev_state < TRACKDIR_END) {
+			dir = (Trackdir)prev_state;
 		} else {
-			dir = (Trackdir)prev_state;
+			return INVALID_TRACKDIR;
 		}
-	} else {
-		return INVALID_TRACKDIR;
 	}
 	/* Do some sanity checking. */
 	static const RoadBits required_roadbits[] = {
 		ROAD_X,            ROAD_Y,            ROAD_NW | ROAD_NE, ROAD_SW | ROAD_SE,
 	return dir;
 }
 /**
 * Can a tram track build without destruction on the given tile?
+* @param p the player that would be building the tram tracks
 * @param t the tile to build on.
+* @param r the road bits needed.
 * @return true when a track track can be build on 't'
 */
-static bool CanBuildTramTrackOnTile(TileIndex t)
+static bool CanBuildTramTrackOnTile(PlayerID p, TileIndex t, RoadBits r)
 {
-	switch (GetTileType(t)) {
+	/* The 'current' player is not necessarily the owner of the vehicle. */
-		case MP_CLEAR:
+	PlayerID original_player = _current_player;
-		case MP_TREES:
+	_current_player = p;
-			return true;
+	CommandCost ret = DoCommand(t, ROADTYPE_TRAM << 4 | r, 0, 0, CMD_BUILD_ROAD);
-		case MP_ROAD:
-			return GetRoadTileType(t) == ROAD_TILE_NORMAL;
+	_current_player = original_player;
+	return CmdSucceeded(ret);
-		case MP_WATER:
-			return IsCoast(t);
-		default:
-			return false;
-	}
 }
 static bool IndividualRoadVehicleController(Vehicle *v, const Vehicle *prev)
 {
 	Direction new_dir;
 	RoadDriveEntry rd;
 	int x,y;
 	uint32 r;
 	if (v->u.road.overtaking != 0)  {
-		if (++v->u.road.overtaking_ctr >= 35)
+		if (IsTileType(v->tile, MP_STATION)) {
+			/* Force us to be not overtaking! */
+			v->u.road.overtaking = 0;
+		} else if (++v->u.road.overtaking_ctr >= 35) {
 			/* If overtaking just aborts at a random moment, we can have a out-of-bound problem,
 			 *  if the vehicle started a corner. To protect that, only allow an abort of
 			 *  overtake if we are on straight roads */
 			if (v->u.road.state < RVSB_IN_ROAD_STOP && IsStraightRoadTrackdir((Trackdir)v->u.road.state)) {
 				v->u.road.overtaking = 0;
 			}
+		}
 	}
 	/* If this vehicle is in a depot and we've reached this point it must be
 	 * one of the articulated parts. It will stay in the depot until activated
 	 * by the previous vehicle in the chain when it gets to the right place. */
 	if (v->u.road.state == RVSB_WORMHOLE) {
 		/* Vehicle is entering a depot or is on a bridge or in a tunnel */
 		GetNewVehiclePosResult gp = GetNewVehiclePos(v);
-		const Vehicle *u = RoadVehFindCloseTo(v, gp.x, gp.y, v->direction);
+		if (IsRoadVehFront(v)) {
-		if (u != NULL && u->First()->cur_speed < v->cur_speed) {
+			const Vehicle *u = RoadVehFindCloseTo(v, gp.x, gp.y, v->direction);
-			v->cur_speed = u->First()->cur_speed;
+			if (u != NULL) {
-			return false;
+				v->cur_speed = u->First()->cur_speed;
+				return false;
+			}
 		}
 		if ((IsTunnelTile(gp.new_tile) || IsBridgeTile(gp.new_tile)) && HasBit(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {
 			/* Vehicle has just entered a bridge or tunnel */
 			v->cur_image = v->GetImage(v->direction);
 					 *   doing a reversing turn when the piece of tram track on the next
 					 *   tile did not exist yet. Do not use the big tram loop as that is
 					 *   going to cause the tram to split up.
 					 * - Or the front of the tram can drive over the next tile.
 					 */
-				} else if (!IsRoadVehFront(v) || !CanBuildTramTrackOnTile(tile)) {
+				} else if (!IsRoadVehFront(v) || !CanBuildTramTrackOnTile(v->owner, tile, needed)) {
 					/*
 					 * Taking the 'small' corner for trams only happens when:
 					 * - We are not the from vehicle of an articulated tram.
 					 * - Or when the player cannot build on the next tile.
 					 *
 			DEBUG(ms, 2, " force a slot clearing");
 			ClearSlot(v);
 		}
 		StartRoadVehSound(v);
-		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 	}
 	/* Check tile position conditions - i.e. stop position in depot,
 	 * entry onto bridge or into tunnel */
 	r = VehicleEnterTile(v, v->tile, x, y);
 	if (depot == NULL || DistanceManhattan(v->tile, depot->xy) > 12) {
 		if (v->current_order.type == OT_GOTO_DEPOT) {
 			v->current_order.type = OT_DUMMY;
 			v->current_order.flags = 0;
-			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 		return;
 	}
 	if (v->current_order.type == OT_GOTO_DEPOT &&
-			v->current_order.flags & OF_NON_STOP &&
+			v->current_order.flags & OFB_NON_STOP &&
 			!Chance16(1, 20)) {
 		return;
 	}
 	if (v->current_order.type == OT_LOADING) v->LeaveStation();
 	ClearSlot(v);
 	v->current_order.type = OT_GOTO_DEPOT;
-	v->current_order.flags = OF_NON_STOP;
+	v->current_order.flags = OFB_NON_STOP;
 	v->current_order.dest = depot->index;
 	v->dest_tile = depot->xy;
-	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 }
 void OnNewDay_RoadVeh(Vehicle *v)
 {
-	CommandCost cost;
+	CommandCost cost(EXPENSES_ROADVEH_RUN);
 	if (!IsRoadVehFront(v)) return;
 	if ((++v->day_counter & 7) == 0) DecreaseVehicleValue(v);
 	if (v->u.road.blocked_ctr == 0) CheckVehicleBreakdown(v);
 			DEBUG(ms, 4, "No road stop for vehicle %d (index %d) at station %d (0x%X)",
 					v->unitnumber, v->index, st->index, st->xy);
 		}
 	}
-	cost = RoadVehInfo(v->engine_type)->running_cost * _price.roadveh_running / 364;
+	cost = CommandCost(EXPENSES_ROADVEH_RUN, RoadVehInfo(v->engine_type)->running_cost * _price.roadveh_running / 364);
 	v->profit_this_year -= cost.GetCost() >> 8;
-	SET_EXPENSES_TYPE(EXPENSES_ROADVEH_RUN);
+	SubtractMoneyFromPlayerFract(v->owner, cost);
-	SubtractMoneyFromPlayerFract(v->owner, CommandCost(cost));
 	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 	InvalidateWindowClasses(WC_ROADVEH_LIST);
 }
 * @return cost of refit or error
 */
 CommandCost CmdRefitRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle *v;
-	CommandCost cost;
+	CommandCost cost(EXPENSES_ROADVEH_RUN);
 	CargoID new_cid = GB(p2, 0, 8);
 	byte new_subtype = GB(p2, 8, 8);
 	bool only_this = HasBit(p2, 16);
 	uint16 capacity = CALLBACK_FAILED;
 	uint total_capacity = 0;
 	v = GetVehicle(p1);
 	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (!CheckRoadVehInDepotStopped(v)) return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
+	if (v->vehstatus & VS_CRASHED) return_cmd_error(STR_CAN_T_REFIT_DESTROYED_VEHICLE);
 	if (new_cid >= NUM_CARGO) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_ROADVEH_RUN);
 	for (; v != NULL; v = v->Next()) {
 		/* XXX: We 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. */

branch	NewGRF_ports
changeset 6872	1c4a4a609f85
parent 6871	5a9dc001e1ad
child 6877	889301acc299