void GetScores(ELeaderboardDataRequest requestType)
{
//set to which type we want
switch (requestType)
{
case ELeaderboardDataRequest.k_ELeaderboardDataRequestGlobal:
wantedType = 2;
break;
case ELeaderboardDataRequest.k_ELeaderboardDataRequestGlobalAroundUser:
wantedType = 1;
break;
case ELeaderboardDataRequest.k_ELeaderboardDataRequestFriends:
wantedType = 0;
break;
default:
break;
}
if (wantedType == 2 || wantedType == 0)
{
SteamAPICall_t newApiCall = SteamUserStats.DownloadLeaderboardEntries(leaderboard_t, requestType, 1, 10);
downloadResultLeaderboard.Set(newApiCall);
}
else
{
SteamAPICall_t newApiCall = SteamUserStats.DownloadLeaderboardEntries(leaderboard_t, requestType, -4, 5);
downloadResultLeaderboard.Set(newApiCall);
}
}
private void Awake()
{
m_leaderboardName = leaderboardName;
m_leaderboardEntriesRangeInit = leaderboardEntriesRangeinit;
m_leaderboardEntriesRangeEnd = leaderboardEntriesRangeEnd;
m_leaderboardPrefab = leaderboardPrefab;
m_distanceBetweenCells = distanceBetweenCells;
m_uploadScoreMethod = uploadScoreMethod;
m_requestType = requestType;
m_usingentriesFinished = false;
}
/// <summary>
/// Query for entries from this baord
/// </summary>
/// <param name="requestType"></param>
/// <param name="rangeStart"></param>
/// <param name="rangeEnd"></param>
public void QueryEntries(ELeaderboardDataRequest requestType, int rangeStart, int rangeEnd)
{
if (!LeaderboardId.HasValue)
{
Debug.LogError(name + " Leaderboard Data Object, cannot download scores, the leaderboard has not been initalized and cannot download scores.");
return;
}
var handle = SteamUserStats.DownloadLeaderboardEntries(LeaderboardId.Value, requestType, rangeStart, rangeEnd);
OnLeaderboardScoresDownloadedCallResult.Set(handle, OnLeaderboardScoresDownloaded);
}
/// <summary>
/// Downloads the leaderboard for the filter criteria. The p_onDownloadedScores callback is invoked when done.
/// First all score entries are fetched, then all user names are loaded if they are not yet cached by Steam.
/// Avatars are loaded as soon as they are requested with SteamLeaderboardsMain.GetAvatarTexture.
/// See also SteamLeaderboardsMain.OnDownloadedScores.
/// </summary>
/// <returns><c>true</c>, if a request was started, <c>false</c> when the request could not have been started due to an error.</returns>
/// <param name="p_leaderboardName">name of the leaderboard to load.</param>
/// <param name="p_scoreSource">source of the leaderboard entries (Global, AroundUser, Friends).</param>
/// <param name="p_rangeStart">score entries range to load. For example, [0,10] for Global, [-4,5] for AroundUser.</param>
/// <param name="p_rangeEnd">score entries range to load. For example, [0,10] for Global, [-4,5] for AroundUser.</param>
/// <param name="p_onDownloadedScores">invoked when the leaderboard is either fully loaded or an error has occured.</param>
public bool DownloadScores(string p_leaderboardName, ELeaderboardDataRequest p_scoreSource, int p_rangeStart, int p_rangeEnd, System.Action <LeaderboardsDownloadedScoresEventArgs> p_onDownloadedScores)
{
if (SteamManager.Initialized)
{
SetSingleShotEventHandler("OnDownloadedScores", ref OnDownloadedScores, p_onDownloadedScores);
Execute <LeaderboardFindResult_t>(SteamUserStats.FindLeaderboard(p_leaderboardName), (p_callback, p_bIOFailure) => OnDownloadScoresFindLeaderboardCallCompleted(p_leaderboardName, p_scoreSource, p_rangeStart, p_rangeEnd, p_callback, p_bIOFailure));
return(true); // request started
}
else
{
ErrorEventArgs errorArgs = ErrorEventArgs.CreateSteamNotInit();
InvokeEventHandlerSafely(p_onDownloadedScores, new LeaderboardsDownloadedScoresEventArgs(errorArgs));
HandleError("DownloadScores: failed! ", errorArgs);
return(false); // no request, because there is no connection to steam
}
}
//change ELeaderboardDataRequest to get a different set (focused around player or global)
public void GetLeaderBoardData(ELeaderboardDataRequest _type = ELeaderboardDataRequest.k_ELeaderboardDataRequestGlobal, int entries = 10)
{
SteamAPICall_t hSteamAPICall;
switch (_type)
{
case ELeaderboardDataRequest.k_ELeaderboardDataRequestGlobal:
hSteamAPICall = SteamUserStats.DownloadLeaderboardEntries(s_currentLeaderboard, _type, 1, entries);
m_downloadResult.Set(hSteamAPICall, OnLeaderboardDownloadResult);
break;
case ELeaderboardDataRequest.k_ELeaderboardDataRequestGlobalAroundUser:
hSteamAPICall = SteamUserStats.DownloadLeaderboardEntries(s_currentLeaderboard, _type, -(entries / 2), (entries / 2));
m_downloadResult.Set(hSteamAPICall, OnLeaderboardDownloadResult);
break;
case ELeaderboardDataRequest.k_ELeaderboardDataRequestFriends:
hSteamAPICall = SteamUserStats.DownloadLeaderboardEntries(s_currentLeaderboard, _type, 1, entries);
m_downloadResult.Set(hSteamAPICall, OnLeaderboardDownloadResult);
break;
}
//Note that the LeaderboardDataset will not be updated immediatly (see callback below)
}
/// <summary>
/// Get entries from the leaderboard
/// </summary>
/// <param name="requestType">type of data request, when downloading leaderboard entries</param>
/// <param name="rangeStart">the result index to start at</param>
/// <param name="rangeEnd">the result index to end at</param>
public void QueryEntries(ELeaderboardDataRequest requestType, int rangeStart, int rangeEnd)
{
Settings.QueryEntries(requestType, rangeStart, rangeEnd);
}
/*internal static GameNetworkState LoadUserState(CSteamID userId)
* {
* var presence = SteamFriends.GetFriendRichPresence(userId, SteamRichPresences.STATUS);
* GameNetworkState status;
* if (Enum.TryParse(presence, out status))
* return status;
*
* return GameNetworkState.Idleness;
* }*/
/*internal static void UpdateUserInfo(ChatPlayerInfo info, CSteamID userId)
* {
* var state = SteamFriends.GetFriendPersonaState(userId);
*
* bool inGame = false;
*
* FriendGameInfo_t gameInfo;
* if (SteamFriends.GetFriendGamePlayed(userId, out gameInfo))
* inGame = gameInfo.m_gameID.AppID().m_AppId == SteamUtils.GetAppID().m_AppId;
*
* info.AvatarData = LoadAvatarsData(userId);
* info.Nickname = SteamFriends.GetFriendPersonaName(userId);
* info.Peer = new SteamPeer(userId);
* info.Rating = SteamFriends.GetFriendRichPresence(userId, SteamRichPresences.RATING).TryParseToInt();
* info.GamesWon = SteamFriends.GetFriendRichPresence(userId, SteamRichPresences.GAMES_WON).TryParseToInt();
* info.GamesLost = SteamFriends.GetFriendRichPresence(userId, SteamRichPresences.GAMES_LOST).TryParseToInt();
* info.Winrate = SteamFriends.GetFriendRichPresence(userId, SteamRichPresences.WINRATE).TryParseToInt();
* info.Online = state != EPersonaState.k_EPersonaStateOffline;
* info.InGame = inGame;
* info.IsUser = userId == SteamUser.GetSteamID();
* info.State = LoadUserState(userId);
* //info.InternalStatus = LoadUserInternalStatus(userId);
* info.Type = LoadUserType(userId);
* info.RatingIcon = LoadUserRatingIcon(userId);
*
* }*/
/* internal static ChatPlayerInfo LoadUserInfo(CSteamID userId)
* {
* var info = new ChatPlayerInfo();
* UpdateUserInfo(info, userId);
* return info;
* }
*
* internal static UserAvatarData LoadAvatarsData(CSteamID userId)
* {
* var data = new UserAvatarData();
*
* data.SmallIcon = LoadIcon(SteamFriends.GetSmallFriendAvatar(userId));
* data.MediumIcon = LoadIcon(SteamFriends.GetMediumFriendAvatar(userId));
* data.LargeIcon = LoadIcon(SteamFriends.GetLargeFriendAvatar(userId));
*
* return data;
* }
*
* private static AvatarIconData LoadIcon(int avatarId)
* {
* AvatarIconData data = new AvatarIconData();
* data.Id = avatarId;
*
* uint w, h;
* if (avatarId > 0 && SteamUtils.GetImageSize(avatarId, out w, out h))
* {
* var bytesCount = w * h * 4;
* var bytes = new byte[bytesCount];
* data.Width = (int)w;
* data.Height = (int)h;
*
* if (SteamUtils.GetImageRGBA(avatarId, bytes, (int)bytesCount))
* {
* data.Bytes = bytes;
* }
* }
*
* return data;
* }*/
/* internal static ChatPlayerType LoadUserType(CSteamID userId)
* {
* return ChatPlayerType.Simple;
* }
*
* internal static RatingIconType LoadUserRatingIcon(CSteamID userId)
* {
* return (RatingIconType)SteamFriends.GetFriendRichPresence(userId, SteamRichPresences.RATING_ICON).TryParseToInt();
* }*/
internal static async Task <List <Tuple <LeaderboardEntry_t, int[]> > > GetLeaderboardEntries(string leaderboardName, ELeaderboardDataRequest type, int start, int end,
int timeout = 10000,
Func <List <Tuple <LeaderboardEntry_t, int[]> >, bool> resultHandler = null,
Func <bool> repeatHandler = null)
{
var resultLeaderboard = await GetLeaderboard(leaderboardName);
return(await TaskHelper.RepeatTaskForeverIfFailed(() => SteamApiHelper.HandleApiCall <List <Tuple <LeaderboardEntry_t, int[]> >, LeaderboardScoresDownloaded_t>(SteamUserStats.DownloadLeaderboardEntries(resultLeaderboard.m_hSteamLeaderboard, type, start, end), CancellationToken.None,
(tcs, result, bIOFailure) =>
{
if (result.m_hSteamLeaderboard.m_SteamLeaderboard == 0 || bIOFailure)
{
tcs.SetException(new Exception("Ошибка GetLeaderboardEntries"));
return;
}
var entriesList = new List <Tuple <LeaderboardEntry_t, int[]> >();
LeaderboardEntry_t entry;
for (int index = 0; index < result.m_cEntryCount; index++)
{
int[] pData = new int[64];
if (SteamUserStats.GetDownloadedLeaderboardEntry(result.m_hSteamLeaderboardEntries, index, out entry, pData, 64))
{
entriesList.Add(Tuple.Create(entry, pData));
}
}
tcs.SetResult(entriesList);
}), timeout, CancellationToken.None, resultHandler : resultHandler, repeatHandler : repeatHandler));
}
internal static extern int DownloadLeaderboardScores(StatusCallback downloadLeaderboardScoresCB, string pchLeaderboardName, ELeaderboardDataRequest eLeaderboardDataRequest, ELeaderboardDataTimeRange eLeaderboardDataTimeRange, int nRangeStart, int nRangeEnd);
/// <summary>
/// <para> Asks the Steam back-end for a set of rows in the leaderboard.</para>
/// <para> This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t</para>
/// <para> LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below)</para>
/// <para> You can ask for more entries than exist, and it will return as many as do exist.</para>
/// <para> k_ELeaderboardDataRequestGlobal requests rows in the leaderboard from the full table, with nRangeStart & nRangeEnd in the range [1, TotalEntries]</para>
/// <para> k_ELeaderboardDataRequestGlobalAroundUser requests rows around the current user, nRangeStart being negate</para>
/// <para> e.g. DownloadLeaderboardEntries( hLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -3, 3 ) will return 7 rows, 3 before the user, 3 after</para>
/// <para> k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user</para>
/// </summary>
public static SteamAPICall_t DownloadLeaderboardEntries(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUserStats_DownloadLeaderboardEntries(CSteamAPIContext.GetSteamUserStats(), hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd));
}
public static extern ulong ISteamUserStats_DownloadLeaderboardEntries(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd);
// Call this once when ever your GUI switches state to download the updated leaderboard entries.
// If you wish to have multiple pages you could pass in the offset from your GUI.
public bool GetLeaderboard(Leaderboard board, ELeaderboardDataRequest requesttype) {
if (!SteamManager.Initialized) {
return false;
}
if (m_bLoading) {
// If we're still loading the Leaderboards then we'll defer this until we've finished
StartCoroutine(RetryGetLeaderboard(board, requesttype));
return false;
}
int offset = 0;
if (requesttype == ELeaderboardDataRequest.k_ELeaderboardDataRequestGlobalAroundUser) {
offset = -5;
}
SteamAPICall_t hSteamAPICall = SteamUserStats.DownloadLeaderboardEntries(m_LeaderboardHandles[(int)board], requesttype, offset, offset + k_nMaxLeaderboardEntries);
// Register for the async callback
m_callResultDownloadedEntries.Set(hSteamAPICall);
m_bDownloading = true;
return true;
}
private static bool SteamUnityAPI_SteamUserStats_RequestLeaderboardEntries(IntPtr stats, ulong leaderboard, ELeaderboardDataRequest requestType, int startIndex, int endIndex, IntPtr OnLeaderboardEntriesRetrievedCallback);
/// <summary>
/// 查询排行榜数据-全球
/// </summary>
/// <param name="leaderboardId"></param>
/// <param name="startRange"></param>
/// <param name="endRange"></param>
/// <param name="type"></param>
/// <param name="callBack"></param>
public void FindLeaderboardEntries(ulong leaderboardId, int startRange, int endRange, ELeaderboardDataRequest type, ISteamLeaderboardEntriesCallBack callBack)
{
this.mEntriesCallBack = callBack;
SteamLeaderboard_t tempBean = new SteamLeaderboard_t
{
m_SteamLeaderboard = leaderboardId
};
CallResult <LeaderboardScoresDownloaded_t> callResult = CallResult <LeaderboardScoresDownloaded_t> .Create(OnLeaderboardScoresDownloaded);
SteamAPICall_t handle = SteamUserStats.DownloadLeaderboardEntries(tempBean, type, startRange, endRange);
//TODO 必须要延迟才能设置回调
//Thread.Sleep(1000);
callResult.Set(handle);
}
private static bool SteamUnityAPI_SteamUserStats_RequestLeaderboardEntries(IntPtr stats, ulong leaderboard, ELeaderboardDataRequest requestType, int startIndex, int endIndex, IntPtr OnLeaderboardEntriesRetrievedCallback);
/// <summary>
/// 查询排行榜数据
/// </summary>
/// <param name="leaderboardId"></param>
/// <param name="startRange"></param>
/// <param name="endRange"></param>
/// <param name="type"></param>
/// <param name="callBack"></param>
private void findLeaderboardEntries(ulong leaderboardId, int startRange, int endRange, ELeaderboardDataRequest type, LeaderboardEntriesFindResultCallBack callBack)
{
OnLeaderboardEntriesFindResultCallBack = callBack;
m_SteamLeaderboard = new SteamLeaderboard_t();
m_SteamLeaderboard.m_SteamLeaderboard = leaderboardId;
OnLeaderboardScoresDownloadedCallResult = CallResult <LeaderboardScoresDownloaded_t> .Create(OnLeaderboardScoresDownloaded);
SteamAPICall_t handle = SteamUserStats.DownloadLeaderboardEntries(m_SteamLeaderboard, type, startRange, endRange);
//TODO 必须要延迟才能设置回调
Thread.Sleep(1000);
OnLeaderboardScoresDownloadedCallResult.Set(handle);
}
public UInt64 DownloadLeaderboardEntries(UInt64 hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, Int32 nRangeStart, Int32 nRangeEnd)
{
UInt64 ret = 0; this.GetFunction <NativeDownloadLeaderboardEntriesUEII>(this.Functions.DownloadLeaderboardEntries24)(this.ObjectAddress, ref ret, hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd); return((UInt64)ret);
}
// If we're still loading the Leaderboards when GetLeaderboard() is called we'll wait until they are loaded and try calling GetLeaderboard() again.
private IEnumerator RetryGetLeaderboard(Leaderboard board, ELeaderboardDataRequest requesttype) {
while (m_bLoading) {
yield return null;
}
GetLeaderboard(board, requesttype);
}
public static SteamAPICall_t DownloadLeaderboardEntries(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd)
{
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamUserStats_DownloadLeaderboardEntries(hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd);
}
// Leaderboard
internal static int DownloadLeaderboardScores(StatusCallback callback, string pchLeaderboardName, ELeaderboardDataRequest nDataRequest, ELeaderboardDataTimeRange nTimeRange, int nRangeStart, int nRangeEnd)
{
int nRequestValue = (int)nDataRequest;
int nTimeValue = (int)nTimeRange;
return(Android.GetJavaUserStats().CallStatic <int>("getLeaderboard", Android.CurrentContext, new AndroidPluginCallback(callback), pchLeaderboardName, nRangeStart, nRangeEnd, nTimeValue, nRequestValue));
}
public UInt64 DownloadLeaderboardEntries(UInt64 hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, Int32 nRangeStart, Int32 nRangeEnd)
{
return(this.GetFunction <NativeDownloadLeaderboardEntriesUEII>(this.Functions.DownloadLeaderboardEntries26)(this.ObjectAddress, hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd));
}
private void OnDownloadScoresFindLeaderboardCallCompleted(string p_leaderboardName, ELeaderboardDataRequest p_scoreSource, int p_rangeStart, int p_rangeEnd, LeaderboardFindResult_t p_callbackFind, bool p_bIOFailureFind)
{
EResult callResultType = p_callbackFind.m_bLeaderboardFound == 1 ? EResult.k_EResultOK : EResult.k_EResultFileNotFound;
if (CheckAndLogResult <LeaderboardFindResult_t, LeaderboardsDownloadedScoresEventArgs>("OnDownloadScoresFindLeaderboardCallCompleted", callResultType, p_bIOFailureFind, "OnDownloadedScores", ref OnDownloadedScores))
{
// download scores
Execute <LeaderboardScoresDownloaded_t>(SteamUserStats.DownloadLeaderboardEntries(p_callbackFind.m_hSteamLeaderboard, p_scoreSource, p_rangeStart, p_rangeEnd), (p_callbackDownload, p_bIOFailureDownload) => OnDownloadLeaderboardEntriesCallCompleted(p_leaderboardName, p_callbackDownload, p_bIOFailureDownload));
if (IsDebugLogEnabled)
{
Debug.Log("DownloadScores: leaderboard '" + p_leaderboardName + "' found, starting scores download");
}
}
}
/// <summary>
/// Asks the Steam back-end for a set of rows in the leaderboard.
/// Results are returned in a <see cref="LeaderboardEntriesCallback"/>.
/// The returned <see cref="AsyncJob{T}"/> can also be awaited to retrieve the callback result.
/// </summary>
/// <param name="appId">The AppID to request leaderboard rows for.</param>
/// <param name="id">ID of the leaderboard to view.</param>
/// <returns>The Job ID of the request. This can be used to find the appropriate <see cref="LeaderboardEntriesCallback"/>.</returns>
/// <param name="rangeStart">Range start or 0.</param>
/// <param name="rangeEnd">Range end or max leaderboard entries.</param>
/// <param name="dataRequest">Type of request.</param>
public AsyncJob <LeaderboardEntriesCallback> GetLeaderboardEntries(uint appId, int id, int rangeStart, int rangeEnd, ELeaderboardDataRequest dataRequest)
{
var msg = new ClientMsgProtobuf <CMsgClientLBSGetLBEntries>(EMsg.ClientLBSGetLBEntries);
msg.SourceJobID = Client.GetNextJobID();
// routing_appid has to be set correctly to receive a response
msg.ProtoHeader.routing_appid = appId;
msg.Body.app_id = ( int )appId;
msg.Body.leaderboard_id = id;
msg.Body.leaderboard_data_request = ( int )dataRequest;
msg.Body.range_start = rangeStart;
msg.Body.range_end = rangeEnd;
Client.Send(msg);
return(new AsyncJob <LeaderboardEntriesCallback>(this.Client, msg.SourceJobID));
}
public bool FetchLeaderBoardData(string leaderBoardName, ResultsCallBack callbackAction, int startRange, int endRange, ELeaderboardDataRequest requestType)
{
bool result = false;
this.callbackAction = callbackAction;
SteamLeaderboard_t leaderBoard;
if (SteamManager.Initialized)
{
if (leaderBoards.TryGetValue(leaderBoardName, out leaderBoard))
{
SteamAPICall_t apiCall = SteamUserStats.DownloadLeaderboardEntries(leaderBoard, requestType, startRange, endRange);
if (leaderBoardScoresDownloaded.IsActive())
{
leaderBoardScoresDownloaded.Cancel();
leaderBoardScoresDownloaded.Dispose();
}
leaderBoardScoresDownloaded.Set(apiCall);
result = true;
}
else
{
//Get or create the leader board
actionType = 1;
result = FindOrCreateLeaderboard(leaderBoardName);
}
}
return(result);
}
/// <summary>
/// Asks the Steam back-end for a set of rows in the leaderboard.
/// Results are returned in a <see cref="LeaderboardEntriesCallback"/>.
/// </summary>
/// <param name="appId">The AppID to request leaderboard rows for.</param>
/// <param name="id">ID of the leaderboard to view.</param>
/// <returns>The Job ID of the request. This can be used to find the appropriate <see cref="LeaderboardEntriesCallback"/>.</returns>
/// <param name="rangeStart">Range start or 0.</param>
/// <param name="rangeEnd">Range end or max leaderboard entries.</param>
/// <param name="dataRequest">Type of request.</param>
public JobID GetLeaderboardEntries( uint appId, int id, int rangeStart, int rangeEnd, ELeaderboardDataRequest dataRequest )
{
var msg = new ClientMsgProtobuf<CMsgClientLBSGetLBEntries>( EMsg.ClientLBSGetLBEntries );
msg.SourceJobID = Client.GetNextJobID();
// routing_appid has to be set correctly to receive a response
msg.ProtoHeader.routing_appid = appId;
msg.Body.app_id = ( int )appId;
msg.Body.leaderboard_id = id;
msg.Body.leaderboard_data_request = ( int )dataRequest;
msg.Body.range_start = rangeStart;
msg.Body.range_end = rangeEnd;
Client.Send( msg );
return msg.SourceJobID;
}
/// Asks the Steam back-end for a set of rows in the leaderboard.
/// This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t
/// LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below)
/// You can ask for more entries than exist, and it will return as many as do exist.
/// k_ELeaderboardDataRequestGlobal requests rows in the leaderboard from the full table, with nRangeStart & nRangeEnd in the range [1, TotalEntries]
/// k_ELeaderboardDataRequestGlobalAroundUser requests rows around the current user, nRangeStart being negate
/// e.g. DownloadLeaderboardEntries( hLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -3, 3 ) will return 7 rows, 3 before the user, 3 after
/// k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user
public static SteamAPICall_t DownloadLeaderboardEntries(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd)
{
return((SteamAPICall_t)0);
}
