271 lines
14 KiB
C#
271 lines
14 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Steamworks
|
|
{
|
|
public static class SteamGameServerInventory
|
|
{
|
|
public static EResult GetResultStatus(SteamInventoryResult_t resultHandle)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_GetResultStatus(CSteamGameServerAPIContext.GetSteamInventory(), resultHandle);
|
|
}
|
|
|
|
public static bool GetResultItems(SteamInventoryResult_t resultHandle, SteamItemDetails_t[] pOutItemsArray, ref uint punOutItemsArraySize)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
if (pOutItemsArray != null && pOutItemsArray.Length != punOutItemsArraySize)
|
|
{
|
|
throw new ArgumentException("pOutItemsArray must be the same size as punOutItemsArraySize!");
|
|
}
|
|
return NativeMethods.ISteamInventory_GetResultItems(CSteamGameServerAPIContext.GetSteamInventory(), resultHandle, pOutItemsArray, ref punOutItemsArraySize);
|
|
}
|
|
|
|
public static bool GetResultItemProperty(SteamInventoryResult_t resultHandle, uint unItemIndex, string pchPropertyName, out string pchValueBuffer, ref uint punValueBufferSizeOut)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
IntPtr intPtr = Marshal.AllocHGlobal((int)punValueBufferSizeOut);
|
|
using InteropHelp.UTF8StringHandle pchPropertyName2 = new InteropHelp.UTF8StringHandle(pchPropertyName);
|
|
bool flag = NativeMethods.ISteamInventory_GetResultItemProperty(CSteamGameServerAPIContext.GetSteamInventory(), resultHandle, unItemIndex, pchPropertyName2, intPtr, ref punValueBufferSizeOut);
|
|
pchValueBuffer = (flag ? InteropHelp.PtrToStringUTF8(intPtr) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return flag;
|
|
}
|
|
|
|
public static uint GetResultTimestamp(SteamInventoryResult_t resultHandle)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_GetResultTimestamp(CSteamGameServerAPIContext.GetSteamInventory(), resultHandle);
|
|
}
|
|
|
|
public static bool CheckResultSteamID(SteamInventoryResult_t resultHandle, CSteamID steamIDExpected)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_CheckResultSteamID(CSteamGameServerAPIContext.GetSteamInventory(), resultHandle, steamIDExpected);
|
|
}
|
|
|
|
public static void DestroyResult(SteamInventoryResult_t resultHandle)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
NativeMethods.ISteamInventory_DestroyResult(CSteamGameServerAPIContext.GetSteamInventory(), resultHandle);
|
|
}
|
|
|
|
public static bool GetAllItems(out SteamInventoryResult_t pResultHandle)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_GetAllItems(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle);
|
|
}
|
|
|
|
public static bool GetItemsByID(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t[] pInstanceIDs, uint unCountInstanceIDs)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_GetItemsByID(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, pInstanceIDs, unCountInstanceIDs);
|
|
}
|
|
|
|
public static bool SerializeResult(SteamInventoryResult_t resultHandle, byte[] pOutBuffer, out uint punOutBufferSize)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_SerializeResult(CSteamGameServerAPIContext.GetSteamInventory(), resultHandle, pOutBuffer, out punOutBufferSize);
|
|
}
|
|
|
|
public static bool DeserializeResult(out SteamInventoryResult_t pOutResultHandle, byte[] pBuffer, uint unBufferSize, bool bRESERVED_MUST_BE_FALSE = false)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_DeserializeResult(CSteamGameServerAPIContext.GetSteamInventory(), out pOutResultHandle, pBuffer, unBufferSize, bRESERVED_MUST_BE_FALSE);
|
|
}
|
|
|
|
public static bool GenerateItems(out SteamInventoryResult_t pResultHandle, SteamItemDef_t[] pArrayItemDefs, uint[] punArrayQuantity, uint unArrayLength)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_GenerateItems(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, pArrayItemDefs, punArrayQuantity, unArrayLength);
|
|
}
|
|
|
|
public static bool GrantPromoItems(out SteamInventoryResult_t pResultHandle)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_GrantPromoItems(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle);
|
|
}
|
|
|
|
public static bool AddPromoItem(out SteamInventoryResult_t pResultHandle, SteamItemDef_t itemDef)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_AddPromoItem(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, itemDef);
|
|
}
|
|
|
|
public static bool AddPromoItems(out SteamInventoryResult_t pResultHandle, SteamItemDef_t[] pArrayItemDefs, uint unArrayLength)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_AddPromoItems(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, pArrayItemDefs, unArrayLength);
|
|
}
|
|
|
|
public static bool ConsumeItem(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemConsume, uint unQuantity)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_ConsumeItem(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, itemConsume, unQuantity);
|
|
}
|
|
|
|
public static bool ExchangeItems(out SteamInventoryResult_t pResultHandle, SteamItemDef_t[] pArrayGenerate, uint[] punArrayGenerateQuantity, uint unArrayGenerateLength, SteamItemInstanceID_t[] pArrayDestroy, uint[] punArrayDestroyQuantity, uint unArrayDestroyLength)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_ExchangeItems(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, pArrayGenerate, punArrayGenerateQuantity, unArrayGenerateLength, pArrayDestroy, punArrayDestroyQuantity, unArrayDestroyLength);
|
|
}
|
|
|
|
public static bool TransferItemQuantity(out SteamInventoryResult_t pResultHandle, SteamItemInstanceID_t itemIdSource, uint unQuantity, SteamItemInstanceID_t itemIdDest)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_TransferItemQuantity(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, itemIdSource, unQuantity, itemIdDest);
|
|
}
|
|
|
|
public static void SendItemDropHeartbeat()
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
NativeMethods.ISteamInventory_SendItemDropHeartbeat(CSteamGameServerAPIContext.GetSteamInventory());
|
|
}
|
|
|
|
public static bool TriggerItemDrop(out SteamInventoryResult_t pResultHandle, SteamItemDef_t dropListDefinition)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_TriggerItemDrop(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, dropListDefinition);
|
|
}
|
|
|
|
public static bool TradeItems(out SteamInventoryResult_t pResultHandle, CSteamID steamIDTradePartner, SteamItemInstanceID_t[] pArrayGive, uint[] pArrayGiveQuantity, uint nArrayGiveLength, SteamItemInstanceID_t[] pArrayGet, uint[] pArrayGetQuantity, uint nArrayGetLength)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_TradeItems(CSteamGameServerAPIContext.GetSteamInventory(), out pResultHandle, steamIDTradePartner, pArrayGive, pArrayGiveQuantity, nArrayGiveLength, pArrayGet, pArrayGetQuantity, nArrayGetLength);
|
|
}
|
|
|
|
public static bool LoadItemDefinitions()
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_LoadItemDefinitions(CSteamGameServerAPIContext.GetSteamInventory());
|
|
}
|
|
|
|
public static bool GetItemDefinitionIDs(SteamItemDef_t[] pItemDefIDs, ref uint punItemDefIDsArraySize)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
if (pItemDefIDs != null && pItemDefIDs.Length != punItemDefIDsArraySize)
|
|
{
|
|
throw new ArgumentException("pItemDefIDs must be the same size as punItemDefIDsArraySize!");
|
|
}
|
|
return NativeMethods.ISteamInventory_GetItemDefinitionIDs(CSteamGameServerAPIContext.GetSteamInventory(), pItemDefIDs, ref punItemDefIDsArraySize);
|
|
}
|
|
|
|
public static bool GetItemDefinitionProperty(SteamItemDef_t iDefinition, string pchPropertyName, out string pchValueBuffer, ref uint punValueBufferSizeOut)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
IntPtr intPtr = Marshal.AllocHGlobal((int)punValueBufferSizeOut);
|
|
using InteropHelp.UTF8StringHandle pchPropertyName2 = new InteropHelp.UTF8StringHandle(pchPropertyName);
|
|
bool flag = NativeMethods.ISteamInventory_GetItemDefinitionProperty(CSteamGameServerAPIContext.GetSteamInventory(), iDefinition, pchPropertyName2, intPtr, ref punValueBufferSizeOut);
|
|
pchValueBuffer = (flag ? InteropHelp.PtrToStringUTF8(intPtr) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return flag;
|
|
}
|
|
|
|
public static SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs(CSteamID steamID)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return (SteamAPICall_t)NativeMethods.ISteamInventory_RequestEligiblePromoItemDefinitionsIDs(CSteamGameServerAPIContext.GetSteamInventory(), steamID);
|
|
}
|
|
|
|
public static bool GetEligiblePromoItemDefinitionIDs(CSteamID steamID, SteamItemDef_t[] pItemDefIDs, ref uint punItemDefIDsArraySize)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
if (pItemDefIDs != null && pItemDefIDs.Length != punItemDefIDsArraySize)
|
|
{
|
|
throw new ArgumentException("pItemDefIDs must be the same size as punItemDefIDsArraySize!");
|
|
}
|
|
return NativeMethods.ISteamInventory_GetEligiblePromoItemDefinitionIDs(CSteamGameServerAPIContext.GetSteamInventory(), steamID, pItemDefIDs, ref punItemDefIDsArraySize);
|
|
}
|
|
|
|
public static SteamAPICall_t StartPurchase(SteamItemDef_t[] pArrayItemDefs, uint[] punArrayQuantity, uint unArrayLength)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return (SteamAPICall_t)NativeMethods.ISteamInventory_StartPurchase(CSteamGameServerAPIContext.GetSteamInventory(), pArrayItemDefs, punArrayQuantity, unArrayLength);
|
|
}
|
|
|
|
public static SteamAPICall_t RequestPrices()
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return (SteamAPICall_t)NativeMethods.ISteamInventory_RequestPrices(CSteamGameServerAPIContext.GetSteamInventory());
|
|
}
|
|
|
|
public static uint GetNumItemsWithPrices()
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_GetNumItemsWithPrices(CSteamGameServerAPIContext.GetSteamInventory());
|
|
}
|
|
|
|
public static bool GetItemsWithPrices(SteamItemDef_t[] pArrayItemDefs, ulong[] pCurrentPrices, ulong[] pBasePrices, uint unArrayLength)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
if (pArrayItemDefs != null && pArrayItemDefs.Length != unArrayLength)
|
|
{
|
|
throw new ArgumentException("pArrayItemDefs must be the same size as unArrayLength!");
|
|
}
|
|
if (pCurrentPrices != null && pCurrentPrices.Length != unArrayLength)
|
|
{
|
|
throw new ArgumentException("pCurrentPrices must be the same size as unArrayLength!");
|
|
}
|
|
if (pBasePrices != null && pBasePrices.Length != unArrayLength)
|
|
{
|
|
throw new ArgumentException("pBasePrices must be the same size as unArrayLength!");
|
|
}
|
|
return NativeMethods.ISteamInventory_GetItemsWithPrices(CSteamGameServerAPIContext.GetSteamInventory(), pArrayItemDefs, pCurrentPrices, pBasePrices, unArrayLength);
|
|
}
|
|
|
|
public static bool GetItemPrice(SteamItemDef_t iDefinition, out ulong pCurrentPrice, out ulong pBasePrice)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_GetItemPrice(CSteamGameServerAPIContext.GetSteamInventory(), iDefinition, out pCurrentPrice, out pBasePrice);
|
|
}
|
|
|
|
public static SteamInventoryUpdateHandle_t StartUpdateProperties()
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return (SteamInventoryUpdateHandle_t)NativeMethods.ISteamInventory_StartUpdateProperties(CSteamGameServerAPIContext.GetSteamInventory());
|
|
}
|
|
|
|
public static bool RemoveProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, string pchPropertyName)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
using InteropHelp.UTF8StringHandle pchPropertyName2 = new InteropHelp.UTF8StringHandle(pchPropertyName);
|
|
return NativeMethods.ISteamInventory_RemoveProperty(CSteamGameServerAPIContext.GetSteamInventory(), handle, nItemID, pchPropertyName2);
|
|
}
|
|
|
|
public static bool SetProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, string pchPropertyName, string pchPropertyValue)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
using InteropHelp.UTF8StringHandle pchPropertyName2 = new InteropHelp.UTF8StringHandle(pchPropertyName);
|
|
using InteropHelp.UTF8StringHandle pchPropertyValue2 = new InteropHelp.UTF8StringHandle(pchPropertyValue);
|
|
return NativeMethods.ISteamInventory_SetPropertyString(CSteamGameServerAPIContext.GetSteamInventory(), handle, nItemID, pchPropertyName2, pchPropertyValue2);
|
|
}
|
|
|
|
public static bool SetProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, string pchPropertyName, bool bValue)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
using InteropHelp.UTF8StringHandle pchPropertyName2 = new InteropHelp.UTF8StringHandle(pchPropertyName);
|
|
return NativeMethods.ISteamInventory_SetPropertyBool(CSteamGameServerAPIContext.GetSteamInventory(), handle, nItemID, pchPropertyName2, bValue);
|
|
}
|
|
|
|
public static bool SetProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, string pchPropertyName, long nValue)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
using InteropHelp.UTF8StringHandle pchPropertyName2 = new InteropHelp.UTF8StringHandle(pchPropertyName);
|
|
return NativeMethods.ISteamInventory_SetPropertyInt64(CSteamGameServerAPIContext.GetSteamInventory(), handle, nItemID, pchPropertyName2, nValue);
|
|
}
|
|
|
|
public static bool SetProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, string pchPropertyName, float flValue)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
using InteropHelp.UTF8StringHandle pchPropertyName2 = new InteropHelp.UTF8StringHandle(pchPropertyName);
|
|
return NativeMethods.ISteamInventory_SetPropertyFloat(CSteamGameServerAPIContext.GetSteamInventory(), handle, nItemID, pchPropertyName2, flValue);
|
|
}
|
|
|
|
public static bool SubmitUpdateProperties(SteamInventoryUpdateHandle_t handle, out SteamInventoryResult_t pResultHandle)
|
|
{
|
|
InteropHelp.TestIfAvailableGameServer();
|
|
return NativeMethods.ISteamInventory_SubmitUpdateProperties(CSteamGameServerAPIContext.GetSteamInventory(), handle, out pResultHandle);
|
|
}
|
|
}
|
|
}
|