506 lines
15 KiB
C#
506 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using HeathenEngineering.SteamApi.Foundation;
|
|
using Steamworks;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
namespace HeathenEngineering.SteamApi.PlayerServices
|
|
{
|
|
[CreateAssetMenu(menuName = "Steamworks/Player Services/Inventory Settings")]
|
|
public class SteamworksInventorySettings : ScriptableObject
|
|
{
|
|
public static SteamworksInventorySettings Current;
|
|
|
|
public bool LogDebugMessages;
|
|
|
|
public List<InventoryItemDefinition> ItemDefinitions = new List<InventoryItemDefinition>();
|
|
|
|
public List<ItemGeneratorDefinition> ItemGenerators = new List<ItemGeneratorDefinition>();
|
|
|
|
public List<TagGeneratorDefinition> TagGenerators = new List<TagGeneratorDefinition>();
|
|
|
|
public List<InventoryItemBundleDefinition> ItemBundles = new List<InventoryItemBundleDefinition>();
|
|
|
|
[HideInInspector]
|
|
public UnityEvent ItemInstancesUpdated = new UnityEvent();
|
|
|
|
[HideInInspector]
|
|
public UnityItemDetailEvent ItemsGranted = new UnityItemDetailEvent();
|
|
|
|
[HideInInspector]
|
|
public UnityItemDetailEvent ItemsConsumed = new UnityItemDetailEvent();
|
|
|
|
[HideInInspector]
|
|
public UnityItemDetailEvent ItemsExchanged = new UnityItemDetailEvent();
|
|
|
|
[HideInInspector]
|
|
public UnityItemDetailEvent ItemsDroped = new UnityItemDetailEvent();
|
|
|
|
private Dictionary<SteamItemDef_t, InventoryItemPointer> ItemPointerIndex = new Dictionary<SteamItemDef_t, InventoryItemPointer>();
|
|
|
|
private Dictionary<SteamItemDef_t, InventoryItemDefinition> ItemDefinitionIndex = new Dictionary<SteamItemDef_t, InventoryItemDefinition>();
|
|
|
|
private Dictionary<SteamItemDef_t, ItemGeneratorDefinition> ItemGeneratorIndex = new Dictionary<SteamItemDef_t, ItemGeneratorDefinition>();
|
|
|
|
public bool IsActive
|
|
{
|
|
get
|
|
{
|
|
return Current == this;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
Register();
|
|
}
|
|
else if (Current == this)
|
|
{
|
|
Current = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public InventoryItemPointer this[SteamItemDef_t id]
|
|
{
|
|
get
|
|
{
|
|
if (ItemPointerIndex == null)
|
|
{
|
|
BuildIndex();
|
|
}
|
|
if (ItemPointerIndex.ContainsKey(id))
|
|
{
|
|
return ItemPointerIndex[id];
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public InventoryItemPointer this[SteamItemDetails_t item] => this[item.m_iDefinition];
|
|
|
|
public InventoryItemPointer this[int itemId] => this[new SteamItemDef_t(itemId)];
|
|
|
|
public void BuildIndex()
|
|
{
|
|
if (ItemPointerIndex == null)
|
|
{
|
|
ItemPointerIndex = new Dictionary<SteamItemDef_t, InventoryItemPointer>();
|
|
}
|
|
if (ItemDefinitionIndex == null)
|
|
{
|
|
ItemDefinitionIndex = new Dictionary<SteamItemDef_t, InventoryItemDefinition>();
|
|
}
|
|
if (ItemGeneratorIndex == null)
|
|
{
|
|
ItemGeneratorIndex = new Dictionary<SteamItemDef_t, ItemGeneratorDefinition>();
|
|
}
|
|
if (LogDebugMessages)
|
|
{
|
|
int num = ((ItemDefinitions != null) ? ItemDefinitions.Count : 0);
|
|
int num2 = ((ItemGenerators != null) ? ItemGenerators.Count : 0);
|
|
Debug.Log("Building internal indices for " + num + " items and " + num2 + " generators.");
|
|
}
|
|
foreach (InventoryItemDefinition itemDefinition in ItemDefinitions)
|
|
{
|
|
if (ItemDefinitionIndex.ContainsKey(itemDefinition.DefinitionID))
|
|
{
|
|
ItemDefinitionIndex[itemDefinition.DefinitionID] = itemDefinition;
|
|
}
|
|
else
|
|
{
|
|
ItemDefinitionIndex.Add(itemDefinition.DefinitionID, itemDefinition);
|
|
}
|
|
if (ItemPointerIndex.ContainsKey(itemDefinition.DefinitionID))
|
|
{
|
|
ItemPointerIndex[itemDefinition.DefinitionID] = itemDefinition;
|
|
}
|
|
else
|
|
{
|
|
ItemPointerIndex.Add(itemDefinition.DefinitionID, itemDefinition);
|
|
}
|
|
}
|
|
foreach (ItemGeneratorDefinition itemGenerator in ItemGenerators)
|
|
{
|
|
if (ItemGeneratorIndex.ContainsKey(itemGenerator.DefinitionID))
|
|
{
|
|
ItemGeneratorIndex[itemGenerator.DefinitionID] = itemGenerator;
|
|
}
|
|
else
|
|
{
|
|
ItemGeneratorIndex.Add(itemGenerator.DefinitionID, itemGenerator);
|
|
}
|
|
if (ItemPointerIndex.ContainsKey(itemGenerator.DefinitionID))
|
|
{
|
|
ItemPointerIndex[itemGenerator.DefinitionID] = itemGenerator;
|
|
}
|
|
else
|
|
{
|
|
ItemPointerIndex.Add(itemGenerator.DefinitionID, itemGenerator);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ClearItemCounts()
|
|
{
|
|
foreach (InventoryItemDefinition itemDefinition in ItemDefinitions)
|
|
{
|
|
if (itemDefinition.Instances == null)
|
|
{
|
|
itemDefinition.Instances = new List<SteamItemDetails_t>();
|
|
}
|
|
else
|
|
{
|
|
itemDefinition.Instances.Clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void InternalItemDetailUpdate(IEnumerable<SteamItemDetails_t> details)
|
|
{
|
|
if (Current != null && details != null)
|
|
{
|
|
Current.HandleItemDetailUpdate(details);
|
|
}
|
|
}
|
|
|
|
public void HandleItemDetailUpdate(IEnumerable<SteamItemDetails_t> details)
|
|
{
|
|
bool flag = false;
|
|
foreach (SteamItemDetails_t detail in details)
|
|
{
|
|
if (ItemDefinitionIndex.ContainsKey(detail.m_iDefinition))
|
|
{
|
|
flag = true;
|
|
InventoryItemDefinition inventoryItemDefinition = ItemDefinitionIndex[detail.m_iDefinition];
|
|
if (inventoryItemDefinition.Instances == null)
|
|
{
|
|
inventoryItemDefinition.Instances = new List<SteamItemDetails_t>();
|
|
}
|
|
else
|
|
{
|
|
inventoryItemDefinition.Instances.RemoveAll((SteamItemDetails_t p) => p.m_itemId == detail.m_itemId);
|
|
}
|
|
inventoryItemDefinition.Instances.Add(detail);
|
|
}
|
|
else if (LogDebugMessages)
|
|
{
|
|
Debug.LogWarning("No item definition found for item " + detail.m_iDefinition.m_SteamItemDef + " but an item instance " + detail.m_itemId.m_SteamItemInstanceID + " exists in the player's inventory with a unit count of " + detail.m_unQuantity + "\nConsider adding an item definition for this to your Steam Inventory Settings.");
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
return;
|
|
}
|
|
if (LogDebugMessages)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder("Inventory Item Detail Update:\n");
|
|
foreach (InventoryItemDefinition itemDefinition in ItemDefinitions)
|
|
{
|
|
stringBuilder.Append("\t[" + itemDefinition.name + "] has " + itemDefinition.Instances.Count + " instances for a sum of " + itemDefinition.Count + " units.\n");
|
|
}
|
|
Debug.Log(stringBuilder.ToString());
|
|
}
|
|
ItemInstancesUpdated.Invoke();
|
|
}
|
|
|
|
public void Register()
|
|
{
|
|
if (LogDebugMessages)
|
|
{
|
|
if (Current == null)
|
|
{
|
|
Debug.Log("Registering a new Steamworks Inventory Settings object [" + base.name + "]");
|
|
}
|
|
else if (Current != this)
|
|
{
|
|
Debug.Log("Replacing Steamworks Inventory Settings object [" + Current.name + "] with [" + base.name + "]");
|
|
}
|
|
if (Current != null)
|
|
{
|
|
Debug.Log("RE-Registering Steamworks Inventory Settings object [" + base.name + "]");
|
|
}
|
|
}
|
|
BuildIndex();
|
|
Current = this;
|
|
}
|
|
|
|
public T GetDefinition<T>(SteamItemDetails_t steamDetail) where T : InventoryItemDefinition
|
|
{
|
|
return this[steamDetail] as T;
|
|
}
|
|
|
|
public T GetDefinition<T>(SteamItemDef_t steamDefinition) where T : InventoryItemDefinition
|
|
{
|
|
return this[steamDefinition] as T;
|
|
}
|
|
|
|
public InventoryItemDefinition GetDefinition(SteamItemDetails_t steamDetail)
|
|
{
|
|
return this[steamDetail] as InventoryItemDefinition;
|
|
}
|
|
|
|
public InventoryItemDefinition GetDefinition(SteamItemDef_t steamDefinition)
|
|
{
|
|
return this[steamDefinition] as InventoryItemDefinition;
|
|
}
|
|
|
|
public InventoryItemDefinition GetDefinition(int steamDefinition)
|
|
{
|
|
return this[steamDefinition] as InventoryItemDefinition;
|
|
}
|
|
|
|
public void RefreshInventory()
|
|
{
|
|
foreach (InventoryItemDefinition itemDefinition in ItemDefinitions)
|
|
{
|
|
if (itemDefinition.Instances == null)
|
|
{
|
|
itemDefinition.Instances = new List<SteamItemDetails_t>();
|
|
}
|
|
else
|
|
{
|
|
itemDefinition.Instances.Clear();
|
|
}
|
|
}
|
|
if (!SteamworksPlayerInventory.GetAllItems(null))
|
|
{
|
|
Debug.LogWarning("[SteamworksInventorySettings.RefreshInventory] - Call failed");
|
|
}
|
|
}
|
|
|
|
public void GrantAllPromotionalItems()
|
|
{
|
|
if (!SteamworksPlayerInventory.GrantPromoItems(delegate(bool status, SteamItemDetails_t[] results)
|
|
{
|
|
ItemsGranted.Invoke(status, results);
|
|
}))
|
|
{
|
|
Debug.LogWarning("[SteamworksInventorySettings.GrantAllPromotionalItems] - Call failed");
|
|
}
|
|
}
|
|
|
|
public void GrantPromotionalItem(InventoryItemDefinition itemDefinition)
|
|
{
|
|
if (!SteamworksPlayerInventory.AddPromoItem(itemDefinition.DefinitionID, delegate(bool status, SteamItemDetails_t[] results)
|
|
{
|
|
ItemsGranted.Invoke(status, results);
|
|
}))
|
|
{
|
|
Debug.LogWarning("[SteamworksInventorySettings.GrantPromotionalItem] - Call failed");
|
|
}
|
|
}
|
|
|
|
public void GrantPromotionalItems(IEnumerable<InventoryItemDefinition> itemDefinitions)
|
|
{
|
|
List<SteamItemDef_t> list = new List<SteamItemDef_t>();
|
|
foreach (InventoryItemDefinition itemDefinition in itemDefinitions)
|
|
{
|
|
list.Add(itemDefinition.DefinitionID);
|
|
}
|
|
if (!SteamworksPlayerInventory.AddPromoItems(list, delegate(bool status, SteamItemDetails_t[] results)
|
|
{
|
|
ItemsGranted.Invoke(status, results);
|
|
}))
|
|
{
|
|
Debug.LogWarning("[SteamworksInventorySettings.GrantPromotionalItems] - Call failed");
|
|
}
|
|
}
|
|
|
|
public bool CheckUserResult(SteamInventoryResult_t resultHandle, ulong user)
|
|
{
|
|
return SteamworksPlayerInventory.CheckResultSteamID(resultHandle, user);
|
|
}
|
|
|
|
public bool CheckUserResult(SteamInventoryResult_t resultHandle, CSteamID user)
|
|
{
|
|
return SteamworksPlayerInventory.CheckResultSteamID(resultHandle, user);
|
|
}
|
|
|
|
public bool CheckUserResult(SteamInventoryResult_t resultHandle, SteamUserData user)
|
|
{
|
|
return SteamworksPlayerInventory.CheckResultSteamID(resultHandle, user);
|
|
}
|
|
|
|
public void ConsumeItem(InventoryItemDefinition itemDefinition)
|
|
{
|
|
SteamItemDetails_t target = itemDefinition.Instances.FirstOrDefault((SteamItemDetails_t p) => p.m_unQuantity > 0);
|
|
if (!SteamworksPlayerInventory.ConsumeItem(target.m_itemId, delegate(bool status, SteamItemDetails_t[] results)
|
|
{
|
|
if (status)
|
|
{
|
|
itemDefinition.Instances.RemoveAll((SteamItemDetails_t p) => p.m_itemId == target.m_itemId);
|
|
target.m_unQuantity--;
|
|
itemDefinition.Instances.Add(target);
|
|
ItemInstancesUpdated.Invoke();
|
|
ItemsConsumed.Invoke(status, results);
|
|
}
|
|
}))
|
|
{
|
|
Debug.LogWarning("[SteamworksInventorySettings.ConsumeItem] - Call failed");
|
|
}
|
|
}
|
|
|
|
public void ConsumeItem(InventoryItemDefinition itemDefinition, int count)
|
|
{
|
|
if (count < 1)
|
|
{
|
|
Debug.LogWarning("Attempted to consume a number of items less than 1; this is not possible and was note requested.");
|
|
return;
|
|
}
|
|
List<ExchangeItemCount> list = new List<ExchangeItemCount>();
|
|
int num = 0;
|
|
foreach (SteamItemDetails_t instance in itemDefinition.Instances)
|
|
{
|
|
if (instance.m_unQuantity >= count - num)
|
|
{
|
|
list.Add(new ExchangeItemCount
|
|
{
|
|
InstanceId = instance.m_itemId,
|
|
Quantity = Convert.ToUInt32(count - num)
|
|
});
|
|
num = count;
|
|
break;
|
|
}
|
|
list.Add(new ExchangeItemCount
|
|
{
|
|
InstanceId = instance.m_itemId,
|
|
Quantity = instance.m_unQuantity
|
|
});
|
|
num += instance.m_unQuantity;
|
|
}
|
|
bool flag = true;
|
|
foreach (ExchangeItemCount exchange in list)
|
|
{
|
|
if (!SteamworksPlayerInventory.ConsumeItem(exchange.InstanceId, exchange.Quantity, delegate(bool status, SteamItemDetails_t[] results)
|
|
{
|
|
if (status)
|
|
{
|
|
SteamItemDetails_t item = itemDefinition.Instances.FirstOrDefault((SteamItemDetails_t p) => p.m_itemId == exchange.InstanceId);
|
|
itemDefinition.Instances.RemoveAll((SteamItemDetails_t p) => p.m_itemId == exchange.InstanceId);
|
|
item.m_unQuantity -= Convert.ToUInt16(exchange.Quantity);
|
|
itemDefinition.Instances.Add(item);
|
|
ItemInstancesUpdated.Invoke();
|
|
ItemsConsumed.Invoke(status, results);
|
|
}
|
|
}))
|
|
{
|
|
flag = false;
|
|
Debug.LogWarning("Failed to consume all requested items");
|
|
break;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
Debug.LogWarning("[SteamworksInventorySettings.ConsumeItem] - Call failed");
|
|
}
|
|
}
|
|
|
|
public void ConsumeItem(InventoryItemDefinition itemDefinition, SteamItemInstanceID_t instanceId, int count)
|
|
{
|
|
SteamItemDetails_t target = itemDefinition.Instances.FirstOrDefault((SteamItemDetails_t p) => p.m_itemId == instanceId);
|
|
if (!SteamworksPlayerInventory.ConsumeItem(instanceId, delegate(bool status, SteamItemDetails_t[] results)
|
|
{
|
|
if (status)
|
|
{
|
|
itemDefinition.Instances.RemoveAll((SteamItemDetails_t p) => p.m_itemId == target.m_itemId);
|
|
target.m_unQuantity -= Convert.ToUInt16(count);
|
|
itemDefinition.Instances.Add(target);
|
|
ItemInstancesUpdated.Invoke();
|
|
ItemsConsumed.Invoke(status, results);
|
|
}
|
|
}))
|
|
{
|
|
Debug.LogWarning("[SteamworksInventorySettings.ConsumeItem] - Call failed");
|
|
}
|
|
}
|
|
|
|
public void ConsumeItem(SteamItemInstanceID_t instanceId, int count)
|
|
{
|
|
InventoryItemDefinition itemDefinition = ItemDefinitions.FirstOrDefault((InventoryItemDefinition p) => p.Instances.Any((SteamItemDetails_t i) => i.m_itemId == instanceId));
|
|
if (itemDefinition == null)
|
|
{
|
|
Debug.LogError("Unable to locate the Item Definition for Item Instance " + instanceId.m_SteamItemInstanceID);
|
|
return;
|
|
}
|
|
SteamItemDetails_t target = itemDefinition.Instances.FirstOrDefault((SteamItemDetails_t p) => p.m_itemId == instanceId);
|
|
if (!SteamworksPlayerInventory.ConsumeItem(instanceId, delegate(bool status, SteamItemDetails_t[] results)
|
|
{
|
|
if (status)
|
|
{
|
|
itemDefinition.Instances.RemoveAll((SteamItemDetails_t p) => p.m_itemId == target.m_itemId);
|
|
target.m_unQuantity -= Convert.ToUInt16(count);
|
|
itemDefinition.Instances.Add(target);
|
|
ItemInstancesUpdated.Invoke();
|
|
ItemsConsumed.Invoke(status, results);
|
|
}
|
|
}))
|
|
{
|
|
Debug.LogWarning("[SteamworksInventorySettings.ConsumeItem] - Call failed");
|
|
}
|
|
}
|
|
|
|
public void ExchangeItems(InventoryItemDefinition itemToCraft, CraftingRecipe recipe)
|
|
{
|
|
itemToCraft.Craft(recipe);
|
|
}
|
|
|
|
public void ExchangeItems(InventoryItemDefinition itemToCraft, int recipeIndex)
|
|
{
|
|
itemToCraft.Craft(recipeIndex);
|
|
}
|
|
|
|
public void TriggerItemDrop(ItemGeneratorDefinition generator, bool postDropRefresh)
|
|
{
|
|
generator.TriggerDrop(delegate(bool status, SteamItemDetails_t[] results)
|
|
{
|
|
if (status)
|
|
{
|
|
if (LogDebugMessages)
|
|
{
|
|
Debug.Log("Item Drop for [" + generator.name + "] completed with status " + status + " and " + results.Count() + " instances effected.");
|
|
}
|
|
if (postDropRefresh)
|
|
{
|
|
RefreshInventory();
|
|
}
|
|
}
|
|
ItemsDroped.Invoke(status, results);
|
|
});
|
|
}
|
|
|
|
public void TriggerItemDrop(ItemGeneratorDefinition generator)
|
|
{
|
|
TriggerItemDrop(generator, postDropRefresh: false);
|
|
}
|
|
|
|
public void TriggerItemDropAndRefresh(ItemGeneratorDefinition generator)
|
|
{
|
|
TriggerItemDrop(generator, postDropRefresh: true);
|
|
}
|
|
|
|
public bool TransferQuantity(InventoryItemDefinition item, SteamItemDetails_t source, uint quantity, SteamItemInstanceID_t destination)
|
|
{
|
|
return item.TransferQuantity(source, quantity, destination);
|
|
}
|
|
|
|
public bool SplitInstance(InventoryItemDefinition item, SteamItemDetails_t source, uint quantity)
|
|
{
|
|
return item.SplitInstance(source, quantity);
|
|
}
|
|
|
|
public bool StackInstance(InventoryItemDefinition item, SteamItemDetails_t source, SteamItemInstanceID_t destination)
|
|
{
|
|
return item.StackInstance(source, destination);
|
|
}
|
|
|
|
public void Consolidate(InventoryItemDefinition item)
|
|
{
|
|
item.Consolidate();
|
|
}
|
|
}
|
|
}
|