Release v2.1.0: fix packaged samples, product picker + quality pricing

- Fix "That ain't packaged" when giving Marco a sample: read the inventory
  instead of the in-hand item (the game empties it during conversations)
- Sample discount is now per single package, not the whole remaining stack
- Add a picker: choose which packaged product to hand Marco
- Marco now visibly consumes the sample (animation, sound, effects)
- Quality scales the discount (Trash 0.6x up to Heavenly 2.0x)
- Re-point the quest marker after a menu reload so the wrench no longer breaks
- Debug-only "rvtest" console helper to spawn packaged test products

Author: DooDesch

CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to RVRepairVan are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 project adheres to Semantic Versioning.
 
+## [2.1.0] - 2026-06-24
+
+### Fixed
+- Giving Marco a packaged sample no longer fails with "That ain't packaged" while you are
+  holding sealed product. The check now reads your inventory instead of the in-hand item,
+  which the game empties while a conversation is open.
+- Each sample's discount is now based on the value of the single package you hand over,
+  rather than scaling with how many were left in the stack.
+- The quest marker (the wrench) could end up pointing nowhere after returning to the main
+  menu and reloading a save; it now re-points to the right target once the world finishes
+  loading.
+
+### Added
+- You can now choose which packaged product to give Marco: the dialogue lists each packaged
+  product you are carrying together with the discount it would give.
+- Marco actually consumes the sample you hand him now (the matching smoke/snort/eat
+  animation and effects), instead of just taking it.
+- Marco pays more for cleaner product and less for junk: the per-sample discount is scaled
+  by quality (Trash 0.6x up to Heavenly 2.0x).
+- Experimental host-authoritative co-op support. Single-player is unaffected; co-op has
+  only had limited testing, so please report any multiplayer issues.
+
 ## [2.0.1] - 2026-06-17
 
 ### Added

Core.cs

@@ -7,7 +7,7 @@
 using RVRepairVan.Persistence;
 using RVRepairVan.Quests;
 
-[assembly: MelonInfo(typeof(RVRepairVan.Core), "RVRepairVan", "2.0.1", "DooDesch", null)]
+[assembly: MelonInfo(typeof(RVRepairVan.Core), "RVRepairVan", "2.1.0", "DooDesch", null)]
 [assembly: MelonGame("TVGS", "Schedule I")]
 
 namespace RVRepairVan

Patches/DebugConsolePatch.cs

@@ -0,0 +1,60 @@
+#if DEBUG
+using System;
+using HarmonyLib;
+using Il2CppScheduleOne.Product.Packaging;            // PackagingDefinition
+
+namespace RVRepairVan.Patches
+{
+    /// <summary>
+    /// DEBUG-only test helper. Typing <c>rvtest</c> in the dev console drops a set of pre-packaged products at every
+    /// quality into the inventory, so the Marco sample / quality-multiplier flow can be tested without manually
+    /// equipping + setquality + packageproduct each one (packageproduct only works on the equipped-in-hand item).
+    /// Usage: <c>rvtest</c> (jar OG Kush) or <c>rvtest &lt;packaging&gt; &lt;productId&gt;</c>. Compiled out of Release.
+    /// </summary>
+    [HarmonyPatch(typeof(Il2CppScheduleOne.Console), nameof(Il2CppScheduleOne.Console.SubmitCommand), new Type[] { typeof(Il2CppSystem.Collections.Generic.List<string>) })]
+    internal static class DebugConsolePatch
+    {
+        private static readonly EQuality[] Qualities =
+            { EQuality.Trash, EQuality.Poor, EQuality.Standard, EQuality.Premium, EQuality.Heavenly };
+
+        private static bool Prefix(Il2CppSystem.Collections.Generic.List<string> args)
+        {
+            try
+            {
+                if (args == null || args.Count == 0) return true;   // not ours - let the game handle it
+                if (!string.Equals(args[0], "rvtest", StringComparison.OrdinalIgnoreCase)) return true;
+
+                string packaging = args.Count > 1 ? args[1] : "jar";
+                string product = args.Count > 2 ? args[2] : "ogkush";
+                GiveTestProducts(packaging, product);
+                return false;   // handled - skip the game's dispatcher (avoids "command not found")
+            }
+            catch (Exception e) { Core.Log.Warning("[Debug] rvtest failed: " + e.Message); return false; }
+        }
+
+        private static void GiveTestProducts(string packagingId, string productId)
+        {
+            PlayerInventory inv = PlayerSingleton<PlayerInventory>.Instance;
+            if (inv == null) { Core.Log.Warning("[Debug] rvtest: no PlayerInventory."); return; }
+
+            ProductDefinition def = Il2CppScheduleOne.Registry.GetItem(productId.ToLower())?.TryCast<ProductDefinition>();
+            PackagingDefinition pkg = Il2CppScheduleOne.Registry.GetItem(packagingId.ToLower())?.TryCast<PackagingDefinition>();
+            if (def == null) { Core.Log.Warning("[Debug] rvtest: unknown product '" + productId + "'."); return; }
+            if (pkg == null) { Core.Log.Warning("[Debug] rvtest: unknown packaging '" + packagingId + "'."); return; }
+
+            int given = 0;
+            foreach (EQuality q in Qualities)
+            {
+                ProductItemInstance inst = def.GetDefaultInstance(1)?.TryCast<ProductItemInstance>();
+                if (inst == null) continue;
+                inst.Quality = q;
+                inst.SetPackaging(pkg);   // the exact call the 'packageproduct' console command uses
+                if (!inv.CanItemFitInInventory(inst)) { Core.Log.Warning("[Debug] rvtest: inventory full at " + q + "."); break; }
+                inv.AddItemToInventory(inst);
+                given++;
+            }
+            Core.Log.Msg("[Debug] rvtest: gave " + given + " packaged " + def.Name + " (" + pkg.Name + ") - one per quality.");
+        }
+    }
+}
+#endif

Quests/Questline.cs

@@ -58,6 +58,12 @@ internal static partial class Questline
         private static Transform _donnaT, _mingT, _marcoT;
         private static DialogueController.DialogueChoice _marcoRepairChoice;
 
+        // Sample picker: one Marco dialogue choice per packaged product the player holds (so they choose WHICH to
+        // hand over). Capped at the hotbar size; _sampleSlots is the live snapshot the choices/handler index into.
+        private const int MAX_SAMPLE_CHOICES = 8;
+        private static readonly DialogueController.DialogueChoice[] _sampleChoices = new DialogueController.DialogueChoice[MAX_SAMPLE_CHOICES];
+        private static readonly System.Collections.Generic.List<ItemSlot> _sampleSlots = new System.Collections.Generic.List<ItemSlot>();
+
         // The host is authoritative: any host-side write to Stage / DiscountTotal auto-replicates to all clients
         // (single StageSync broadcast). Offline and client writes don't broadcast (client writes only happen via
         // ApplyStageSync, which uses RepairStateStore directly to avoid echoing). This is the one choke point that
@@ -132,6 +138,8 @@ internal static void Reset()
             _cratePoint = Vector3.zero;
             _donnaT = _mingT = _marcoT = null;
             _marcoRepairChoice = null;
+            System.Array.Clear(_sampleChoices, 0, _sampleChoices.Length);
+            _sampleSlots.Clear();
         }
 
         internal static void Start()
@@ -175,7 +183,22 @@ private static IEnumerator SetupCoroutine()
                 }
             }
             if (myGen == _gen)
+            {
                 Core.LogDebug($"[Questline] all NPC dialogue injected: Donna={_donnaDone} Ming={_mingDone} Marco={_marcoDone}");
+                // The NPC transforms are only resolved now. On a fresh load RestoreCoroutine's first SyncEntry runs on
+                // a fixed ~4s timer - often BEFORE Marco/Ming exist - so MarcoPos() falls back to RvPos()/zero and the
+                // quest POI (the wrench marker) is left pointing nowhere, never re-pointed. Re-sync once here with the
+                // real positions (host/offline only; a co-op client's POI is driven by the host snapshot).
+                try
+                {
+                    if (!(NetworkBus.Online && !NetworkBus.IsServer) && Active && Stage >= Started && Stage < Done)
+                    {
+                        EnsureQuest();
+                        Core.LogDebug("[Questline] post-inject POI re-sync (Marco resolved=" + (_marcoT != null) + ").");
+                    }
+                }
+                catch (Exception e) { Core.Log.Warning("[Questline] post-inject POI sync failed: " + e.Message); }
+            }
         }
 
         // Inject each NPC independently, looked up by id in the game's NPC registry.
@@ -279,10 +302,15 @@ private static void InjectMarco(DialogueController marco, NPC npc)
             AddChoice(marco, "I lost your package.", 96,
                 () => Active && _pickupActive && _hasPackage && _pkgPlaced && !PlayerHasItem(PackageId), null, lostpkg);
 
-            // Sample option only appears while you're actually holding packaged product (and there's still room
-            // above the price floor). Trust must already be earned (Stage >= Trusted).
-            AddChoice(marco, "Give Marco a packaged sample", 95,
-                () => Active && Trusted_ && Stage < Paid && HoldingPackaged() && CurrentPrice() > RVRepairVanPreferences.RepairPrice, OnGiveSample);
+            // One sample entry per packaged product the player holds, so they pick WHICH to hand over. Each entry is
+            // shown live (SampleChoiceVisible) only while trust is earned (Stage >= Trusted) and the price is still
+            // above the floor; its label is set to that product's name + per-unit value right before it's drawn.
+            for (int s = 0; s < MAX_SAMPLE_CHOICES; s++)
+            {
+                int idx = s;
+                _sampleChoices[idx] = AddChoice(marco, "Give Marco a packaged sample", 95 - idx,
+                    () => SampleChoiceVisible(idx), () => OnGiveSample(idx));
+            }
 
             // Persistent reminder once trust is earned: tells players (who may have skipped the dialogue) HOW to
             // keep lowering the price. Shows whenever they're NOT currently holding product to hand over (when they
@@ -649,33 +677,37 @@ private static void OnMarcoPayLoss()
             SyncEntry();
         }
 
-        private static void OnGiveSample()
+        // Give Marco one packaged product. i indexes the snapshot the choice list was built from (RefreshSampleSlots),
+        // so the player hands over exactly the product they picked; falls back to the first packaged product if the
+        // index is stale. Reads from inventory (not the equipped item, which is null during a conversation).
+        private static void OnGiveSample(int i)
         {
             try
             {
-                PlayerInventory inv = PlayerSingleton<PlayerInventory>.Instance;
-                ProductItemInstance product = inv?.EquippedItem?.TryCast<ProductItemInstance>();
+                RefreshSampleSlots();
+                ItemSlot slot = (i >= 0 && i < _sampleSlots.Count) ? _sampleSlots[i] : FindPackagedProductSlot();
+                ProductItemInstance product = slot?.ItemInstance?.TryCast<ProductItemInstance>();
                 if (product == null || product.AppliedPackaging == null)
                 {
                     WorldSay(_marcoT, "That ain't packaged. Hand me something sealed.");
                     return;
                 }
-                int discount = Mathf.Clamp(Mathf.RoundToInt(product.GetMonetaryValue()),
-                    RVRepairVanPreferences.MinSampleDiscount, RVRepairVanPreferences.MaxSampleDiscount);
-
-                // Marco TAKES it and consumes it (real consume animation + effects), like handing a free sample
-                // to a non-customer. We pass removeFromInventory:FALSE and remove exactly ONE unit ourselves:
-                // SendProduct's native removal quantity is unverifiable (body lives in GameAssembly.dll) and could
-                // wipe a whole stack >1. Removing one deterministically protects the player's stack either way.
+                int discount = SampleUnitDiscount(product);
+
+                // Marco actually consumes it: NPCBehaviour.ConsumeProduct (the ServerRpc the vanilla sample flow uses)
+                // both sets the product AND enables the consume behaviour, so he plays the smoke/snort/eat animation,
+                // sound and particles and the product's effects apply to him - and it replicates in co-op. Earlier we
+                // only called SendProduct (sets the product, never starts the behaviour), so nothing happened visibly.
+                // removeFromInventory:FALSE - that flag only touches the NPC's own inventory; we remove exactly one
+                // unit from the player ourselves below (deterministic; protects a stack > 1).
                 NPC marco = FindNpc(MarcoId);
-                var cpb = (marco != null && marco.Behaviour != null) ? marco.Behaviour.ConsumeProductBehaviour : null;
-                int before = (inv != null && inv.equippedSlot != null) ? inv.equippedSlot.Quantity : -1;
-                if (cpb != null) cpb.SendProduct(product, false);   // consume/animate, but don't let it touch inventory
-                if (inv != null && inv.equippedSlot != null) RemoveOneFromSlot(inv.equippedSlot);   // exactly one (clears the slot if it was the last)
-                int after = (inv != null && inv.equippedSlot != null) ? inv.equippedSlot.Quantity : -1;
-                Core.LogDebug("[Questline] sample given: equipped qty " + before + " -> " + after + " (expected -1).");
-
-                // The consume above is the ACTING player's local action (per-player inventory; SendProduct is a
+                int before = slot != null ? slot.Quantity : -1;
+                if (marco != null && marco.Behaviour != null) marco.Behaviour.ConsumeProduct(product, false);
+                RemoveOneFromSlot(slot);   // exactly one from the slot we found (clears it if it was the last)
+                int after = slot != null ? slot.Quantity : -1;
+                Core.LogDebug("[Questline] sample given: hotbar qty " + before + " -> " + after + " (expected -1).");
+
+                // The consume above is the ACTING player's local action (per-player inventory; ConsumeProduct is a
                 // ServerRpc so Marco's eating replicates). The DISCOUNT is shared state - the host owns it. Client:
                 // send the discount it computed and let the host apply + replicate the new price.
                 if (RouteIntent(RvOp.GiveSample, discount))
@@ -688,6 +720,68 @@ private static void OnGiveSample()
             catch (Exception e) { Core.Log.Warning("[Questline] give sample failed: " + e.Message); }
         }
 
+        // Per-sample discount = the value of the ONE package handed over, NOT the whole stack. GetMonetaryValue() is
+        // MarketValue * Quantity * Amount (scales with stack size), so divide by Quantity to get a single unit's
+        // worth, then clamp to the configured min/max.
+        private static int SampleUnitDiscount(ProductItemInstance p)
+        {
+            int qty = Mathf.Max(1, ((BaseItemInstance)p).Quantity);
+            // Per-package value (GetMonetaryValue already folds in product type + effects via MarketValue, and the
+            // packaging size via Amount) times a Marco-specific quality bonus/penalty, finally clamped to min/max.
+            float unit = (p.GetMonetaryValue() / qty) * QualityMultiplier(p.Quality);
+            return Mathf.Clamp(Mathf.RoundToInt(unit), RVRepairVanPreferences.MinSampleDiscount, RVRepairVanPreferences.MaxSampleDiscount);
+        }
+
+        // Marco pays more for cleaner product, less for junk. The game's own monetary value is quality-independent,
+        // so this is a Marco-only sweetener. EQuality order: Trash, Poor, Standard, Premium, Heavenly.
+        private static float QualityMultiplier(EQuality q)
+        {
+            switch (q)
+            {
+                case EQuality.Trash: return 0.6f;
+                case EQuality.Poor: return 0.8f;
+                case EQuality.Premium: return 1.5f;
+                case EQuality.Heavenly: return 2.0f;
+                default: return 1.0f;   // Standard
+            }
+        }
+
+        // Snapshot every inventory slot currently holding a packaged product (capped at the choice count). Rebuilt
+        // each time the choices are evaluated/picked so the list always reflects what the player holds right now.
+        private static void RefreshSampleSlots()
+        {
+            _sampleSlots.Clear();
+            var slots = PlayerSingleton<PlayerInventory>.Instance?.GetAllInventorySlots();
+            if (slots == null) return;
+            for (int i = 0; i < slots.Count && _sampleSlots.Count < MAX_SAMPLE_CHOICES; i++)
+            {
+                ItemSlot slot = slots[i];
+                ProductItemInstance p = slot?.ItemInstance?.TryCast<ProductItemInstance>();
+                if (p != null && p.AppliedPackaging != null) _sampleSlots.Add(slot);
+            }
+        }
+
+        // Live visibility + label for the i-th sample choice. Shown only with trust earned and room above the floor;
+        // refreshes the snapshot and (the game calls this right before drawing) sets this entry's label to the i-th
+        // packaged product's name + per-unit value.
+        private static bool SampleChoiceVisible(int i)
+        {
+            if (!(Active && Trusted_ && Stage < Paid && CurrentPrice() > RVRepairVanPreferences.RepairPrice)) return false;
+            RefreshSampleSlots();
+            if (i >= _sampleSlots.Count) return false;
+            ProductItemInstance p = _sampleSlots[i]?.ItemInstance?.TryCast<ProductItemInstance>();
+            if (p == null) return false;
+            if (_sampleChoices[i] != null) _sampleChoices[i].ChoiceText = SampleChoiceText(p);
+            return true;
+        }
+
+        private static string SampleChoiceText(ProductItemInstance p)
+        {
+            string name = "product";
+            try { ItemDefinition def = p.Definition; if (def != null) name = def.Name; } catch { }
+            return "Give Marco: " + name + " (-" + MoneyManager.FormatAmount(SampleUnitDiscount(p)) + ")";
+        }
+
         // Host-only (or offline): apply a sample's discount to the shared price. Safe when the host is processing a
         // client's GiveSample intent (the client already consumed its own product) - no inventory touch here.
         private static void HostGiveSample(int discount)
@@ -1034,16 +1128,28 @@ private static DialogueController.DialogueChoice AddChoice(DialogueController dc
             return choice;
         }
 
-        /// <summary>True if the player is currently holding a PACKAGED product (peek only, no consume).</summary>
-        private static bool HoldingPackaged()
+        /// <summary>True if the player has a PACKAGED product anywhere in the hotbar (peek only, no consume).</summary>
+        private static bool HoldingPackaged() => FindPackagedProductSlot() != null;
+
+        /// <summary>The inventory slot holding a PACKAGED product, or null. Scans GetAllInventorySlots (hotbar +
+        /// cash) - the exact source the vanilla HandoverScreen sample flow reads - instead of the equipped item:
+        /// opening an NPC conversation holsters/unequips the player, so EquippedItem and equippedSlot both go null
+        /// mid-dialogue even though the sealed product is still in the inventory.</summary>
+        private static ItemSlot FindPackagedProductSlot()
         {
             try
             {
-                PlayerInventory inv = PlayerSingleton<PlayerInventory>.Instance;
-                ProductItemInstance p = inv?.EquippedItem?.TryCast<ProductItemInstance>();
-                return p != null && p.AppliedPackaging != null;
+                var slots = PlayerSingleton<PlayerInventory>.Instance?.GetAllInventorySlots();
+                if (slots == null) return null;
+                for (int i = 0; i < slots.Count; i++)
+                {
+                    ItemSlot slot = slots[i];
+                    ProductItemInstance p = slot?.ItemInstance?.TryCast<ProductItemInstance>();
+                    if (p != null && p.AppliedPackaging != null) return slot;
+                }
             }
-            catch { return false; }
+            catch { }
+            return null;
         }
 
         private static void RefreshRepairChoice()

RVRepairVan.csproj

@@ -23,9 +23,9 @@
     <RootNamespace>RVRepairVan</RootNamespace>
     <AssemblyName>RVRepairVan</AssemblyName>
     <NeutralLanguage>en-US</NeutralLanguage>
-    <Version>2.0.1</Version>
-    <AssemblyVersion>2.0.1.0</AssemblyVersion>
-    <FileVersion>2.0.1.0</FileVersion>
+    <Version>2.1.0</Version>
+    <AssemblyVersion>2.1.0.0</AssemblyVersion>
+    <FileVersion>2.1.0.0</FileVersion>
     <!-- Suppress MSB3277/MSB3245 noise from il2cpp interop transitive refs -->
     <NoWarn>$(NoWarn);MSB3277;MSB3245</NoWarn>