static private void OnLeaderboardUploadResult(LeaderboardScoreUploaded_t pCallback, bool failure)
{
RawFuncs.Print("4. STEAM LEADERBOARDS: failure - " + failure + " Completed - " + pCallback.m_bSuccess + " NewScore: " + pCallback.m_nGlobalRankNew + " Score " + pCallback.m_nScore + " HasChanged - " + pCallback.m_bScoreChanged);
for (int i = 0; i < queue.Count; i++)
{
if (queue[i].open)
{
if (queue[i].waitingForUpload)
{
if (!failure)
{
queue[i].finished = true;
queue[i].open = false;
RawFuncs.Print("5. Success!");
PlayerPrefs.SetInt("Syncd_" + queue[i].type, 1);
PlayerPrefs.Save();
}
else
{
queue[i].finished = false;
queue[i].waitingForUpload = false; //try again
RawFuncs.Print("5b. Trying again...");
}
}
return;
}
}
}
internal static LeaderboardUpdate From(LeaderboardScoreUploaded_t e) =>
new LeaderboardUpdate
{
Score = e.Score,
Changed = e.ScoreChanged == 1,
NewGlobalRank = e.GlobalRankNew,
OldGlobalRank = e.GlobalRankPrevious
};
private void OnLeaderboardUploadResult(LeaderboardScoreUploaded_t pCallback, bool failure)
{
UnityEngine.Debug.Log("STEAM LEADERBOARDS: failure - " + failure + " Completed - " + pCallback.m_bSuccess + " NewScore: " + pCallback.m_nGlobalRankNew + " Score " + pCallback.m_nScore + " HasChanged - " + pCallback.m_bScoreChanged);
if (!failure)
{
DownloadEntries();
}
}
// SteamAPICall_t
public CallbackHandle UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard /*SteamLeaderboard_t*/, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod /*ELeaderboardUploadScoreMethod*/, int nScore /*int32*/, int[] pScoreDetails /*const int32 **/, int cScoreDetailsCount /*int*/, Action<LeaderboardScoreUploaded_t, bool> CallbackFunction = null /*Action<LeaderboardScoreUploaded_t, bool>*/ )
{
SteamAPICall_t callback = 0;
callback = platform.ISteamUserStats_UploadLeaderboardScore( hSteamLeaderboard.Value, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount );
if ( CallbackFunction == null ) return null;
return LeaderboardScoreUploaded_t.CallResult( steamworks, callback, CallbackFunction );
}
private void OnLeaderboardScoreUploaded(LeaderboardScoreUploaded_t param, bool bIOFailure)
{
if (param.m_bSuccess == 0 || bIOFailure)
{
Debug.LogError(name + " Leaderboard Data Object, failed to upload score to Steam: Success code = " + param.m_bSuccess, this);
}
RefreshUserEntry();
}
public static LeaderboardUpdate From(LeaderboardScoreUploaded_t e)
{
return(new LeaderboardUpdate
{
Score = e.Score,
Changed = e.ScoreChanged == 1,
NewGlobalRank = e.GlobalRankNew,
OldGlobalRank = e.GlobalRankPrevious
});
}
/// <summary>
/// Ons the leaderboard score uploaded.
/// </summary>
/// <param name="pCallback">P callback.</param>
/// <param name="bIOFailure">If set to <c>true</c> b IOF ailure.</param>
private void OnLeaderboardScoreUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
//m_nGlobalRankPrevious 0: 新規
Debug.Log("[" + LeaderboardScoreUploaded_t.k_iCallback + " - LeaderboardScoreUploaded] - " + pCallback.m_bSuccess + " -- " + pCallback.m_hSteamLeaderboard + " -- " + pCallback.m_nScore + " -- " + pCallback.m_bScoreChanged + " -- " + pCallback.m_nGlobalRankNew + " -- " + pCallback.m_nGlobalRankPrevious);
if (callBackUpload != null)
{
callBackUpload(pCallback);
}
}
private void OnLeaderBoardScoresUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
if (pCallback.m_bSuccess == 0 || bIOFailure)
{
Debug.Log("[LeaderBoard] There was an error uploading scores.");
}
else
{
Debug.Log("[LeaderBoard] Score Uploaded to Leaderboard");
}
}
private void UploadResult(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
if (pCallback.m_bSuccess != 1 || bIOFailure)
{
//debug.Log("Not uploaded." + pCallback.m_bSuccess+" " +bIOFailure);
}
else
{
//debug.Log("Uploaded");
}
}
void OnLeaderboardUploadResult(LeaderboardScoreUploaded_t cb, bool IOFailure)
{
if (cb.m_bSuccess == 0 || IOFailure)
{
print("<Steamworks> Error Uploading Scores");
}
else
{
hasLeaderBoard = false;
}
}
private void OnSaveEntryResponse(LeaderboardScoreUploaded_t callback, bool isFail)
{
if (isFail)
{
UnityEngine.Debug.LogError("Something went wrong with writing to leaderboard");
}
else
{
UnityEngine.Debug.Log("Leaderboard entry added");
_isReady = true;
}
}
void OnUploadScore(LeaderboardScoreUploaded_t callback, bool ioFailure)
{
if (callback.m_bSuccess == 0 || ioFailure)
{
Debug.LogError("Score could not be uploaded to Steam!");
}
else
{
Debug.Log("Uploaded Score!");
}
uploadInProgress = false;
}
private void IniLeaderboardScoreUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
if (pCallback.m_bSuccess == 0 || bIOFailure)
{
Debug.Log("SteamLeaderboardScoreUploaded Error");
}
else
{
Debug.Log("SteamLeaderboardScoreUploaded OK");
SteamLeaderboardScoreUploaded = pCallback;
uploadScore = true;
reWriteTop = false;
}
}
private void OnLeaderboardScoreUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
if (!bIOFailure)
{
KeyValuePair <string, SteamLeaderboard_t?>?entry = leaderbordsStatus.Where(y => y.Value == pCallback.m_hSteamLeaderboard).FirstOrDefault();
if (entry != null)
{
string leaderboardId = entry.Value.Key;
LeaderboardScoreEntryArg arg = new LeaderboardScoreEntryArg(leaderboardId, pCallback.m_nGlobalRankNew, pCallback.m_nScore);
RaiseGameServiceEvent(new GameServiceEvent(GameServiceEventType.LeaderboardScoreReady, arg));
}
}
}
private void OnLeaderboardScoreUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
Debug.Log("[" + LeaderboardScoreUploaded_t.k_iCallback + " - LeaderboardScoreUploaded] - " + pCallback.m_bSuccess + " -- " + pCallback.m_hSteamLeaderboard + " -- " + pCallback.m_nScore + " -- " + pCallback.m_bScoreChanged + " -- " + pCallback.m_nGlobalRankNew + " -- " + pCallback.m_nGlobalRankPrevious);
if (pCallback.m_bScoreChanged == 1)
{
rank = pCallback.m_nGlobalRankNew;
}
if (rank == 1)
{
UnlockAchievement(AchievementID.ACH_CURRENT_HIGHSCORE);
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="pCallback"></param>
/// <param name="bIOFailure"></param>
private void OnLeaderboardScoreUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
if (bIOFailure)
{
if (mUpdateCallBack != null)
{
mUpdateCallBack.UpdateLeaderboardFail(SteamLeaderboardFailEnum.UPDATE_FAIL);
}
return;
}
if (mUpdateCallBack != null)
{
mUpdateCallBack.UpdateLeaderboardSucess();
}
}
void ScoreUploaded_OnRun(ulong callHandle, LeaderboardScoreUploaded_t param)
{
if (callHandle != uploadCall)
{
return;
}
try
{
LoadSelfRank(param.m_hSteamLeaderboard);
}
finally
{
uploadCall = 0;
}
}
private void OnLeaerboardScoreUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
if (pCallback.m_bSuccess != 1)
{
//UploadScore(PlayerControl.Ins.Award);
}
//else if(pCallback.m_hSteamLeaderboard!= m_steamLeaderboard)
//{
// Debug.LogError("获取排行榜数据信息有误！！");
//}
else
{
Debug.LogError("成功上传价值数据：" + pCallback.m_nScore + "榜内数据是否需要变更：" + pCallback.m_bScoreChanged
+ "新的排名：" + pCallback.m_nGlobalRankNew + "上次排名：" + pCallback.m_nGlobalRankPrevious);
gos[gos.Count - 1].transform.FindChild("name").GetComponent <UILabel>().text = pCallback.m_nGlobalRankNew + " " + SteamFriends.GetPersonaName();
gos[gos.Count - 1].transform.FindChild("score").GetComponent <UILabel>().text = pCallback.m_nScore + "";
if (pCallback.m_nGlobalRankPrevious == 0 || pCallback.m_bScoreChanged != 0)
{
}
DownloadLeaderboardEntries();
}
}
private void OnLeaderboardUploadResult(LeaderboardScoreUploaded_t pCallback, bool failure)
{
Debug.Log($"Steam Leaderboard Upload: Did it fail? {failure}, Score: {pCallback.m_nScore}, HasChanged: {pCallback.m_bScoreChanged}");
}
private void OnLeaderboardScoreUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
}
void OnLeaderboardScoreUploaded(LeaderboardScoreUploaded_t pCallback, bool bIOFailure)
{
Debug.Log("[" + LeaderboardScoreUploaded_t.k_iCallback + " - LeaderboardScoreUploaded] - " + pCallback.m_bSuccess + " -- " + pCallback.m_hSteamLeaderboard + " -- " + pCallback.m_nScore + " -- " + pCallback.m_bScoreChanged + " -- " + pCallback.m_nGlobalRankNew + " -- " + pCallback.m_nGlobalRankPrevious);
}
//This method is just to check if the upload was successful and permits to debug some things like Failure, if the score was set, etc etc
static private void OnLeaderBoardUploadResult(LeaderboardScoreUploaded_t _callback, bool _IOFailure)
{
Debug.Log("STEAM LEADERBOARDS: failure - " + _IOFailure + " Completed - " + _callback.m_bSuccess + " NewScore: " + _callback.m_nGlobalRankNew + " Score: " + _callback.m_nScore + " HasChanged - " + _callback.m_bScoreChanged);
}
private void OnUploadLeaderboardScoreCallCompleted(string p_leaderboardName, int p_score, LeaderboardScoreUploaded_t p_callback, bool p_bIOFailure)
{
EResult callResultType = p_callback.m_bSuccess == 1 ? EResult.k_EResultOK : EResult.k_EResultUnexpectedError;
if (CheckAndLogResult <LeaderboardScoreUploaded_t, LeaderboardsUploadedScoreEventArgs>("OnUploadLeaderboardScoreCallCompleted", callResultType, p_bIOFailure, GetEventNameForOnUploadedScore(p_leaderboardName, p_score), ref OnUploadedScore))
{
// inform listeners
if (OnUploadedScore != null)
{
ELeaderboardDisplayType scoreType = SteamUserStats.GetLeaderboardDisplayType(p_callback.m_hSteamLeaderboard);
InvokeEventHandlerSafely(OnUploadedScore, new LeaderboardsUploadedScoreEventArgs()
{
LeaderboardName = p_leaderboardName,
Score = p_callback.m_nScore,
ScoreString = FormatScore(p_callback.m_nScore, scoreType),
ScoreType = scoreType,
IsScoreChanged = p_callback.m_bScoreChanged == 1,
GlobalRankNew = p_callback.m_nGlobalRankNew,
GlobalRankPrevious = p_callback.m_nGlobalRankPrevious,
SteamNative = new LeaderboardsUploadedScoreEventArgs.SteamNativeData(p_callback.m_hSteamLeaderboard)
});
ClearSingleShotEventHandlers(GetEventNameForOnUploadedScore(p_leaderboardName, p_score), ref OnUploadedScore);
}
}
}
void UploadResult(LeaderboardScoreUploaded_t uploadResult, bool failure)
{
Debug.Log("STEAM LEADERBOARDS: isfailure = " + failure + ") isCompleted = " + uploadResult.m_bSuccess + ") GlobalNew: " + uploadResult.m_nGlobalRankNew + ") UploScore " + uploadResult.m_nScore + ") HasChanged - " + uploadResult.m_bScoreChanged);
}
