openttd-ottdgrfs: comparison src/roadveh

equal deleted inserted replaced

-:70d78ac95d6c
+:7bd07f43b0e3
 #include "newgrf_engine.h"
 #include "newgrf_text.h"
 #include "newgrf_sound.h"
 #include "yapf/yapf.h"
 #include "date.h"
+#include "cargotype.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,
 	int32 cost;
 	Vehicle *v;
 	UnitID unit_num;
 	Engine *e;
-	if (!IsEngineBuildable(p1, VEH_Road, _current_player)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
+	if (!IsEngineBuildable(p1, VEH_ROAD, _current_player)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	cost = EstimateRoadVehCost(p1);
 	if (flags & DC_QUERY_COST) return cost;
 	v = AllocateVehicle();
 	if (v == NULL) return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
 	/* find the first free roadveh id */
-	unit_num = HASBIT(p2, 0) ? 0 : GetFreeUnitNumber(VEH_Road);
+	unit_num = HASBIT(p2, 0) ? 0 : GetFreeUnitNumber(VEH_ROAD);
 	if (unit_num > _patches.max_roadveh)
 		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
 	if (flags & DC_EXEC) {
 		int x;
 		v->service_interval = _patches.servint_roadveh;
 		v->date_of_last_service = _date;
 		v->build_year = _cur_year;
-		v->type = VEH_Road;
+		v->type = VEH_ROAD;
 		v->cur_image = 0xC15;
 		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_Road); // updates the replace Road window
+			InvalidateAutoreplaceWindow(VEH_ROAD); // updates the replace Road window
 		GetPlayer(_current_player)->num_engines[p1]++;
 	}
 	return cost;
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	v = GetVehicle(p1);
-	if (v->type != VEH_Road || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
 	/* Check if this road veh can be started/stopped. The callback will fail or
 	 * return 0xFF if it can. */
 	callback = GetVehicleCallback(CBID_VEHICLE_START_STOP_CHECK, 0, 0, v->engine_type, v);
 	if (callback != CALLBACK_FAILED && callback != 0xFF) {
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	v = GetVehicle(p1);
-	if (v->type != VEH_Road || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	if (!IsRoadVehInDepotStopped(v)) {
 		return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
 	}
 	return -(int32)v->value;
 }
-typedef struct RoadFindDepotData {
+struct RoadFindDepotData {
 	uint best_length;
 	TileIndex tile;
 	OwnerByte owner;
-} RoadFindDepotData;
+};
 static const DiagDirection _road_pf_directions[] = {
 	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, INVALID_DIAGDIR, INVALID_DIAGDIR,
 	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE, INVALID_DIAGDIR, INVALID_DIAGDIR
 };
 	const Depot *dep;
 	if (p2 & DEPOT_MASS_SEND) {
 		/* Mass goto depot requested */
 		if (!ValidVLWFlags(p2 & VLW_MASK)) return CMD_ERROR;
-		return SendAllVehiclesToDepot(VEH_Road, flags, p2 & DEPOT_SERVICE, _current_player, (p2 & VLW_MASK), p1);
+		return SendAllVehiclesToDepot(VEH_ROAD, flags, p2 & DEPOT_SERVICE, _current_player, (p2 & VLW_MASK), p1);
 	}
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	v = GetVehicle(p1);
-	if (v->type != VEH_Road || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
 	if (IsRoadVehInDepot(v)) return CMD_ERROR;
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	v = GetVehicle(p1);
-	if (v->type != VEH_Road || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (v->vehstatus & VS_STOPPED ||
 			v->u.road.crashed_ctr != 0 ||
 			v->breakdown_ctr != 0 ||
 			v->u.road.overtaking != 0 ||
 static void* EnumCheckRoadVehCrashTrain(Vehicle* v, void* data)
 {
 	const Vehicle* u = (Vehicle*)data;
 	return
-		v->type == VEH_Train &&
+		v->type == VEH_TRAIN &&
 		myabs(v->z_pos - u->z_pos) <= 6 &&
 		myabs(v->x_pos - u->x_pos) <= 4 &&
 		myabs(v->y_pos - u->y_pos) <= 4 ?
 			v : NULL;
 }
 	ClearSlot(v);
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 	pass = 1;
-	if (v->cargo_type == CT_PASSENGERS) pass += v->cargo_count;
+	if (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) pass += v->cargo_count;
 	v->cargo_count = 0;
 	SetDParam(0, pass);
 	AddNewsItem(
 		(pass == 1) ?
 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
 	order = GetVehicleOrder(v, v->cur_order_index);
 	if (order == NULL) {
-		v->current_order.type = OT_NOTHING;
+		v->current_order.Free();
-		v->current_order.flags = 0;
 		v->dest_tile = 0;
 		ClearSlot(v);
 		return;
 	}
 			if (order->dest == v->last_station_visited) {
 				v->last_station_visited = INVALID_STATION;
 			}
 			rs = GetStation(order->dest)->GetPrimaryRoadStop(
-				v->cargo_type == CT_PASSENGERS ? RoadStop::BUS : RoadStop::TRUCK
+				IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK
 			);
 			if (rs != NULL) {
 				TileIndex dest = rs->xy;
 				uint mindist = DistanceManhattan(v->tile, rs->xy);
 			s = SND_1A_BUS_START_PULL_AWAY_WITH_HORN;
 		SndPlayVehicleFx(s, v);
 	}
 }
-typedef struct RoadVehFindData {
+struct RoadVehFindData {
 	int x;
 	int y;
 	const Vehicle* veh;
 	Direction dir;
-} RoadVehFindData;
+};
 static void* EnumCheckRoadVehClose(Vehicle *v, void* data)
 {
 	static const int8 dist_x[] = { -4, -8, -4, -1, 4, 8, 4, 1 };
 	static const int8 dist_y[] = { -4, -1, 4, 8, 4, 1, -4, -8 };
 	short x_diff = v->x_pos - rvf->x;
 	short y_diff = v->y_pos - rvf->y;
 	return
 		rvf->veh != v &&
-		v->type == VEH_Road &&
+		v->type == VEH_ROAD &&
 		!IsRoadVehInDepot(v) &&
 		myabs(v->z_pos - rvf->veh->z_pos) < 6 &&
 		v->direction == rvf->dir &&
 		(dist_x[v->direction] >= 0 || (x_diff > dist_x[v->direction] && x_diff <= 0)) &&
 		(dist_x[v->direction] <= 0 || (x_diff < dist_x[v->direction] && x_diff >= 0)) &&
 	return u;
 }
 static void RoadVehArrivesAt(const Vehicle* v, Station* st)
 {
-	if (v->cargo_type == CT_PASSENGERS) {
+	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;
 	if (new_dir == old_dir) return old_dir;
 	delta = (DirDifference(new_dir, old_dir) > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
 	return ChangeDir(old_dir, delta);
 }
-typedef struct OvertakeData {
+struct OvertakeData {
 	const Vehicle* u;
 	const Vehicle* v;
 	TileIndex tile;
 	byte tilebits;
-} OvertakeData;
+};
 static void* EnumFindVehToOvertake(Vehicle* v, void* data)
 {
 	const OvertakeData* od = (OvertakeData*)data;
 	return
-		v->tile == od->tile && v->type == VEH_Road && v != od->u && v != od->v ?
+		v->tile == od->tile && v->type == VEH_ROAD && v != od->u && v != od->v ?
 			v : NULL;
 }
 static bool FindRoadVehToOvertake(OvertakeData *od)
 {
 	for (i = 0; !(bits & 1) || (int)--num >= 0; bits >>= 1, i++) {}
 	return i;
 }
-typedef struct {
+struct FindRoadToChooseData {
 	TileIndex dest;
 	uint maxtracklen;
 	uint mindist;
-} FindRoadToChooseData;
+};
 static bool EnumRoadTrackFindDist(TileIndex tile, void* data, Trackdir trackdir, uint length, byte* state)
 {
 	FindRoadToChooseData* frd = (FindRoadToChooseData*)data;
 	uint dist = DistanceManhattan(tile, frd->dest);
 		if (!IsTileOwner(tile, v->owner) || GetRoadStopDir(tile) == enterdir) {
 			/* different station owner or wrong orientation */
 			trackdirs = TRACKDIR_BIT_NONE;
 		} else {
 			/* Our station */
-			RoadStop::Type rstype = (v->cargo_type == CT_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK;
+			RoadStop::Type rstype = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK;
 			if (GetRoadStopType(tile) != rstype) {
 				/* Wrong station type */
 				trackdirs = TRACKDIR_BIT_NONE;
 			} else {
 	RVC_DEPOT_START_FRAME        = 6,
 	/* Stop frame for a vehicle in a drive-through stop */
 	RVC_DRIVE_THROUGH_STOP_FRAME = 7
 };
-typedef struct RoadDriveEntry {
+struct RoadDriveEntry {
-	byte x,y;
+	byte x, y;
-} RoadDriveEntry;
+};
 #include "table/roadveh.h"
 static const byte _road_veh_data_1[] = {
 	20, 20, 16, 16, 0, 0, 0, 0,
 	 * a through route, do not stop) */
 	if ((IS_BYTE_INSIDE(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) ||
 			(IS_BYTE_INSIDE(v->u.road.state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END) &&
 			v->current_order.dest == GetStationIndex(v->tile) &&
-			GetRoadStopType(v->tile) == ((v->cargo_type == CT_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 has arrived at a bay in a road stop */
 			Order old_order;
 			if (IsDriveThroughStopTile(v->tile)) {
 				TileIndex next_tile = TILE_ADD(v->tile, TileOffsByDir(v->direction));
-				RoadStop::Type type = (v->cargo_type == CT_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK;
+				RoadStop::Type type = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK;
 				assert(HASBIT(v->u.road.state, RVS_IS_STOPPING));
 				/* Check if next inline bay is free */
 				if (IsDriveThroughStopTile(next_tile) && (GetRoadStopType(next_tile) == type)) {
 			if (rs->IsEntranceBusy()) {
 				/* Road stop entrance is busy, so wait as there is nowhere else to go */
 				v->cur_speed = 0;
 				return;
 			}
-			v->current_order.type = OT_NOTHING;
+			v->current_order.Free();
-			v->current_order.flags = 0;
 			ClearSlot(v);
 		}
 		if (IsStandardRoadStopTile(v->tile)) rs->SetEntranceBusy(true);
 	if (v->vehstatus & VS_STOPPED) return;
 	/* update destination */
 	if (v->current_order.type == OT_GOTO_STATION && v->u.road.slot == NULL && !(v->vehstatus & VS_CRASHED)) {
 		Station* st = GetStation(v->current_order.dest);
-		RoadStop* rs = st->GetPrimaryRoadStop(v->cargo_type == CT_PASSENGERS ? RoadStop::BUS : RoadStop::TRUCK);
+		RoadStop* rs = st->GetPrimaryRoadStop(IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK);
 		RoadStop* best = NULL;
 		if (rs != NULL) {
 			/* We try to obtain a slot if:
 			 * 1) we're reasonably close to the primary road stop
 	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 	InvalidateWindowClasses(WC_ROADVEH_LIST);
 }
-void RoadVehiclesYearlyLoop(void)
+void RoadVehiclesYearlyLoop()
 {
 	Vehicle *v;
 	FOR_ALL_VEHICLES(v) {
-		if (v->type == VEH_Road) {
+		if (v->type == VEH_ROAD) {
 			v->profit_last_year = v->profit_this_year;
 			v->profit_this_year = 0;
 			InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 		}
 	}
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	v = GetVehicle(p1);
-	if (v->type != VEH_Road || !CheckOwnership(v->owner)) return CMD_ERROR;
+	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (!IsRoadVehInDepotStopped(v)) return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
-	if (new_cid > NUM_CARGO || !CanRefitTo(v->engine_type, new_cid)) return CMD_ERROR;
+	if (new_cid >= NUM_CARGO || !CanRefitTo(v->engine_type, new_cid)) return CMD_ERROR;
 	SET_EXPENSES_TYPE(EXPENSES_ROADVEH_RUN);
 	if (HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_REFIT_CAPACITY)) {
 		/* Back up the cargo type */

branch	gamebalance
changeset 9895	7bd07f43b0e3
parent 6502	7ca154aca2b7
child 9903	dc85aaa556ae