openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:6e81cec30a2b
+:31e38d28a0af
 		uint32 vweight = GetCargo(u->cargo_type)->weight * u->cargo_count * FreightWagonMult(u->cargo_type) / 16;
 		/* Vehicle weight is not added for articulated parts. */
 		if (!IsArticulatedPart(u)) {
 			/* vehicle weight is the sum of the weight of the vehicle and the weight of its cargo */
-			vweight += RailVehInfo(u->engine_type)->weight;
+			vweight += GetVehicleProperty(u, 0x16, RailVehInfo(u->engine_type)->weight);
 			/* powered wagons have extra weight added */
 			if (HASBIT(u->u.rail.flags, VRF_POWEREDWAGON))
 				vweight += RailVehInfo(u->u.rail.first_engine)->pow_wag_weight;
 		}
 				if (callback != CALLBACK_FAILED) u->u.rail.cached_vis_effect = callback;
 			}
 			if (rvi_v->pow_wag_power != 0 && rvi_u->railveh_type == RAILVEH_WAGON &&
-				UsesWagonOverride(u) && (u->u.rail.cached_vis_effect < 0x40)) {
+				UsesWagonOverride(u) && !HASBIT(u->u.rail.cached_vis_effect, 7)) {
 				/* wagon is powered */
 				SETBIT(u->u.rail.flags, VRF_POWEREDWAGON); // cache 'powered' status
 			} else {
 				CLRBIT(u->u.rail.flags, VRF_POWEREDWAGON);
 			}
 		u->owner = v->owner;
 		u->tile = v->tile;
 		u->x_pos = v->x_pos;
 		u->y_pos = v->y_pos;
 		u->z_pos = v->z_pos;
-		u->z_height = v->z_height;
 		u->u.rail.track = v->u.rail.track;
 		u->u.rail.railtype = v->u.rail.railtype;
 		u->build_year = v->build_year;
 		u->vehstatus = v->vehstatus & ~VS_STOPPED;
 		u->u.rail.first_engine = v->engine_type;
 		u->cargo_cap = rvi_artic->capacity;
 		u->max_speed = 0;
 		u->max_age = 0;
 		u->engine_type = engine_type;
 		u->value = 0;
-		u->type = VEH_TRAIN;
+		u = new (u) Train();
 		u->subtype = 0;
 		SetArticulatedPart(u);
 		u->cur_image = 0xAC2;
 		u->random_bits = VehicleRandomBits();
 static int32 CmdBuildRailWagon(EngineID engine, TileIndex tile, uint32 flags)
 {
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	const RailVehicleInfo *rvi = RailVehInfo(engine);
-	int32 value = (rvi->base_cost * _price.build_railwagon) >> 8;
+	int32 value = (GetEngineProperty(engine, 0x17, rvi->base_cost) * _price.build_railwagon) >> 8;
 	uint num_vehicles = 1 + CountArticulatedParts(engine);
 	if (!(flags & DC_QUERY_COST)) {
 		Vehicle *vl[11]; // Allow for wagon and upto 10 artic parts.
 			v->x_pos = x;
 			v->y_pos = y;
 			v->z_pos = GetSlopeZ(x, y);
 			v->owner = _current_player;
-			v->z_height = 6;
 			v->u.rail.track = TRACK_BIT_DEPOT;
 			v->vehstatus = VS_HIDDEN | VS_DEFPAL;
 			v->subtype = 0;
 			SetTrainWagon(v);
 //			v->day_counter = 0;
 			v->u.rail.railtype = rvi->railtype;
 			v->build_year = _cur_year;
-			v->type = VEH_TRAIN;
+			v = new (v) Train();
 			v->cur_image = 0xAC2;
 			v->random_bits = VehicleRandomBits();
 			AddArticulatedParts(vl);
 				break;
 		}
 	}
 }
-static int32 EstimateTrainCost(const RailVehicleInfo* rvi)
+static int32 EstimateTrainCost(EngineID engine, const RailVehicleInfo* rvi)
 {
-	return rvi->base_cost * (_price.build_railvehicle >> 3) >> 5;
+	return GetEngineProperty(engine, 0x17, rvi->base_cost) * (_price.build_railvehicle >> 3) >> 5;
 }
 static void AddRearEngineToMultiheadedTrain(Vehicle* v, Vehicle* u, bool building)
 {
 	u->direction = v->direction;
 	u->owner = v->owner;
 	u->tile = v->tile;
 	u->x_pos = v->x_pos;
 	u->y_pos = v->y_pos;
 	u->z_pos = v->z_pos;
-	u->z_height = 6;
 	u->u.rail.track = TRACK_BIT_DEPOT;
 	u->vehstatus = v->vehstatus & ~VS_STOPPED;
 	u->subtype = 0;
 	SetMultiheaded(u);
 	u->spritenum = v->spritenum + 1;
 	if (building) v->next = u;
 	u->engine_type = v->engine_type;
 	u->build_year = v->build_year;
 	if (building) v->value >>= 1;
 	u->value = v->value;
-	u->type = VEH_TRAIN;
+	u = new (u) Train();
 	u->cur_image = 0xAC2;
 	u->random_bits = VehicleRandomBits();
 	VehiclePositionChanged(u);
 }
 	/* We need to see if the engine got power on the tile to avoid eletric engines in non-electric depots */
 	if (!HasPowerOnRail(rvi->railtype, GetRailType(tile))) return CMD_ERROR;
 	if (rvi->railveh_type == RAILVEH_WAGON) return CmdBuildRailWagon(p1, tile, flags);
-	int32 value = EstimateTrainCost(rvi);
+	int32 value = EstimateTrainCost(p1, rvi);
 	uint num_vehicles =
 		(rvi->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1) +
 		CountArticulatedParts(p1);
 			v->tile = tile;
 			v->owner = _current_player;
 			v->x_pos = x;
 			v->y_pos = y;
 			v->z_pos = GetSlopeZ(x, y);
-			v->z_height = 6;
 			v->u.rail.track = TRACK_BIT_DEPOT;
 			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
 			v->spritenum = rvi->image_index;
 			v->cargo_type = rvi->cargo_type;
 			v->cargo_subtype = 0;
 			_new_vehicle_id = v->index;
 			v->service_interval = _patches.servint_trains;
 			v->date_of_last_service = _date;
 			v->build_year = _cur_year;
-			v->type = VEH_TRAIN;
+			v = new (v) Train();
 			v->cur_image = 0xAC2;
 			v->random_bits = VehicleRandomBits();
 			v->vehicle_flags = 0;
 			if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SETBIT(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
 	if (flags & DC_EXEC) {
 		if (v->vehstatus & VS_STOPPED && v->u.rail.track == TRACK_BIT_DEPOT) {
 			DeleteVehicleNews(p1, STR_8814_TRAIN_IS_WAITING_IN_DEPOT);
 		}
-		v->u.rail.days_since_order_progr = 0;
 		v->vehstatus ^= VS_STOPPED;
 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 	}
 	return 0;
 		} break;
 	}
 	return cost;
 }
-static void UpdateTrainDeltaXY(Vehicle *v, Direction direction)
+void Train::UpdateDeltaXY(Direction direction)
 {
-#define MKIT(a,b,c,d) ((a&0xFF)<<24) | ((b&0xFF)<<16) | ((c&0xFF)<<8) | ((d&0xFF)<<0)
+#define MKIT(a, b, c, d) ((a & 0xFF) << 24) | ((b & 0xFF) << 16) | ((c & 0xFF) << 8) | ((d & 0xFF) << 0)
 	static const uint32 _delta_xy_table[8] = {
 		MKIT(3, 3, -1, -1),
 		MKIT(3, 7, -1, -3),
 		MKIT(3, 3, -1, -1),
 		MKIT(7, 3, -3, -1),
 		MKIT(7, 3, -3, -1),
 	};
 #undef MKIT
 	uint32 x = _delta_xy_table[direction];
+	this->x_offs        = GB(x,  0, 8);
-	v->x_offs        = GB(x,  0, 8);
+	this->y_offs        = GB(x,  8, 8);
-	v->y_offs        = GB(x,  8, 8);
+	this->sprite_width  = GB(x, 16, 8);
-	v->sprite_width  = GB(x, 16, 8);
+	this->sprite_height = GB(x, 24, 8);
-	v->sprite_height = GB(x, 24, 8);
+	this->z_height      = 6;
 }
 static void UpdateVarsAfterSwap(Vehicle *v)
 {
-	UpdateTrainDeltaXY(v, v->direction);
+	v->UpdateDeltaXY(v->direction);
 	v->cur_image = GetTrainImage(v, v->direction);
 	BeginVehicleMove(v);
 	VehiclePositionChanged(v);
 	EndVehicleMove(v);
 }
 * @param flags type of operation
 * @param p1 vehicle ID of the train to refit
 * param p2 various bitstuffed elements
 * - p2 = (bit 0-7) - the new cargo type to refit to
 * - p2 = (bit 8-15) - the new cargo subtype to refit to
+* - p2 = (bit 16) - refit only this vehicle
+* @return cost of refit or error
 */
 int32 CmdRefitRailVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	CargoID new_cid = GB(p2, 0, 8);
 	byte new_subtype = GB(p2, 8, 8);
+	bool only_this = HASBIT(p2, 16);
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 	Vehicle *v = GetVehicle(p1);
 					InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 					RebuildVehicleLists();
 				}
 			}
 		}
-	} while ((v = v->next) != NULL);
+	} while ((v = v->next) != NULL && !only_this);
 	_returned_refit_capacity = num;
 	/* Update the train's cached variables */
 	if (flags & DC_EXEC) TrainConsistChanged(GetFirstVehicleInChain(GetVehicle(p1)));
 		}
 		if (p2 & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of depot orders
 		if (flags & DC_EXEC) {
 			if (HASBIT(v->current_order.flags, OFB_PART_OF_ORDERS)) {
-				v->u.rail.days_since_order_progr = 0;
 				v->cur_order_index++;
 			}
 			v->current_order.type = OT_DUMMY;
 			v->current_order.flags = 0;
 		bool disable_effect = HASBIT(v->u.rail.cached_vis_effect, 6);
 		/* no smoke? */
 		if ((rvi->railveh_type == RAILVEH_WAGON && effect_type == 0) ||
 				disable_effect ||
-				rvi->railtype > RAILTYPE_ELECTRIC ||
 				v->vehstatus & VS_HIDDEN) {
 			continue;
 		}
 		/* No smoke in depots or tunnels */
 static void TrainPlayLeaveStationSound(const Vehicle* v)
 {
 	static const SoundFx sfx[] = {
 		SND_04_TRAIN,
 		SND_0A_TRAIN_HORN,
-		SND_0A_TRAIN_HORN
+		SND_0A_TRAIN_HORN,
+		SND_47_MAGLEV_2,
+		SND_41_MAGLEV
 	};
 	if (PlayVehicleSound(v, VSE_START)) return;
 	EngineID engtype = v->engine_type;
-	switch (RailVehInfo(engtype)->railtype) {
+	SndPlayVehicleFx(sfx[RailVehInfo(engtype)->engclass], v);
-		case RAILTYPE_RAIL:
+}
-		case RAILTYPE_ELECTRIC:
-			SndPlayVehicleFx(sfx[RailVehInfo(engtype)->engclass], v);
+void Train::PlayLeaveStationSound() const
-			break;
+{
+	TrainPlayLeaveStationSound(this);
-		case RAILTYPE_MONO: SndPlayVehicleFx(SND_47_MAGLEV_2, v); break;
-		case RAILTYPE_MAGLEV: SndPlayVehicleFx(SND_41_MAGLEV, v); break;
-		default: NOT_REACHED();
-	}
 }
 static bool CheckTrainStayInDepot(Vehicle *v)
 {
 	/* bail out if not all wagons are in the same depot or not in a depot at all */
 	if (v->direction & 2) v->u.rail.track = TRACK_BIT_Y;
 	v->vehstatus &= ~VS_HIDDEN;
 	v->cur_speed = 0;
-	UpdateTrainDeltaXY(v, v->direction);
+	v->UpdateDeltaXY(v->direction);
 	v->cur_image = GetTrainImage(v, v->direction);
 	VehiclePositionChanged(v);
 	UpdateSignalsOnSegment(v->tile, DirToDiagDir(v->direction));
 	UpdateTrainAcceleration(v);
 	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	}
 	return !at_waypoint && CheckReverseTrain(v);
 }
-static void MarkTrainDirty(Vehicle *v)
+void Train::MarkDirty()
 {
+	Vehicle *v = this;
 	do {
 		v->cur_image = GetTrainImage(v, v->direction);
 		MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
 	} while ((v = v->next) != NULL);
-}
+	/* need to update acceleration and cached values since the goods on the train changed. */
-static void HandleTrainLoading(Vehicle *v, bool mode)
+	TrainCargoChanged(this);
-{
+	UpdateTrainAcceleration(this);
-	switch (v->current_order.type) {
-		case OT_LOADING: {
-			if (mode) return;
-			/* don't mark the train as lost if we're loading on the final station. */
-			if (v->current_order.flags & OF_NON_STOP) {
-				v->u.rail.days_since_order_progr = 0;
-			}
-			if (--v->load_unload_time_rem) return;
-			if (CanFillVehicle(v) && (
-						v->current_order.flags & OF_FULL_LOAD ||
-						(_patches.gradual_loading && !HASBIT(v->vehicle_flags, VF_LOADING_FINISHED))
-					)) {
-				v->u.rail.days_since_order_progr = 0; // Prevent a train lost message for full loading trains
-				SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);
-				if (LoadUnloadVehicle(v, false)) {
-					InvalidateWindow(WC_TRAINS_LIST, v->owner);
-					MarkTrainDirty(v);
-					/* need to update acceleration and cached values since the goods on the train changed. */
-					TrainCargoChanged(v);
-					UpdateTrainAcceleration(v);
-				}
-				return;
-			}
-			TrainPlayLeaveStationSound(v);
-			Order b = v->current_order;
-			v->LeaveStation();
-			/* If this was not the final order, don't remove it from the list. */
-			if (!(b.flags & OF_NON_STOP)) return;
-			break;
-		}
-		case OT_DUMMY: break;
-		default: return;
-	}
-	v->u.rail.days_since_order_progr = 0;
-	v->cur_order_index++;
-	InvalidateVehicleOrder(v);
 }
 static int UpdateTrainSpeed(Vehicle *v)
 {
 	uint accel;
 			v->index,
 			0
 		);
 	}
-	/* Did we reach the final destination? */
+	v->BeginLoading();
-	if (v->current_order.type == OT_GOTO_STATION &&
-			v->current_order.dest == station) {
-		/* Yeah, keep the load/unload flags
-		 * Non Stop now means if the order should be increased. */
-		v->BeginLoading();
-		v->current_order.flags &= OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER;
-		v->current_order.flags |= OF_NON_STOP;
-	} else {
-		/* No, just do a simple load */
-		v->BeginLoading();
-		v->current_order.flags = 0;
-	}
 	v->current_order.dest = 0;
-	SET_EXPENSES_TYPE(EXPENSES_TRAIN_INC);
-	if (LoadUnloadVehicle(v, true) != 0) {
-		InvalidateWindow(WC_TRAINS_LIST, v->owner);
-		TrainCargoChanged(v);
-		UpdateTrainAcceleration(v);
-	}
-	MarkTrainDirty(v);
-	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 }
 static byte AfterSetTrainPos(Vehicle *v, bool new_tile)
 {
 	/* need this hint so it returns the right z coordinate on bridges. */
 			}
 		}
 		/* update image of train, as well as delta XY */
 		Direction newdir = GetNewVehicleDirection(v, gp.x, gp.y);
-		UpdateTrainDeltaXY(v, newdir);
+		v->UpdateDeltaXY(newdir);
 		if (update_image) v->cur_image = GetTrainImage(v, newdir);
 		v->x_pos = gp.x;
 		v->y_pos = gp.y;
 	do {
 		/* We don't need to twist around vehicles if they're not visible */
 		if (!(v->vehstatus & VS_HIDDEN)) {
 			v->direction = ChangeDir(v->direction, delta[GB(Random(), 0, 2)]);
 			BeginVehicleMove(v);
-			UpdateTrainDeltaXY(v, v->direction);
+			v->UpdateDeltaXY(v->direction);
 			v->cur_image = GetTrainImage(v, v->direction);
 			/* Refrain from updating the z position of the vehicle when on
 			   a bridge, because AfterSetTrainPos will put the vehicle under
 			   the bridge in that case */
 			if (v->u.rail.track != TRACK_BIT_WORMHOLE) AfterSetTrainPos(v, false);
 		v->subspeed = 0;
 		ReverseTrainDirection(v);
 		return;
 	}
-	HandleTrainLoading(v, mode);
+	v->HandleLoading(mode);
 	if (v->current_order.type == OT_LOADING) return;
 	if (CheckTrainStayInDepot(v)) return;
 	if (v->current_order.type == OT_GOTO_DEPOT &&
 			v->current_order.dest != depot->index &&
 			!CHANCE16(3, 16)) {
 		return;
 	}
+	if (v->current_order.type == OT_LOADING) v->LeaveStation();
 	v->current_order.type = OT_GOTO_DEPOT;
 	v->current_order.flags = OF_NON_STOP;
 	v->current_order.dest = depot->index;
 	v->dest_tile = tfdd.tile;

branch	noai
changeset 9620	31e38d28a0af
parent 9601	b499fdd106d5
child 9624	b71483f2330f