public static async void GetLevelLeaderboard(string levelLeaderboardName)
{
var leaderboard = await SteamUserStats.FindLeaderboardAsync(levelLeaderboardName);
if (leaderboard.HasValue)
{
Steamworks.Data.Leaderboard unwrappedLeaderboard = leaderboard.Value;
}
else
{
Debug.LogError($"Could not retrieve leaderboard {levelLeaderboardName} from steam");
}
}
public override void OnEnter()
{
isSuccess.Value = (bool)SteamUserStats.ClearAchievement((string)achievementAPIname.Value);
if (isSuccess.Value)
{
Fsm.Event(success);
}
else
{
Fsm.Event(failed);
}
Finish();
}
/// <summary>
/// Refreshes the user's entry for this board
/// </summary>
public void RefreshUserEntry()
{
if (!LeaderboardId.HasValue)
{
Debug.LogError(name + " Leaderboard Data Object, cannot download scores, the leaderboard has not been initalized and cannot download scores.");
return;
}
CSteamID[] users = new CSteamID[] { SteamUser.GetSteamID() };
var handle = SteamUserStats.DownloadLeaderboardEntriesForUsers(LeaderboardId.Value, users, 1);
OnLeaderboardScoresDownloadedCallResult.Set(handle, OnLeaderboardUserRefreshRequest);
}
public static async Task <List <LeaderboardEntry> > FindLeaderboard(string name, int entryCount)
{
var leaderboard = await SteamUserStats.FindLeaderboardAsync(name);
if (leaderboard.HasValue)
{
return(GetLeaderboardScores(leaderboard.Value, entryCount).Result);
}
else
{
return(new List <LeaderboardEntry>());
}
}
public LeaderEntry[] ReadDownloadedTop100Entries()
{
Debug.Log("[LeaderBoard] reading top 100 entries");
LeaderEntry[] vals = new LeaderEntry[topEntriesCount];
for (int i = 0; i < topEntriesCount; i++)
{
LeaderboardEntry_t entry_T;
SteamUserStats.GetDownloadedLeaderboardEntry(hSteamTop100Entries, i, out entry_T, pScoreDetails, cScoreDetailsCount);
vals[i] = new LeaderEntry(entry_T.m_steamIDUser, entry_T.m_nGlobalRank, entry_T.m_nScore);
}
return(vals);
}
public void ResetAchievements()
{
if (active && SteamAPI.IsSteamRunning())
{
try
{
SteamUserStats.ResetAllStats(bAchievementsToo: true);
}
catch (Exception)
{
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Accumulate distance traveled
//-----------------------------------------------------------------------------
//public void AddDistanceTraveled(float flDistance)
//{
// m_flGameFeetTraveled += flDistance;
//}
//-----------------------------------------------------------------------------
// Purpose: Game state has changed
//-----------------------------------------------------------------------------
//public void OnGameStateChange(EClientGameState eNewState)
//{
// if (!m_bStatsValid)
// return;
// if (eNewState == EClientGameState.k_EClientGameActive)
// {
// // Reset per-game stats
// m_flGameFeetTraveled = 0;
// m_ulTickCountGameStart = Time.time;
// }
// else if (eNewState == EClientGameState.k_EClientGameWinner || eNewState == EClientGameState.k_EClientGameLoser)
// {
// if (eNewState == EClientGameState.k_EClientGameWinner)
// {
// m_nTotalNumWins++;
// }
// else
// {
// m_nTotalNumLosses++;
// }
// // Tally games
// m_nTotalGamesPlayed++;
// // Accumulate distances
// m_flTotalFeetTraveled += m_flGameFeetTraveled;
// // New max?
// if (m_flGameFeetTraveled > m_flMaxFeetTraveled)
// m_flMaxFeetTraveled = m_flGameFeetTraveled;
// // Calc game duration
// m_flGameDurationSeconds = Time.time - m_ulTickCountGameStart;
// // We want to update stats the next frame.
// m_bStoreStats = true;
// }
//}
//-----------------------------------------------------------------------------
// Purpose: Unlock this achievement
//-----------------------------------------------------------------------------
private void UnlockAchievement(Achievement_t achievement)
{
achievement.m_bAchieved = true;
// the icon may change once it's unlocked
//achievement.m_iIconImage = 0;
// mark it down
SteamUserStats.SetAchievement(achievement.m_eAchievementID.ToString());
// Store stats end of frame
m_bStoreStats = true;
}
public static void ResetAllStats(bool andCheevos = true)
{
if (!SteamInitialized)
{
return;
}
SteamUserStats.ResetAllStats(andCheevos);
SteamUserStats.RequestCurrentStats();
_achievementDictionary = new Dictionary <string, bool>();
_statDictionary = new Dictionary <string, int>();
StatsInitialized.Value = false;
}
public void UpdateLeaderboardScore(ulong leaderboardId, int score, int[] scoreDetails, int scoreDetailsMax, ISteamLeaderboardUpdateCallBack callBack)
{
this.mUpdateCallBack = callBack;
SteamLeaderboard_t m_SteamLeaderboard = new SteamLeaderboard_t
{
m_SteamLeaderboard = leaderboardId
};
CallResult <LeaderboardScoreUploaded_t> callResult = CallResult <LeaderboardScoreUploaded_t> .Create(OnLeaderboardScoreUploaded);
SteamAPICall_t handle = SteamUserStats.UploadLeaderboardScore(m_SteamLeaderboard, ELeaderboardUploadScoreMethod.k_ELeaderboardUploadScoreMethodForceUpdate, score, scoreDetails, scoreDetailsMax);
callResult.Set(handle);
}
public void ChangeLeaderboard(int newScore)
{
//store for a retry?
recentScore = newScore;
if (foundLeaderboard)
{
//create new call instance
SteamAPICall_t newApiCall = SteamUserStats.UploadLeaderboardScore(leaderboard_t, ELeaderboardUploadScoreMethod.k_ELeaderboardUploadScoreMethodKeepBest, newScore, null, 0);
//upload call
uploadResultLeaderboard.Set(newApiCall);
}
}
private void MyCallbacks_LobbyCreated(SteamHubLobby lobby)
{
int elo;
//bool ret =
SteamUserStats.GetStat("NumGames", out elo);
//if (ret)
// lobby.SetData<string>("ELO", ret);
lobby.SetData <string>("name", lobbyName.GetComponent <Text>().text);
Debug.Log("LOBBY CREATED CALLBACK: Lobby name\"" + lobby.GetData <string>("name") + "\"");
}
public void Init()
{
if (!SteamManager.Initialized)
{
Debug.Assert(false, "SteamManager not initialized");
}
stats.Clear();
stats.Add("NUM_WAVES_COMPLETED", 0);
stats.Add("DAMAGE_DEALT", 0);
stats.Add("CRITICAL_HITS", 0);
stats.Add("COMBOS_GAINED", 0);
stats.Add("HEALTH_HEALED", 0);
stats.Add("NUM_RESURRECTIONS", 0);
stats.Add("MINIONS_UNLOCKED", 0);
achievementProgress.Clear();
achievementProgress.Add("NUM_WAVES_COMPLETED", new AchievementProgressData[2] {
new AchievementProgressData("GETTING_STARTED", 25, 100),
new AchievementProgressData("VETERAN_MINIMANCER", 50, 250)
});
achievementProgress.Add("DAMAGE_DEALT", new AchievementProgressData[2] {
new AchievementProgressData("DAMAGE_DEALER", 25000, 100000),
new AchievementProgressData("DAMAGE_MASTER", 100000, 1000000)
});
achievementProgress.Add("CRITICAL_HITS", new AchievementProgressData[1] {
new AchievementProgressData("CRITICALLY_ACCLAIMED", 100, 500)
});
achievementProgress.Add("COMBOS_GAINED", new AchievementProgressData[1] {
new AchievementProgressData("COMBO_COLLECTOR", 250, 1000)
});
achievementProgress.Add("HEALTH_HEALED", new AchievementProgressData[1] {
new AchievementProgressData("MASTER_HEALER", 2500, 10000)
});
achievementProgress.Add("NUM_RESURRECTIONS", new AchievementProgressData[1] {
new AchievementProgressData("UNKILLABLE", 10, 30)
});
achievementProgress.Add("MINIONS_UNLOCKED", new AchievementProgressData[1] {
new AchievementProgressData("COMPLETIONIST", 10, 113)
});
gameID = new CGameID(SteamUtils.GetAppID());
statsRecievedCallback = Callback <UserStatsReceived_t> .Create(OnStatsReceived);
statsStoredCallback = Callback <UserStatsStored_t> .Create(OnStatsStored);
achievementStoredCallback = Callback <UserAchievementStored_t> .Create(OnAchievementStored);
bRequestedStats = SteamUserStats.RequestCurrentStats();
}
private static void OnUserStatsReceived(UserStatsReceived_t pCallback)
{
if (!SteamInitialized)
{
return;
}
if (pCallback.m_nGameID != Main.SteamAppID || pCallback.m_eResult != EResult.k_EResultOK)
{
return;
}
//I'm sorry, Evan. We'll need to find somewhere nice to put this part.
string[] cheevoNames = new string[]
{
"ending_a",
"ending_b",
"ending_c",
"ending_d",
"ending_e",
"cheating_jerk",
"pillar_crushed",
"orbs",
};
string[] statNames = new string[]
{
"orbs_collected"
};
foreach (var cheevo in cheevoNames)
{
bool value;
bool success = SteamUserStats.GetAchievement("cheevo_" + cheevo, out value);
if (success)
{
_achievementDictionary.Add("cheevo_" + cheevo, value);
}
}
foreach (var stat in statNames)
{
int value;
bool success = SteamUserStats.GetStat("stat_" + stat, out value);
if (success)
{
_statDictionary.Add("stat_" + stat, value);
}
}
StatsInitialized = true;
}
public static void UploadStats(bool force = false)
{
if (!Initialized)
{
return;
}
if (!_anythingChanged && !force)
{
return;
}
SteamUserStats.StoreStats();
_anythingChanged = false;
_statsLastUploaded = DateTime.Now;
}
public int GetIntStat(AchievementData ach)
{
int result;
if (ach.StatHandle != null)
{
SteamUserStats.GetStat(ach.StatHandle, out result);
}
else
{
SteamUserStats.GetStat(ach.StatKey, out result);
}
return(result);
}
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");
}
}
}
public void lvl_5_complite()
{
if (gameplayParametrs != null && !gameplayParametrs.ThisDemoVersion)
{
bool resultYN = false;
bool unloskYN = false;
resultYN = SteamUserStats.GetAchievement(name_Complete_lvl_5, out unloskYN);
if (resultYN && !unloskYN)
{
SteamUserStats.SetAchievement(name_Complete_lvl_5);
to_server_ok = false;
}
}
}
public void UnlockSteamAchievement(string ID)
{
TestSteamAchievement(ID);
if (!unlockTest)
{
Debug.Log("Unlock" + ID);
SteamUserStats.SetAchievement(ID);
SteamUserStats.StoreStats();
}
else
{
Debug.Log("Already Unlock" + ID);
}
}
public override void OnEnter()
{
isSuccess.Value = (bool)SteamUserStats.IndicateAchievementProgress((string)achievementAPIname.Value, (uint)CurrentProgress.Value, (uint)MaxProgress.Value);
if (isSuccess.Value)
{
SteamUserStats.StoreStats();
Fsm.Event(success);
}
else
{
Fsm.Event(failed);
}
Finish();
}
public void plus_1_tank_shell()
{
if (gameplayParametrs != null && !gameplayParametrs.ThisDemoVersion)
{
Destroy_tank_shell++;
SteamUserStats.SetStat(name_Destroy_tankShell, Destroy_tank_shell);
if (Destroy_tank_shell == 10)
{
to_server_ok = false;
}
}
}
public void TestNewScoreTop(int NewScoreTop)
{
if (ScoreTop < NewScoreTop)
{
ScoreTop = NewScoreTop;
SteamUserStats.SetStat(name_ScoreTop, ScoreTop);
//Если счет резко отличается то нужно отправить немедленно или если игра закончилать
if (ScoreTopOldSend * 10 < ScoreTop || (gameplayParametrs != null && gameplayParametrs.GameOver))
{
//to_server_ok = false;
}
}
}
public void zero_score()
{
if (gameplayParametrs != null && !gameplayParametrs.ThisDemoVersion)
{
bool resultYN = false;
bool unloskYN = false;
resultYN = SteamUserStats.GetAchievement(name_zero_score, out unloskYN);
if (resultYN && !unloskYN)
{
SteamUserStats.SetAchievement(name_zero_score);
to_server_ok = false;
}
}
}
public void destroy_fighter()
{
if (gameplayParametrs != null && !gameplayParametrs.ThisDemoVersion)
{
bool resultYN = false;
bool unloskYN = false;
resultYN = SteamUserStats.GetAchievement(name_destroy_fighter, out unloskYN);
if (resultYN && !unloskYN)
{
SteamUserStats.SetAchievement(name_destroy_fighter);
to_server_ok = false;
}
}
}
public static void GetSteamAchievement(string achievementName)
{
if (fa.dontConnectSteam)
{
return;
}
if (SteamManager.Initialized)
{
bool resultBool = false;
SteamUserStats.GetAchievement(achievementName, out resultBool);
SteamUserStats.SetAchievement(achievementName);
}
}
void inicialize()
{
//Получить
bool geting_current_acivment = false;
geting_current_acivment = SteamUserStats.RequestCurrentStats();
bool geting_stats = false;
SteamAPICall_t user = SteamUserStats.RequestUserStats(SteamUser.GetSteamID());
if (geting_current_acivment && user != null)
{
inicialized_yn = true;
}
}
public void IncrementGoldEarnedStats(long goldEarned)
{
if (m_StatsValid)
{
m_GoldEarned += (int)goldEarned;
SteamUserStats.SetStat("Gold Earned", m_GoldEarned);
if (m_GoldEarned < 10000)
{
SteamUserStats.IndicateAchievementProgress("Gold Earned", (uint)m_GoldEarned, 10000);
}
}
SteamUserStats.StoreStats();
Debug.Log("[SteamStats] " + m_GoldEarned + "Gold Earned");
}
public void UploadStatistics()
{
if (m_initialised)
{
if (m_statsNeedUpload && SteamUserStats.StoreStats())
{
m_statsNeedUpload = false;
}
}
else
{
m_earlyUpload = true;
}
}
public void SetLeaderBoardScore(int score)
{
Debug.Log("[LeaderBoard] Setting leaderboard score to: " + score);
if (score >= 0 && score <= 5000)
{
SteamAPICall_t handle2 = SteamUserStats.UploadLeaderboardScore(hSteamLeaderboard, eLeaderboardUploadScoreMethod, score, pScoreDetails, cScoreDetailsCount);
m_LeaderBoardScoreUploaded.Set(handle2);
}
else if (score >= 5000)
{
SteamAPICall_t handle2 = SteamUserStats.UploadLeaderboardScore(hSteamLeaderboard, eLeaderboardUploadScoreMethod, 5000, pScoreDetails, cScoreDetailsCount);
m_LeaderBoardScoreUploaded.Set(handle2);
}
}
public void UpdateScore(int score)
{
if (!s_initialized)
{
Debug.LogError("Leaderboard not initialized");
}
else
{
score = PlayerPrefs.GetInt("high_wave", 0);
//Change upload method to
SteamAPICall_t hSteamAPICall = SteamUserStats.UploadLeaderboardScore(s_currentLeaderboard, ELeaderboardUploadScoreMethod.k_ELeaderboardUploadScoreMethodKeepBest, score, null, 0);
m_uploadResult.Set(hSteamAPICall, OnLeaderboardUploadResult);
}
}
public static void SetAchievement(string id)
{
if (SteamManager.Initialized)
{
CheckAchievement(id);
if (!unlocked)
{
Debug.Log($"Unlocking {id}...");
SteamUserStats.SetAchievement(id);
SteamUserStats.StoreStats();
}
}
}
