v1.1.0 (#2)

* Add SteamLobbyMetadataHandler to handle all synchronisation

Now SynchronisedMetadata and PriceSynchroniser both use the same shared static class. Also fixes a remnant from when SynchronisedMetadata was not generic, so now new subtypes will not create their own SteamAPI subscriptions

* Update Shop.cs

* Update manifests and changelog

* Add UpdateItemPrice

* Add check for valid item category during registration

* Fix SteamLobbyMetadataHandler not synchronising after leaving and joining a new lobby

So this was a thing. Weirdly this passed a group beta test initially so I am really not sure what happened there, because after some digging the previous implementation should have never worked.

* Update PriceSynchroniser to reload the store when prices are synced

* Update docs and manifest

Author: Xerren09

PriceSynchroniser.cs

@@ -5,46 +5,63 @@ namespace ContentWarningShop
 {
     internal class PriceSynchroniser
     {
-        private static Callback<LobbyCreated_t> cb_onLobbyCreated;
-        private static Callback<LobbyEnter_t> cb_onLobbyEntered;
-        private static bool IsHost => SteamMatchmaking.GetLobbyOwner(LobbyID) == SteamUser.GetSteamID();
-        private static CSteamID LobbyID {  get; set; }
-
         internal static void RegisterCallbacks()
         {
-            cb_onLobbyCreated = Callback<LobbyCreated_t>.Create(OnLobbyCreated);
-            cb_onLobbyEntered = Callback<LobbyEnter_t>.Create(OnLobbyEntered);
+            SteamLobbyMetadataHandler.OnLobbyJoined += SyncPrices;
+            SteamLobbyMetadataHandler.OnLobbyDataUpdate += OnLobbyDataUpdate;
         }
 
-        private static void OnLobbyCreated(LobbyCreated_t e)
+        private static void OnLobbyDataUpdate()
         {
-            if (e.m_eResult != EResult.k_EResultOK)
+            if (SteamLobbyMetadataHandler.IsHost)
             {
                 return;
             }
-            LobbyID = new(e.m_ulSteamIDLobby);
+            SyncPrices();
+        }
+
+        private static void SyncPrices()
+        {
             foreach (var item in Shop._items)
             {
-                var key = $"__{item.PersistentID}_price";
-                SteamMatchmaking.SetLobbyData(LobbyID, key, $"{item.price}");
-                Debug.Log($"Item price registered: {item.name} ({key}) = {item.price}");
+                SyncPrice(item);
             }
         }
 
-        private static void OnLobbyEntered(LobbyEnter_t e)
+        internal static void SyncPrice(Item item)
         {
-            if (IsHost == true)
+            if (SteamLobbyMetadataHandler.InLobby == false)
             {
                 return;
             }
-            LobbyID = new(e.m_ulSteamIDLobby);
-            foreach (var item in Shop._items)
+            var key = $"{ShopApiPlugin.MOD_GUID}_item_{item.PersistentID}_price";
+            var changed = false;
+            if (SteamLobbyMetadataHandler.IsHost)
+            {
+                SteamMatchmaking.SetLobbyData(SteamLobbyMetadataHandler.CurrentLobby, key, $"{item.price}");
+                changed = true;
+            }
+            else
+            {
+                var strVal = SteamMatchmaking.GetLobbyData(SteamLobbyMetadataHandler.CurrentLobby, key);
+                var val = int.Parse(strVal);
+                changed = item.price != val;
+                item.price = val;
+            }
+            if (changed && ShopHandler.Instance != null)
             {
-                var key = $"__{item.PersistentID}_price";
-                var strVal = SteamMatchmaking.GetLobbyData(LobbyID, key);
-                item.price = int.Parse(strVal);
-                Debug.Log($"Item price synchronised: {item.name} ({key}) = {item.price}");
+                if (ShopHandler.Instance.m_CategoryItemDic.ContainsKey(item.Category) == false)
+                {
+                    return;
+                }
+                var idx = ShopHandler.Instance.m_CategoryItemDic[item.Category].FindIndex(shopItem => shopItem.Item == item);
+                var newItem = new ShopItem(item);
+                ShopHandler.Instance.m_CategoryItemDic[item.Category][idx] = newItem;
+                ShopHandler.Instance.m_ItemsForSaleDictionary[item.id] = newItem;
+                // Does not actually call the RPC, this is the local effect
+                ShopHandler.Instance.RPCA_ClearCart();
             }
+            Debug.Log($"Item price synchronised: {item.name} ({key}) = {item.price}");
         }
     }
 }

README.md

@@ -34,7 +34,7 @@ Use the `RegisterItem` method to register an `Item` to the shop. Ideally the ite
 Make sure to set the `persistentID`, `price`, `purchasable`, `Category`, and `icon` properties at the very least to ensure the item will show up correctly in the store.
 
 > [!NOTE]
-> Item prices are automatically synchronised between players on lobby join. The price set by the lobby's host will be used for the entire lobby. Once a lobby has been created, the price can not be changed.
+> Item prices are automatically synchronised between players on lobby join. The price set by the lobby's host will be used for the entire lobby. Once a lobby has been created, the price of a registered item can be updated via `UpdateItemPrice`.
 
 You can check if a custom item has been already registered via the `IsItemRegistered` method. The list of **all** registered custom items is also available via the `CustomItems` property.
 

Shop.cs

@@ -63,9 +63,13 @@ public static void RegisterItem(Item item)
             Debug.LogWarning($"Item {item.displayName} ({item.persistentID}) already registered.");
             return;
         }
+        if (item.Category == ShopItemCategory.Invalid)
+        {
+            throw new Exception($"Item {item.displayName} ({item.persistentID}) shop category is set to {nameof(ShopItemCategory.Invalid)}.");
+        }
         _items.Add(item);
         SingletonAsset<ItemDatabase>.Instance.AddRuntimeEntry(item);
-        Debug.LogWarning($"Registered custom item: {item.displayName} ({item.persistentID}) [{Assembly.GetCallingAssembly().GetSimpleName()}].");
+        Debug.Log($"Registered custom item: {item.displayName} ({item.persistentID}) [{Assembly.GetCallingAssembly().GetSimpleName()}].");
     }
 
     /// <summary>
@@ -98,6 +102,35 @@ public static void RegisterCustomDataEntries()
         }
     }
 
+    /// <summary>
+    /// Updates the given item's price and synchronises it with other players.
+    /// </summary>
+    /// <remarks>
+    /// Setting lobby metadata is only allowed if the current player is the lobby's owner. Use the return value to determine if the set was possible.
+    /// </remarks>
+    /// <param name="item"></param>
+    /// <param name="price"></param>
+    /// <returns>
+    /// <see langword="true"/> if updating the price was successful (player is not in a lobby OR the owner of the current lobby).
+    /// <see langword="false"/> if the player is in a lobby but is not the lobby's host.
+    /// </returns>
+    public static bool UpdateItemPrice(Item item, int price)
+    {
+        if (IsItemRegistered(item) == false)
+        {
+            Debug.LogWarning($"Item {item.name} ({item.persistentID}) is not registered with {ShopApiPlugin.MOD_NAME}");
+            return false;
+        }
+        if (SteamLobbyMetadataHandler.IsHost == false && SteamLobbyMetadataHandler.InLobby)
+        {
+            Debug.LogError($"Tried updating item price when not the lobby host; this is not allowed.");
+            return false;
+        }
+        item.price = price;
+        PriceSynchroniser.SyncPrice(item);
+        return true;
+    }
+
     /// <summary>
     /// Returns the list of item data data entries derived from <see cref="ItemDataEntry"/> in the given assembly.
     /// </summary>

SteamLobbyMetadataHandler.cs

@@ -0,0 +1,55 @@
+using Steamworks;
+using UnityEngine;
+
+namespace ContentWarningShop
+{
+    internal static class SteamLobbyMetadataHandler
+    {
+        private static Callback<LobbyCreated_t> cb_onLobbyCreated;
+        private static Callback<LobbyEnter_t> cb_onLobbyEntered;
+        private static Callback<LobbyDataUpdate_t> cb_onLobbyDataUpdate;
+        //
+        internal static event Action? OnLobbyJoined;
+        internal static event Action? OnLobbyDataUpdate;
+
+        internal static CSteamID CurrentLobby = CSteamID.Nil;
+        // GetLobbyOwner returns nil if the current lobby is invalid / we are not in it
+        internal static bool InLobby => SteamMatchmaking.GetLobbyOwner(CurrentLobby) != CSteamID.Nil;
+        internal static bool IsHost => SteamMatchmaking.GetLobbyOwner(CurrentLobby) == SteamUser.GetSteamID();
+
+        static SteamLobbyMetadataHandler()
+        {
+            cb_onLobbyCreated = Callback<LobbyCreated_t>.Create(Steam_LobbyCreated);
+            cb_onLobbyEntered = Callback<LobbyEnter_t>.Create(Steam_LobbyEntered);
+            cb_onLobbyDataUpdate = Callback<LobbyDataUpdate_t>.Create(Steam_LobbyDataUpdated);
+        }
+
+        private static void Steam_LobbyCreated(LobbyCreated_t e)
+        {
+            if (e.m_eResult == EResult.k_EResultOK)
+            {
+                CurrentLobby = new CSteamID(e.m_ulSteamIDLobby);
+                OnLobbyJoined?.Invoke();
+            }
+        }
+
+        private static void Steam_LobbyEntered(LobbyEnter_t e)
+        {
+            // If we created the lobby, don't call the event again. Otherwise _currentLobby will be default by now
+            if (InLobby == false)
+            {
+                CurrentLobby = new CSteamID(e.m_ulSteamIDLobby);
+                OnLobbyJoined?.Invoke();
+            }
+        }
+
+        private static void Steam_LobbyDataUpdated(LobbyDataUpdate_t e)
+        {
+            if (e.m_ulSteamIDLobby != e.m_ulSteamIDMember)
+            {
+                return;
+            }
+            OnLobbyDataUpdate?.Invoke();
+        }
+    }
+}