Merge branch 'master' into overlay_h

dll/dll.cpp

@@ -135,6 +135,7 @@ Steam_Client *get_steam_clientserver_old()
 S_API void * S_CALLTYPE SteamInternal_CreateInterface( const char *ver )
 {
     PRINT_DEBUG("SteamInternal_CreateInterface %s\n", ver);
+    if (!get_steam_client()->user_logged_in) return NULL;
 
     if (strstr(ver, "SteamClient") == ver) {
         void *steam_client;
@@ -221,6 +222,7 @@ S_API bool S_CALLTYPE SteamAPI_InitAnonymousUser()
 S_API void S_CALLTYPE SteamAPI_Shutdown()
 {
     PRINT_DEBUG("SteamAPI_Shutdown\n");
+    get_steam_client()->clientShutdown();
 }
 
 // SteamAPI_RestartAppIfNecessary ensures that your executable was launched through Steam.
@@ -590,7 +592,7 @@ S_API uint64 SteamGameServer_GetSteamID()
 S_API ISteamClient *SteamGameServerClient() { 
     PRINT_DEBUG("SteamGameServerClient()\n");
     load_old_interface_versions();
-    get_steam_clientserver_old();
+    if (!get_steam_clientserver_old()->IsServerInit()) return NULL;
     return (ISteamClient *)SteamInternal_CreateInterface(old_client); 
 }
 

dll/settings.cpp

@@ -53,6 +53,7 @@ Settings::Settings(CSteamID steam_id, CGameID game_id, std::string name, std::st
     this->unlockAllDLCs = true;
 
     this->offline = offline;
+    this->create_unknown_leaderboards = true;
 }
 
 CSteamID Settings::get_local_steam_id()
@@ -193,3 +194,12 @@ std::string Settings::getAppInstallPath(AppId_t appID)
 {
     return app_paths[appID];
 }
+
+void Settings::setLeaderboard(std::string leaderboard, enum ELeaderboardSortMethod sort_method, enum ELeaderboardDisplayType display_type)
+{
+    Leaderboard_config leader;
+    leader.sort_method = sort_method;
+    leader.display_type = display_type;
+
+    leaderboards[leaderboard] = leader;
+}

dll/settings.h

@@ -33,6 +33,11 @@ struct Mod_entry {
     std::string path;
 };
 
+struct Leaderboard_config {
+    enum ELeaderboardSortMethod sort_method;
+    enum ELeaderboardDisplayType display_type;
+};
+
 class Settings {
     CSteamID steam_id;
     CGameID game_id;
@@ -44,6 +49,8 @@ class Settings {
     std::vector<struct DLC_entry> DLCs;
     std::vector<struct Mod_entry> mods;
     std::map<AppId_t, std::string> app_paths;
+    std::map<std::string, Leaderboard_config> leaderboards;
+    bool create_unknown_leaderboards;
 
 public:
 #ifdef LOBBY_CONNECT
@@ -78,6 +85,12 @@ public:
     Mod_entry getMod(PublishedFileId_t id);
     bool isModInstalled(PublishedFileId_t id);
     std::set<PublishedFileId_t> modSet();
+
+    //leaderboards
+    void setLeaderboard(std::string leaderboard, enum ELeaderboardSortMethod sort_method, enum ELeaderboardDisplayType display_type);
+    std::map<std::string, Leaderboard_config> getLeaderboards() { return leaderboards; }
+    void setCreateUnknownLeaderboards(bool enable) {create_unknown_leaderboards = enable;}
+    bool createUnknownLeaderboards() { return create_unknown_leaderboards; }
 };
 
 #endif

dll/steam_client.cpp

@@ -278,6 +278,47 @@ Steam_Client::Steam_Client()
         }
     }
 
+    {
+        std::string dlc_config_path = Local_Storage::get_game_settings_path() + "leaderboards.txt";
+        std::ifstream input( dlc_config_path );
+        if (input.is_open()) {
+            settings_client->setCreateUnknownLeaderboards(false);
+            settings_server->setCreateUnknownLeaderboards(false);
+
+            for( std::string line; getline( input, line ); ) {
+                if (!line.empty() && line[line.length()-1] == '\n') {
+                    line.erase(line.length()-1);
+                }
+
+                if (!line.empty() && line[line.length()-1] == '\r') {
+                    line.erase(line.length()-1);
+                }
+
+                std::string leaderboard;
+                unsigned int sort_method = 0;
+                unsigned int display_type = 0;
+
+                std::size_t deliminator = line.find("=");
+                if (deliminator != 0 && deliminator != std::string::npos && deliminator != line.size()) {
+                    leaderboard = line.substr(0, deliminator);
+                    std::size_t deliminator2 = line.find("=", deliminator + 1);
+                    if (deliminator2 != std::string::npos && deliminator2 != line.size()) {
+                        sort_method = stol(line.substr(deliminator + 1, deliminator2));
+                        display_type = stol(line.substr(deliminator2 + 1));
+                    }
+                }
+
+                if (leaderboard.size() && sort_method <= k_ELeaderboardSortMethodDescending && display_type <= k_ELeaderboardDisplayTypeTimeMilliSeconds) {
+                    PRINT_DEBUG("Adding leaderboard: %s|%u|%u\n", leaderboard.c_str(), sort_method, display_type);
+                    settings_client->setLeaderboard(leaderboard, (ELeaderboardSortMethod)sort_method, (ELeaderboardDisplayType)display_type);
+                    settings_server->setLeaderboard(leaderboard, (ELeaderboardSortMethod)sort_method, (ELeaderboardDisplayType)display_type);
+                } else {
+                    PRINT_DEBUG("Error adding leaderboard for: %s, are sort method %u or display type %u valid?\n", leaderboard.c_str(), sort_method, display_type);
+                }
+            }
+        }
+    }
+
     {
         std::string mod_path = Local_Storage::get_game_settings_path() + "mods";
         std::vector<std::string> paths = Local_Storage::get_filenames_path(mod_path);
@@ -383,6 +424,11 @@ void Steam_Client::serverShutdown()
     server_init = false;
 }
 
+void Steam_Client::clientShutdown()
+{
+    user_logged_in = false;
+}
+
 void Steam_Client::setAppID(uint32 appid)
 {
     std::lock_guard<std::recursive_mutex> lock(global_mutex);

dll/steam_client.h

@@ -278,6 +278,7 @@ public:
     void userLogIn();
     void serverInit();
     void serverShutdown();
+    void clientShutdown();
     bool IsServerInit();
     bool IsUserLogIn();
 };

dll/steam_user_stats.h

@@ -109,6 +109,7 @@ bool GetStat( const char *pchName, float *pData )
 bool SetStat( const char *pchName, int32 nData )
 {
     PRINT_DEBUG("SetStat int32 %s\n", pchName);
+    if (!pchName) return false;
     std::lock_guard<std::recursive_mutex> lock(global_mutex);
 
     return local_storage->store_data(STATS_STORAGE_FOLDER, pchName, (char* )&nData, sizeof(nData)) == sizeof(nData);
@@ -117,6 +118,7 @@ bool SetStat( const char *pchName, int32 nData )
 bool SetStat( const char *pchName, float fData )
 {
     PRINT_DEBUG("SetStat float %s\n", pchName);
+    if (!pchName) return false;
     std::lock_guard<std::recursive_mutex> lock(global_mutex);
 
     return local_storage->store_data(STATS_STORAGE_FOLDER, pchName, (char* )&fData, sizeof(fData)) == sizeof(fData);
@@ -368,14 +370,19 @@ SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName )
 {
     PRINT_DEBUG("FindLeaderboard %s\n", pchLeaderboardName);
     std::lock_guard<std::recursive_mutex> lock(global_mutex);
-    //TODO: figure out a way to get real leaderboard info
-    /*
-    LeaderboardFindResult_t data;
-    data.m_hSteamLeaderboard = find_leaderboard(pchLeaderboardName);;
-    data.m_bLeaderboardFound = !!data.m_hSteamLeaderboard;
-    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
-    */
-    return FindOrCreateLeaderboard(pchLeaderboardName, k_ELeaderboardSortMethodDescending, k_ELeaderboardDisplayTypeNumeric);
+
+    auto settings_Leaderboards = settings->getLeaderboards();
+    if (settings_Leaderboards.count(pchLeaderboardName)) {
+        auto config = settings_Leaderboards[pchLeaderboardName];
+        return FindOrCreateLeaderboard(pchLeaderboardName, config.sort_method, config.display_type);
+    } else if (settings->createUnknownLeaderboards()) {
+        return FindOrCreateLeaderboard(pchLeaderboardName, k_ELeaderboardSortMethodDescending, k_ELeaderboardDisplayTypeNumeric);
+    } else {
+        LeaderboardFindResult_t data;
+        data.m_hSteamLeaderboard = find_leaderboard(pchLeaderboardName);;
+        data.m_bLeaderboardFound = !!data.m_hSteamLeaderboard;
+        return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+    }
 }
 
 
@@ -446,7 +453,7 @@ STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users -
 SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard,
                                                             STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers )
 {
-    PRINT_DEBUG("DownloadLeaderboardEntriesForUsers\n");
+    PRINT_DEBUG("DownloadLeaderboardEntriesForUsers %i %llu\n", cUsers, cUsers > 0 ? prgUsers[0].ConvertToUint64() : 0);
     std::lock_guard<std::recursive_mutex> lock(global_mutex);
     LeaderboardScoresDownloaded_t data;
     data.m_hSteamLeaderboard = hSteamLeaderboard;