openttd-ottdgrfs: comparison src/roadveh

equal deleted inserted replaced

-:eec5a7dcbf61
+:fcf5fb2548eb
 #include "tile_cmd.h"
 #include "landscape.h"
 #include "road_map.h"
 #include "roadveh.h"
 #include "station_map.h"
-#include "timetable.h"
-#include "engine.h"
 #include "command_func.h"
-#include "station.h"
+#include "station_base.h"
-#include "news.h"
+#include "news_func.h"
 #include "pathfind.h"
 #include "npf.h"
 #include "player_func.h"
 #include "player_base.h"
 #include "depot.h"
 #include "sound_func.h"
 #include "variables.h"
 #include "autoreplace_gui.h"
 #include "gfx_func.h"
 #include "settings_type.h"
+#include "order_func.h"
 #include "table/strings.h"
 static const uint16 _roadveh_images[63] = {
 	0xCD4, 0xCDC, 0xCE4, 0xCEC, 0xCF4, 0xCFC, 0xD0C, 0xD14,
 			rfdd.owner = v->owner;
 			rfdd.best_length = UINT_MAX;
 			/* search in all directions */
 			for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
-				FollowTrack(v->tile, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, d, EnumRoadSignalFindDepot, NULL, &rfdd);
+				FollowTrack(v->tile, PATHFIND_FLAGS_NONE, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, d, EnumRoadSignalFindDepot, NULL, &rfdd);
 			}
 			if (rfdd.best_length != UINT_MAX) return GetDepotByTile(rfdd.tile);
 		} break;
 	}
 	if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
 	if (v->IsInDepot()) return CMD_ERROR;
 	/* If the current orders are already goto-depot */
-	if (v->current_order.type == OT_GOTO_DEPOT) {
+	if (v->current_order.IsType(OT_GOTO_DEPOT)) {
-		if (!!(p2 & DEPOT_SERVICE) == HasBit(v->current_order.flags, OF_HALT_IN_DEPOT)) {
+		bool halt_in_depot = v->current_order.GetDepotActionType() & ODATFB_HALT;
+		if (!!(p2 & DEPOT_SERVICE) == 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, OF_PART_OF_ORDERS);
+				v->current_order.SetDepotOrderType(ODTF_MANUAL);
-				ToggleBit(v->current_order.flags, OF_HALT_IN_DEPOT);
+				v->current_order.SetDepotActionType(halt_in_depot ? ODATF_SERVICE_ONLY : ODATFB_HALT);
 				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, OF_PART_OF_ORDERS))
+			if (v->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS) v->cur_order_index++;
-				v->cur_order_index++;
+			v->current_order.MakeDummy();
-			v->current_order.type = OT_DUMMY;
-			v->current_order.flags = 0;
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 		return CommandCost();
 	}
 	dep = FindClosestRoadDepot(v);
 	if (dep == NULL) return_cmd_error(STR_9019_UNABLE_TO_FIND_LOCAL_DEPOT);
 	if (flags & DC_EXEC) {
-		if (v->current_order.type == OT_LOADING) v->LeaveStation();
+		if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
 		ClearSlot(v);
-		v->current_order.type = OT_GOTO_DEPOT;
+		v->current_order.MakeGoToDepot(dep->index, ODTF_MANUAL);
-		v->current_order.flags = OFB_NON_STOP;
+		if (!(p2 & DEPOT_SERVICE)) v->current_order.SetDepotActionType(ODATFB_HALT);
-		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, VVW_WIDGET_START_STOP_VEH);
 	}
 	return CommandCost();
 #undef MKIT
 	uint32 x = _delta_xy_table[direction];
 	this->x_offs        = GB(x,  0, 8);
 	this->y_offs        = GB(x,  8, 8);
-	this->sprite_width  = GB(x, 16, 8);
+	this->x_extent      = GB(x, 16, 8);
-	this->sprite_height = GB(x, 24, 8);
+	this->y_extent      = GB(x, 24, 8);
-	this->z_height      = 6;
+	this->z_extent      = 6;
 }
 static void ClearCrashedStation(Vehicle *v)
 {
 	RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
 	SetDParam(0, pass);
 	AddNewsItem(
 		(pass == 1) ?
 			STR_9031_ROAD_VEHICLE_CRASH_DRIVER : STR_9032_ROAD_VEHICLE_CRASH_DIE,
-		NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0),
+		NM_THIN, NF_VIEWPORT | NF_VEHICLE, NT_ACCIDENT, DNC_NONE,
 		v->index,
 		0
 	);
 	ModifyStationRatingAround(v->tile, v->owner, -160, 22);
 			InvalidateWindow(WC_VEHICLE_VIEW, v->index);
 		}
 	}
 }
-static void ProcessRoadVehOrder(Vehicle *v)
+TileIndex RoadVehicle::GetOrderStationLocation(StationID station)
 {
-	const Order *order;
+	if (station == this->last_station_visited) this->last_station_visited = INVALID_STATION;
-	switch (v->current_order.type) {
+	TileIndex dest = INVALID_TILE;
-		case OT_GOTO_DEPOT:
+	const RoadStop *rs = GetStation(station)->GetPrimaryRoadStop(this);
-			/* Let a depot order in the orderlist interrupt. */
+	if (rs != NULL) {
-			if (!(v->current_order.flags & OFB_PART_OF_ORDERS)) return;
+		uint mindist = MAX_UVALUE(uint);
-			if (v->current_order.flags & OFB_SERVICE_IF_NEEDED &&
-					!VehicleNeedsService(v)) {
+		for (; rs != NULL; rs = rs->GetNextRoadStop(this)) {
-				UpdateVehicleTimetable(v, true);
+			uint dist = DistanceManhattan(this->tile, rs->xy);
-				v->cur_order_index++;
-			}
+			if (dist < mindist) {
-			break;
+				mindist = dist;
+				dest = rs->xy;
-		case OT_LOADING:
+			}
-		case OT_LEAVESTATION:
+		}
-			return;
+	}
-		default: break;
+	if (dest != INVALID_TILE) {
-	}
+		return dest;
+	} else {
-	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
+		/* There is no stop left at the station, so don't even TRY to go there */
+		this->cur_order_index++;
-	order = GetVehicleOrder(v, v->cur_order_index);
+		return 0;
+	}
-	if (order == NULL) {
-		v->current_order.Free();
-		v->dest_tile = 0;
-		ClearSlot(v);
-		return;
-	}
-	if (order->type  == v->current_order.type &&
-			order->flags == v->current_order.flags &&
-			order->dest  == v->current_order.dest) {
-		return;
-	}
-	v->current_order = *order;
-	switch (order->type) {
-		case OT_GOTO_STATION: {
-			if (order->dest == v->last_station_visited) {
-				v->last_station_visited = INVALID_STATION;
-			}
-			const RoadStop *rs = GetStation(order->dest)->GetPrimaryRoadStop(v);
-			TileIndex dest = INVALID_TILE;
-			if (rs != NULL) {
-				uint mindist = MAX_UVALUE(uint);
-				for (; rs != NULL; rs = rs->GetNextRoadStop(v)) {
-					uint dist = DistanceManhattan(v->tile, rs->xy);
-					if (dist < mindist) {
-						mindist = dist;
-						dest = rs->xy;
-					}
-				}
-			}
-			if (dest != INVALID_TILE) {
-					v->dest_tile = dest;
-			} else {
-				/* There is no stop left at the station, so don't even TRY to go there */
-				v->cur_order_index++;
-				v->dest_tile = 0;
-			}
-			break;
-		}
-		case OT_GOTO_DEPOT:
-			v->dest_tile = GetDepot(order->dest)->xy;
-			break;
-		default:
-			v->dest_tile = 0;
-			break;
-	}
-	InvalidateVehicleOrder(v);
 }
 static void StartRoadVehSound(const Vehicle* v)
 {
 	if (!PlayVehicleSound(v, VSE_START)) {
 static void RoadVehArrivesAt(const Vehicle* v, Station* st)
 {
 	if (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) {
 		/* Check if station was ever visited before */
 		if (!(st->had_vehicle_of_type & HVOT_BUS)) {
-			uint32 flags;
 			st->had_vehicle_of_type |= HVOT_BUS;
 			SetDParam(0, st->index);
-			flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
 			AddNewsItem(
 				v->u.road.roadtype == ROADTYPE_ROAD ? STR_902F_CITIZENS_CELEBRATE_FIRST : STR_CITIZENS_CELEBRATE_FIRST_PASSENGER_TRAM,
-				flags,
+				NM_THIN, NF_VIEWPORT | NF_VEHICLE, (v->owner == _local_player) ? NT_ARRIVAL_PLAYER : NT_ARRIVAL_OTHER, DNC_NONE,
 				v->index,
 				0);
 		}
 	} else {
 		/* Check if station was ever visited before */
 		if (!(st->had_vehicle_of_type & HVOT_TRUCK)) {
-			uint32 flags;
 			st->had_vehicle_of_type |= HVOT_TRUCK;
 			SetDParam(0, st->index);
-			flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
 			AddNewsItem(
 				v->u.road.roadtype == ROADTYPE_ROAD ? STR_9030_CITIZENS_CELEBRATE_FIRST : STR_CITIZENS_CELEBRATE_FIRST_CARGO_TRAM,
-				flags,
+				NM_THIN, NF_VIEWPORT | NF_VEHICLE, (v->owner == _local_player) ? NT_ARRIVAL_PLAYER : NT_ARRIVAL_OTHER, DNC_NONE,
 				v->index,
 				0
 			);
 		}
 	}
 		if (!IsTileOwner(tile, v->owner) || GetRoadStopDir(tile) == enterdir || RoadVehHasArticPart(v)) {
 			/* different station owner or wrong orientation or the vehicle has articulated parts */
 			trackdirs = TRACKDIR_BIT_NONE;
 		} else {
 			/* Our station */
-			RoadStop::Type rstype = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK;
+			RoadStopType rstype = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? ROADSTOP_BUS : ROADSTOP_TRUCK;
 			if (GetRoadStopType(tile) != rstype) {
 				/* Wrong station type */
 				trackdirs = TRACKDIR_BIT_NONE;
 			} else {
 			uint i;
 			FOR_EACH_SET_BIT(i, bitmask) {
 				if (best_track == INVALID_TRACKDIR) best_track = (Trackdir)i; // in case we don't find the path, just pick a track
 				frd.maxtracklen = UINT_MAX;
 				frd.mindist = UINT_MAX;
-				FollowTrack(tile, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, _road_pf_directions[i], EnumRoadTrackFindDist, NULL, &frd);
+				FollowTrack(tile, PATHFIND_FLAGS_NONE, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, _road_pf_directions[i], EnumRoadTrackFindDist, NULL, &frd);
 				if (frd.mindist < best_dist || (frd.mindist == best_dist && frd.maxtracklen < best_maxlen)) {
 					best_dist = frd.mindist;
 					best_maxlen = frd.maxtracklen;
 					best_track = (Trackdir)i;
 		ROAD_X,            ROAD_Y,            ROAD_NW | ROAD_NE, ROAD_SW | ROAD_SE,
 		ROAD_NW | ROAD_SW, ROAD_NE | ROAD_SE, ROAD_X,            ROAD_Y
 	};
 	RoadBits required = required_roadbits[dir & 0x07];
-	if ((required & GetAnyRoadBits(tile, v->u.road.roadtype)) == ROAD_NONE) {
+	if ((required & GetAnyRoadBits(tile, v->u.road.roadtype, true)) == ROAD_NONE) {
 		dir = INVALID_TRACKDIR;
 	}
 	return dir;
 }
 		const RoadDriveEntry *rdp;
 		uint turn_around_start_frame = RVC_TURN_AROUND_START_FRAME;
 		RoadBits tram;
-		if (v->u.road.roadtype == ROADTYPE_TRAM && CountBits(tram = GetAnyRoadBits(v->tile, ROADTYPE_TRAM)) == 1) {
+		if (v->u.road.roadtype == ROADTYPE_TRAM && CountBits(tram = GetAnyRoadBits(v->tile, ROADTYPE_TRAM, true)) == 1) {
 			/*
 			 * The tram is turning around with one tram 'roadbit'. This means that
 			 * it is using the 'big' corner 'drive data'. However, to support the
 			 * trams to take a small corner, there is a 'turned' marker in the middle
 			 * of the turning 'drive data'. When the tram took the long corner, we
 	 * (the station test and stop type test ensure that other vehicles, using the road stop as
 	 * a through route, do not stop) */
 	if (IsRoadVehFront(v) && ((IsInsideMM(v->u.road.state, RVSB_IN_ROAD_STOP, RVSB_IN_ROAD_STOP_END) &&
 			_road_veh_data_1[v->u.road.state - RVSB_IN_ROAD_STOP + (_opt.road_side << RVS_DRIVE_SIDE)] == v->u.road.frame) ||
 			(IsInsideMM(v->u.road.state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END) &&
-			v->current_order.dest == GetStationIndex(v->tile) &&
+			v->current_order.GetDestination() == GetStationIndex(v->tile) &&
-			GetRoadStopType(v->tile) == (IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK) &&
+			GetRoadStopType(v->tile) == (IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? ROADSTOP_BUS : ROADSTOP_TRUCK) &&
 			v->u.road.frame == RVC_DRIVE_THROUGH_STOP_FRAME))) {
 		RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
 		Station* st = GetStationByTile(v->tile);
 		/* Vehicle is at the stop position (at a bay) in a road stop.
 		 * Note, if vehicle is loading/unloading it has already been handled,
 		 * so if we get here the vehicle has just arrived or is just ready to leave. */
-		if (v->current_order.type != OT_LEAVESTATION &&
+		if (!v->current_order.IsType(OT_LEAVESTATION) &&
-				v->current_order.type != OT_GOTO_DEPOT) {
+				!v->current_order.IsType(OT_GOTO_DEPOT)) {
 			/* Vehicle has arrived at a bay in a road stop */
 			if (IsDriveThroughStopTile(v->tile)) {
 				TileIndex next_tile = TILE_ADD(v->tile, TileOffsByDir(v->direction));
-				RoadStop::Type type = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK;
+				RoadStopType type = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? ROADSTOP_BUS : ROADSTOP_TRUCK;
 				/* Check if next inline bay is free */
 				if (IsDriveThroughStopTile(next_tile) && (GetRoadStopType(next_tile) == type)) {
 					RoadStop *rs_n = GetRoadStopByTile(next_tile, type);
 			return false;
 		}
 		/* Vehicle is ready to leave a bay in a road stop */
-		if (v->current_order.type != OT_GOTO_DEPOT) {
+		if (!v->current_order.IsType(OT_GOTO_DEPOT)) {
 			if (rs->IsEntranceBusy()) {
 				/* Road stop entrance is busy, so wait as there is nowhere else to go */
 				v->cur_speed = 0;
 				return false;
 			}
 				DEBUG(ms, 2, " current tile 0x%X is not destination tile 0x%X. Route problem", v->tile, v->dest_tile);
 			}
 			if (v->dest_tile != v->u.road.slot->xy) {
 				DEBUG(ms, 2, " stop tile 0x%X is not destination tile 0x%X. Multistop desync", v->u.road.slot->xy, v->dest_tile);
 			}
-			if (v->current_order.type != OT_GOTO_STATION) {
+			if (!v->current_order.IsType(OT_GOTO_STATION)) {
-				DEBUG(ms, 2, " current order type (%d) is not OT_GOTO_STATION", v->current_order.type);
+				DEBUG(ms, 2, " current order type (%d) is not OT_GOTO_STATION", v->current_order.GetType());
 			} else {
-				if (v->current_order.dest != st->index)
+				if (v->current_order.GetDestination() != st->index)
 					DEBUG(ms, 2, " current station %d is not target station in current_order.station (%d)",
-							st->index, v->current_order.dest);
+							st->index, v->current_order.GetDestination());
 			}
 			DEBUG(ms, 2, " force a slot clearing");
 			ClearSlot(v);
 		}
 		v->breakdown_ctr--;
 	}
 	if (v->vehstatus & VS_STOPPED) return;
-	ProcessRoadVehOrder(v);
+	ProcessOrders(v);
 	v->HandleLoading();
-	if (v->current_order.type == OT_LOADING) return;
+	if (v->current_order.IsType(OT_LOADING)) return;
 	if (v->IsInDepot() && RoadVehLeaveDepot(v, true)) return;
 	/* Check if vehicle needs to proceed, return if it doesn't */
 	if (!RoadVehAccelerate(v)) return;
 }
 static void CheckIfRoadVehNeedsService(Vehicle *v)
 {
 	/* If we already got a slot at a stop, use that FIRST, and go to a depot later */
-	if (v->u.road.slot != NULL || _patches.servint_roadveh == 0 || !VehicleNeedsService(v)) return;
+	if (v->u.road.slot != NULL || _patches.servint_roadveh == 0 || !v->NeedsAutomaticServicing()) return;
 	if (v->IsInDepot()) {
 		VehicleServiceInDepot(v);
 		return;
 	}
 	/* XXX If we already have a depot order, WHY do we search over and over? */
 	const Depot *depot = FindClosestRoadDepot(v);
 	if (depot == NULL || DistanceManhattan(v->tile, depot->xy) > 12) {
-		if (v->current_order.type == OT_GOTO_DEPOT) {
+		if (v->current_order.IsType(OT_GOTO_DEPOT)) {
-			v->current_order.type = OT_DUMMY;
+			v->current_order.MakeDummy();
-			v->current_order.flags = 0;
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 		return;
 	}
-	if (v->current_order.type == OT_GOTO_DEPOT &&
+	if (v->current_order.IsType(OT_GOTO_DEPOT) &&
-			v->current_order.flags & OFB_NON_STOP &&
+			v->current_order.GetNonStopType() & ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS &&
 			!Chance16(1, 20)) {
 		return;
 	}
-	if (v->current_order.type == OT_LOADING) v->LeaveStation();
+	if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
 	ClearSlot(v);
-	v->current_order.type = OT_GOTO_DEPOT;
+	v->current_order.MakeGoToDepot(depot->index, ODTFB_SERVICE);
-	v->current_order.flags = OFB_NON_STOP;
-	v->current_order.dest = depot->index;
 	v->dest_tile = depot->xy;
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 }
 void RoadVehicle::OnNewDay()
 	CheckIfRoadVehNeedsService(this);
 	CheckOrders(this);
 	/* Current slot has expired */
-	if (this->current_order.type == OT_GOTO_STATION && this->u.road.slot != NULL && this->u.road.slot_age-- == 0) {
+	if (this->current_order.IsType(OT_GOTO_STATION) && this->u.road.slot != NULL && this->u.road.slot_age-- == 0) {
 		DEBUG(ms, 3, "Slot expired for vehicle %d (index %d) at stop 0x%X",
 			this->unitnumber, this->index, this->u.road.slot->xy);
 		ClearSlot(this);
 	}
 	/* update destination */
-	if (!(this->vehstatus & VS_STOPPED) && this->current_order.type == OT_GOTO_STATION && this->u.road.slot == NULL && !(this->vehstatus & VS_CRASHED)) {
+	if (!(this->vehstatus & VS_STOPPED) && this->current_order.IsType(OT_GOTO_STATION) && this->u.road.slot == NULL && !(this->vehstatus & VS_CRASHED)) {
-		Station *st = GetStation(this->current_order.dest);
+		Station *st = GetStation(this->current_order.GetDestination());
 		RoadStop *rs = st->GetPrimaryRoadStop(this);
 		RoadStop *best = NULL;
 		if (rs != NULL) {
 			/* We try to obtain a slot if:

branch	NewGRF_ports
changeset 10184	fcf5fb2548eb
parent 6878	7d1ff2f621c7
child 10200	aba3af04cdbd