118 lines
3.2 KiB
C#
118 lines
3.2 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using Facepunch.Steamworks.Data;
|
|
|
|
namespace Facepunch.Steamworks
|
|
{
|
|
public struct InventoryResult : IDisposable
|
|
{
|
|
internal SteamInventoryResult_t _id;
|
|
|
|
public bool Expired { get; internal set; }
|
|
|
|
internal InventoryResult( SteamInventoryResult_t id, bool expired )
|
|
{
|
|
_id = id;
|
|
Expired = expired;
|
|
}
|
|
|
|
public int ItemCount
|
|
{
|
|
get
|
|
{
|
|
uint cnt = 0;
|
|
|
|
if ( !SteamInventory.Internal.GetResultItems( _id, null, ref cnt ) )
|
|
return 0;
|
|
|
|
return (int) cnt;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks whether an inventory result handle belongs to the specified Steam ID.
|
|
/// This is important when using Deserialize, to verify that a remote player is not pretending to have a different user's inventory
|
|
/// </summary>
|
|
public bool BelongsTo( SteamId steamId )
|
|
{
|
|
return SteamInventory.Internal.CheckResultSteamID( _id, steamId );
|
|
}
|
|
|
|
public InventoryItem[] GetItems( bool includeProperties = false )
|
|
{
|
|
uint cnt = (uint) ItemCount;
|
|
if ( cnt <= 0 ) return null;
|
|
|
|
var pOutItemsArray = new SteamItemDetails_t[cnt];
|
|
|
|
if ( !SteamInventory.Internal.GetResultItems( _id, pOutItemsArray, ref cnt ) )
|
|
return null;
|
|
|
|
var items = new InventoryItem[cnt];
|
|
|
|
for( int i=0; i< cnt; i++ )
|
|
{
|
|
var item = InventoryItem.From( pOutItemsArray[i] );
|
|
|
|
if ( includeProperties )
|
|
item._properties = InventoryItem.GetProperties( _id, i );
|
|
|
|
items[i] = item;
|
|
}
|
|
|
|
|
|
return items;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if ( _id.Value == -1 ) return;
|
|
|
|
SteamInventory.Internal.DestroyResult( _id );
|
|
}
|
|
|
|
internal static async Task<InventoryResult?> GetAsync( SteamInventoryResult_t sresult )
|
|
{
|
|
var _result = Result.Pending;
|
|
while ( _result == Result.Pending )
|
|
{
|
|
_result = SteamInventory.Internal.GetResultStatus( sresult );
|
|
await Task.Delay( 10 );
|
|
}
|
|
|
|
if ( _result != Result.OK && _result != Result.Expired )
|
|
return null;
|
|
|
|
return new InventoryResult( sresult, _result == Result.Expired );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serialized result sets contain a short signature which can't be forged or replayed across different game sessions.
|
|
/// A result set can be serialized on the local client, transmitted to other players via your game networking, and
|
|
/// deserialized by the remote players.This is a secure way of preventing hackers from lying about posessing
|
|
/// rare/high-value items. Serializes a result set with signature bytes to an output buffer.The size of a serialized
|
|
/// result depends on the number items which are being serialized.When securely transmitting items to other players,
|
|
/// it is recommended to use GetItemsByID first to create a minimal result set.
|
|
/// Results have a built-in timestamp which will be considered "expired" after an hour has elapsed.See DeserializeResult
|
|
/// for expiration handling.
|
|
/// </summary>
|
|
public unsafe byte[] Serialize()
|
|
{
|
|
uint size = 0;
|
|
|
|
if ( !SteamInventory.Internal.SerializeResult( _id, IntPtr.Zero, ref size ) )
|
|
return null;
|
|
|
|
var data = new byte[size];
|
|
|
|
fixed ( byte* ptr = data )
|
|
{
|
|
if ( !SteamInventory.Internal.SerializeResult( _id, (IntPtr)ptr, ref size ) )
|
|
return null;
|
|
}
|
|
|
|
return data;
|
|
}
|
|
}
|
|
} |