Merge branch 'overlay_h' of https://gitlab.com/Nemirtingas/goldberg_emulator

# Conflicts:
#	build_steamos.sh
#	dll/dll.cpp

dll/base.h

@@ -18,7 +18,29 @@
 #ifndef BASE_INCLUDE
 #define BASE_INCLUDE
 
-#if defined(WIN32) || defined(_WIN32)
+#if defined(WIN64) || defined(_WIN64) || defined(__MINGW64__)
+    #define __WINDOWS_64__
+#elif defined(WIN32) || defined(_WIN32) || defined(__MINGW32__)
+	#define __WINDOWS_32__
+#endif
+
+#if defined(__WINDOWS_32__) || defined(__WINDOWS_64__)
+	#define __WINDOWS__
+#endif
+
+#if defined(__linux__) || defined(linux)
+    #if defined(__x86_64__)
+        #define __LINUX_64__
+    #else
+        #define __LINUX_32__
+    #endif
+#endif
+
+#if defined(__LINUX_32__) || defined(__LINUX_64__)
+    #define __LINUX__
+#endif
+
+#if defined(__WINDOWS__)
 #define STEAM_WIN32
 #pragma warning( disable : 4716)
 #ifndef NOMINMAX
@@ -210,7 +232,7 @@ public:
             if (it != cr.callbacks.end()) {
                 cr.callbacks.erase(it);
             }
-        
+
             if (cr.callbacks.size() == 0) {
                 cr.to_delete = true;
             }

dll/dll.cpp

@@ -223,6 +223,12 @@ STEAMAPI_API bool S_CALLTYPE SteamAPI_Init()
     load_old_interface_versions();
     user_steam_pipe = get_steam_client()->CreateSteamPipe();
     get_steam_client()->ConnectToGlobalUser(user_steam_pipe);
+
+    Steam_Client* client = get_steam_client();
+#ifndef NO_OVERLAY
+    if( client->enable_overlay )
+        client->steam_overlay->SetupOverlay();
+#endif
     return true;
 }
 

dll/net.proto

@@ -185,6 +185,17 @@ message Friend_Messages {
     }
 }
 
+message Steam_Messages {
+	enum Types {
+		FRIEND_CHAT = 0;
+	}
+
+	Types type = 1;
+	oneof message_data {
+		bytes message = 2;
+	}
+}
+
 message Common_Message {
     uint64 source_id = 1;
     uint64 dest_id = 2;
@@ -200,6 +211,7 @@ message Common_Message {
         Friend_Messages friend_messages = 11;
         Network_Old network_old = 12;
         Networking_Sockets networking_sockets = 13;
+		Steam_Messages steam_messages = 14;
     }
 
     uint32 source_ip = 128;

dll/network.cpp

@@ -574,6 +574,11 @@ void Networking::do_callbacks_message(Common_Message *msg)
         PRINT_DEBUG("has_networking_sockets\n");
         run_callbacks(CALLBACK_ID_NETWORKING_SOCKETS, msg);
     }
+
+    if (msg->has_steam_messages()) {
+        PRINT_DEBUG("has_steam_messages\n");
+        run_callbacks(CALLBACK_ID_STEAM_MESSAGES, msg);
+    }
 }
 
 bool Networking::handle_tcp(Common_Message *msg, struct TCP_Socket &socket)

dll/network.h

@@ -60,6 +60,7 @@ enum Callback_Ids {
     CALLBACK_ID_AUTH_TICKET,
     CALLBACK_ID_FRIEND_MESSAGES,
     CALLBACK_ID_NETWORKING_SOCKETS,
+    CALLBACK_ID_STEAM_MESSAGES,
 
     CALLBACK_IDS_MAX
 };

dll/steam_client.cpp

@@ -46,9 +46,13 @@ static void background_thread(Steam_Client *client)
 
 Steam_Client::Steam_Client()
 {
-
     uint32 appid = create_localstorage_settings(&settings_client, &settings_server, &local_storage);
 
+    {
+        std::ifstream chk_ovlay(Local_Storage::get_program_path() + PATH_SEPARATOR + "disable_overlay.txt", std::ios::in);
+        if (chk_ovlay)
+            enable_overlay = false;
+    }
     network = new Networking(settings_server->get_local_steam_id(), appid, settings_server->get_port(), &(settings_server->custom_broadcasts), settings_server->disable_networking);
 
     callback_results_client = new SteamCallResults();
@@ -59,9 +63,12 @@ Steam_Client::Steam_Client()
 
     PRINT_DEBUG("steam client init: id: %llu server id: %llu appid: %u port: %u \n", settings_client->get_local_steam_id().ConvertToUint64(), settings_server->get_local_steam_id().ConvertToUint64(), appid, settings_server->get_port());
 
+    steam_overlay = new Steam_Overlay(settings_client, callback_results_client, callbacks_client, run_every_runcb, network);
+
     steam_user = new Steam_User(settings_client, local_storage, network, callback_results_client, callbacks_client);
-    steam_friends = new Steam_Friends(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
-    steam_utils = new Steam_Utils(settings_client, callback_results_client);
+    steam_friends = new Steam_Friends(settings_client, network, callback_results_client, callbacks_client, run_every_runcb, steam_overlay);
+    steam_utils = new Steam_Utils(settings_client, callback_results_client, steam_overlay);
+
     steam_matchmaking = new Steam_Matchmaking(settings_client, network, callback_results_client, callbacks_client, run_every_runcb);
     steam_matchmaking_servers = new Steam_Matchmaking_Servers(settings_client, network);
     steam_user_stats = new Steam_User_Stats(settings_client, local_storage, callback_results_client, callbacks_client);
@@ -90,7 +97,7 @@ Steam_Client::Steam_Client()
 
     PRINT_DEBUG("client init gameserver\n");
     steam_gameserver = new Steam_GameServer(settings_server, network, callbacks_server);
-    steam_gameserver_utils = new Steam_Utils(settings_server, callback_results_server);
+    steam_gameserver_utils = new Steam_Utils(settings_server, callback_results_server, steam_overlay);
     steam_gameserverstats = new Steam_GameServerStats(settings_server, network, callback_results_server, callbacks_server);
     steam_gameserver_networking = new Steam_Networking(settings_server, network, callbacks_server, run_every_runcb);
     steam_gameserver_http = new Steam_HTTP(settings_server, network, callback_results_server, callbacks_server);

dll/steam_client.h

@@ -53,6 +53,8 @@
 #include "steam_gameserverstats.h"
 #include "steam_masterserver_updater.h"
 
+#include "../overlay_experimental/steam_overlay.h"
+
 #include <thread>
 
 enum Steam_Pipe {
@@ -127,6 +129,9 @@ public:
     Steam_Game_Coordinator *steam_gameserver_game_coordinator;
     Steam_Masterserver_Updater *steam_masterserver_updater;
 
+    Steam_Overlay* steam_overlay;
+
+    bool enable_overlay = true;
     bool user_logged_in = false;
     bool server_init = false;
     std::thread background_keepalive;

dll/steam_friends.h

@@ -15,7 +15,11 @@
    License along with the Goldberg Emulator; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#ifndef __INCLUDED_STEAM_FRIENDS_H__
+#define __INCLUDED_STEAM_FRIENDS_H__
+
 #include "base.h"
+#include "../overlay_experimental/steam_overlay.h"
 
 #define SEND_FRIEND_RATE 4.0
 
@@ -46,6 +50,7 @@ public ISteamFriends
     class SteamCallBacks *callbacks;
     class SteamCallResults *callback_results;
     class RunEveryRunCB *run_every_runcb;
+    class Steam_Overlay* overlay;
 
     Friend us;
     bool modified;
@@ -128,13 +133,14 @@ static void steam_friends_run_every_runcb(void *object)
     steam_friends->RunCallbacks();
 }
 
-Steam_Friends(class Settings *settings, class Networking *network, class SteamCallResults *callback_results, class SteamCallBacks *callbacks, class RunEveryRunCB *run_every_runcb)
+Steam_Friends(Settings* settings, Networking* network, SteamCallResults* callback_results, SteamCallBacks* callbacks, RunEveryRunCB* run_every_runcb, Steam_Overlay* overlay):
+    settings(settings),
+    network(network),
+    callbacks(callbacks),
+    callback_results(callback_results),
+    run_every_runcb(run_every_runcb),
+    overlay(overlay)
 {
-    this->settings = settings;
-    this->network = network;
-    this->callbacks = callbacks;
-    this->callback_results = callback_results;
-    this->run_every_runcb = run_every_runcb;
     this->network->setCallback(CALLBACK_ID_FRIEND, settings->get_local_steam_id(), &Steam_Friends::steam_friends_callback, this);
     this->network->setCallback(CALLBACK_ID_FRIEND_MESSAGES, settings->get_local_steam_id(), &Steam_Friends::steam_friends_callback, this);
     this->network->setCallback(CALLBACK_ID_USER_STATUS, settings->get_local_steam_id(), &Steam_Friends::steam_friends_callback, this);
@@ -518,6 +524,7 @@ void SetInGameVoiceSpeaking( CSteamID steamIDUser, bool bSpeaking )
 void ActivateGameOverlay( const char *pchDialog )
 {
     PRINT_DEBUG("Steam_Friends::ActivateGameOverlay %s\n", pchDialog);
+    overlay->OpenOverlay(pchDialog);
 }
 
 
@@ -574,7 +581,7 @@ void SetPlayedWith( CSteamID steamIDUserPlayedWith )
 void ActivateGameOverlayInviteDialog( CSteamID steamIDLobby )
 {
     PRINT_DEBUG("Steam_Friends::ActivateGameOverlayInviteDialog\n");
-    // TODO: Here open the overlay
+    overlay->OpenOverlayInvite(steamIDLobby);
 }
 
 // gets the small (32x32) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set
@@ -1014,6 +1021,7 @@ void Callback(Common_Message *msg)
             auto f = std::find_if(friends.begin(), friends.end(), [&id](Friend const& item) { return item.id() == id; });
             if (friends.end() != f) {
                 persona_change((uint64)f->id(), k_EPersonaChangeStatus);
+                overlay->FriendDisconnect(*f);
                 friends.erase(f);
             }
         }
@@ -1039,6 +1047,7 @@ void Callback(Common_Message *msg)
         if (!f) {
             if (msg->friend_().id() != settings->get_local_steam_id().ConvertToUint64()) {
                 friends.push_back(msg->friend_());
+                overlay->FriendConnect(msg->friend_());
                 persona_change((uint64)msg->friend_().id(), k_EPersonaChangeName);
             }
         } else {
@@ -1059,23 +1068,41 @@ void Callback(Common_Message *msg)
     if (msg->has_friend_messages()) {
         if (msg->friend_messages().type() == Friend_Messages::LOBBY_INVITE) {
             PRINT_DEBUG("Steam_Friends Got Lobby Invite\n");
-            //TODO: the user should accept the invite first but we auto accept it because there's no gui yet
-            GameLobbyJoinRequested_t data;
-            data.m_steamIDLobby = CSteamID((uint64)msg->friend_messages().lobby_id());
-            data.m_steamIDFriend = CSteamID((uint64)msg->source_id());
-            callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
+            if (overlay->Ready())
+            {
+                //TODO: the user should accept the invite first but we auto accept it because there's no gui yet
+                // Then we will handle it !
+                overlay->SetLobbyInvite(*find_friend(static_cast<uint64>(msg->source_id())), msg->friend_messages().lobby_id());
+            }
+            else
+            {
+                GameLobbyJoinRequested_t data;
+                data.m_steamIDLobby = CSteamID((uint64)msg->friend_messages().lobby_id());
+                data.m_steamIDFriend = CSteamID((uint64)msg->source_id());
+                callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
+            }
         }
 
         if (msg->friend_messages().type() == Friend_Messages::GAME_INVITE) {
             PRINT_DEBUG("Steam_Friends Got Game Invite\n");
             //TODO: I'm pretty sure that the user should accept the invite before this is posted but we do like above
-            std::string const& connect_str = msg->friend_messages().connect_str();
-            GameRichPresenceJoinRequested_t data = {};
-            data.m_steamIDFriend = CSteamID((uint64)msg->source_id());
-            strncpy(data.m_rgchConnect, connect_str.c_str(), k_cchMaxRichPresenceValueLength - 1);
-            callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
+            if (overlay->Ready())
+            {
+                // Then we will handle it !
+                overlay->SetRichInvite(*find_friend(static_cast<uint64>(msg->source_id())), msg->friend_messages().connect_str().c_str());
+            }
+            else
+            {
+                std::string const& connect_str = msg->friend_messages().connect_str();
+                GameRichPresenceJoinRequested_t data = {};
+                data.m_steamIDFriend = CSteamID((uint64)msg->source_id());
+                strncpy(data.m_rgchConnect, connect_str.c_str(), k_cchMaxRichPresenceValueLength - 1);
+                callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
+            }
         }
     }
 }
 
 };
+
+#endif//__INCLUDED_STEAM_FRIENDS_H__

dll/steam_matchmaking.h

@@ -1268,7 +1268,7 @@ void Callback(Common_Message *msg)
         if (msg->lobby().owner() != settings->get_local_steam_id().ConvertToUint64() && msg->lobby().appid() == settings->get_local_game_id().AppID()) {
             Lobby *lobby = get_lobby((uint64)msg->lobby().room_id());
             if (!lobby) {
-                unsigned int old_size = lobbies.size();
+                size_t old_size = lobbies.size();
                 lobbies.resize(old_size + 1);
                 lobbies[old_size].set_room_id(msg->lobby().room_id());
                 lobby = &(lobbies[old_size]);

dll/steam_user_stats.cpp

@@ -0,0 +1,829 @@
+/* Copyright (C) 2019 Mr Goldberg
+   This file is part of the Goldberg Emulator
+
+   The Goldberg Emulator is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   The Goldberg Emulator is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the Goldberg Emulator; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include "steam_user_stats.h"
+#include "dll.h"
+
+unsigned int Steam_User_Stats::find_leaderboard(std::string name)
+{
+    unsigned index = 1;
+    for (auto& leaderboard : leaderboards) {
+        if (leaderboard.name == name) return index;
+        ++index;
+    }
+
+    return 0;
+}
+
+void Steam_User_Stats::load_achievements_db()
+{
+    std::string file_path = Local_Storage::get_game_settings_path() + achievements_user_file;
+    local_storage->load_json(file_path, defined_achievements);
+}
+
+void Steam_User_Stats::load_achievements()
+{
+    local_storage->load_json_file("", achievements_user_file, user_achievements);
+}
+
+void Steam_User_Stats::save_achievements()
+{
+    local_storage->write_json_file("", achievements_user_file, user_achievements);
+}
+
+Steam_User_Stats::Steam_User_Stats(Settings *settings, Local_Storage *local_storage, class SteamCallResults *callback_results, class SteamCallBacks *callbacks):
+    settings(settings),
+    local_storage(local_storage),
+    callback_results(callback_results),
+    callbacks(callbacks),
+    defined_achievements(nlohmann::json::object()),
+    user_achievements(nlohmann::json::object())
+{
+    load_achievements_db(); // achievements db
+    load_achievements(); // achievements per user
+}
+
+nlohmann::json const& Steam_User_Stats::GetAchievementsDb() const
+{
+    return defined_achievements;
+}
+
+// Ask the server to send down this user's data and achievements for this game
+STEAM_CALL_BACK(UserStatsReceived_t)
+bool Steam_User_Stats::RequestCurrentStats()
+{
+    PRINT_DEBUG("Steam_User_Stats::RequestCurrentStats\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    UserStatsReceived_t data;
+    data.m_nGameID = settings->get_local_game_id().ToUint64();
+    data.m_eResult = k_EResultOK;
+    data.m_steamIDUser = settings->get_local_steam_id();
+    callbacks->addCBResult(data.k_iCallback, &data, sizeof(data), 0.1);
+    return true;
+}
+
+
+// Data accessors
+bool Steam_User_Stats::GetStat(const char* pchName, int32* pData)
+{
+    PRINT_DEBUG("GetStat int32 %s\n", pchName);
+    if (!pchName || !pData) return false;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    auto stats_config = settings->getStats();
+    auto stats_data = stats_config.find(pchName);
+    if (stats_data != stats_config.end()) {
+        if (stats_data->second.type != Stat_Type::STAT_TYPE_INT) return false;
+    }
+
+    int read_data = local_storage->get_data(Local_Storage::stats_storage_folder, pchName, (char*)pData, sizeof(*pData));
+    if (read_data == sizeof(int32))
+        return true;
+
+    if (stats_data != stats_config.end()) {
+        *pData = stats_data->second.default_value_int;
+        return true;
+    }
+
+    return false;
+}
+
+bool Steam_User_Stats::GetStat(const char* pchName, float* pData)
+{
+    PRINT_DEBUG("GetStat float %s\n", pchName);
+    if (!pchName || !pData) return false;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    auto stats_config = settings->getStats();
+    auto stats_data = stats_config.find(pchName);
+    if (stats_data != stats_config.end()) {
+        if (stats_data->second.type == Stat_Type::STAT_TYPE_INT) return false;
+    }
+
+    int read_data = local_storage->get_data(Local_Storage::stats_storage_folder, pchName, (char*)pData, sizeof(*pData));
+    if (read_data == sizeof(float))
+        return true;
+
+    if (stats_data != stats_config.end()) {
+        *pData = stats_data->second.default_value_float;
+        return true;
+    }
+
+    return false;
+}
+
+
+// Set / update data
+bool Steam_User_Stats::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(Local_Storage::stats_storage_folder, pchName, (char*)&nData, sizeof(nData)) == sizeof(nData);
+}
+
+bool Steam_User_Stats::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(Local_Storage::stats_storage_folder, pchName, (char*)&fData, sizeof(fData)) == sizeof(fData);
+}
+
+bool Steam_User_Stats::UpdateAvgRateStat(const char* pchName, float flCountThisSession, double dSessionLength)
+{
+    PRINT_DEBUG("UpdateAvgRateStat %s\n", pchName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    char data[sizeof(float) + sizeof(float) + sizeof(double)];
+    int read_data = local_storage->get_data(Local_Storage::stats_storage_folder, pchName, (char*)data, sizeof(*data));
+    float oldcount = 0;
+    double oldsessionlength = 0;
+    if (read_data == sizeof(data)) {
+        memcpy(&oldcount, data + sizeof(float), sizeof(oldcount));
+        memcpy(&oldsessionlength, data + sizeof(float) + sizeof(double), sizeof(oldsessionlength));
+    }
+
+    oldcount += flCountThisSession;
+    oldsessionlength += dSessionLength;
+
+    float average = oldcount / oldsessionlength;
+    memcpy(data, &average, sizeof(average));
+    memcpy(data + sizeof(float), &oldcount, sizeof(oldcount));
+    memcpy(data + sizeof(float) * 2, &oldsessionlength, sizeof(oldsessionlength));
+
+    return local_storage->store_data(Local_Storage::stats_storage_folder, pchName, data, sizeof(data)) == sizeof(data);
+}
+
+
+// Achievement flag accessors
+bool Steam_User_Stats::GetAchievement(const char* pchName, bool* pbAchieved)
+{
+    PRINT_DEBUG("GetAchievement %s\n", pchName);
+    if (pchName == nullptr) return false;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    try {
+        auto it = std::find_if(defined_achievements.begin(), defined_achievements.end(), [pchName](nlohmann::json& item) {
+            return item["name"].get<std::string>() == pchName;
+            });
+        auto ach = user_achievements.find(pchName);
+        if (it != defined_achievements.end() && ach != user_achievements.end()) {
+            if (pbAchieved != nullptr) *pbAchieved = (*ach)["earned"];
+            return true;
+        }
+    }
+    catch (...) {}
+
+    if (pbAchieved != nullptr)*pbAchieved = false;
+
+    return false;
+}
+
+bool Steam_User_Stats::SetAchievement(const char* pchName)
+{
+    PRINT_DEBUG("SetAchievement %s\n", pchName);
+    if (pchName == nullptr) return false;
+
+    try {
+        auto it = std::find_if(defined_achievements.begin(), defined_achievements.end(), [pchName](nlohmann::json& item) {
+            return item["name"].get<std::string>() == pchName;
+            });
+        if (it != defined_achievements.end()) {
+            if (user_achievements.find(pchName) == user_achievements.end() || user_achievements[pchName].value("earned", false) == false) {
+                user_achievements[pchName]["earned"] = true;
+                user_achievements[pchName]["earned_time"] = std::chrono::duration_cast<std::chrono::duration<uint32>>(std::chrono::system_clock::now().time_since_epoch()).count();
+#ifndef NO_OVERLAY
+                get_steam_client()->steam_overlay->AddAchievementNotification(it.value());
+#endif
+            }
+            return true;
+        }
+    }
+    catch (...) {}
+
+    return false;
+}
+
+bool Steam_User_Stats::ClearAchievement(const char* pchName)
+{
+    PRINT_DEBUG("ClearAchievement %s\n", pchName);
+    if (pchName == nullptr) return false;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    try {
+        auto it = std::find_if(defined_achievements.begin(), defined_achievements.end(), [pchName](nlohmann::json& item) {
+            return static_cast<std::string const&>(item["name"]) == pchName;
+            });
+        if (it != defined_achievements.end()) {
+            user_achievements[pchName]["earned"] = false;
+            user_achievements[pchName]["earned_time"] = static_cast<uint32>(0);
+            return true;
+        }
+    }
+    catch (...) {}
+
+    return false;
+}
+
+
+// Get the achievement status, and the time it was unlocked if unlocked.
+// If the return value is true, but the unlock time is zero, that means it was unlocked before Steam 
+// began tracking achievement unlock times (December 2009). Time is seconds since January 1, 1970.
+bool Steam_User_Stats::GetAchievementAndUnlockTime(const char* pchName, bool* pbAchieved, uint32* punUnlockTime)
+{
+    PRINT_DEBUG("GetAchievementAndUnlockTime\n");
+    if (pchName == nullptr) return false;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    try {
+        auto it = std::find_if(defined_achievements.begin(), defined_achievements.end(), [pchName](nlohmann::json& item) {
+            return static_cast<std::string const&>(item["name"]) == pchName;
+            });
+        auto ach = user_achievements.find(pchName);
+        if (it != defined_achievements.end() && ach != user_achievements.end()) {
+            if (pbAchieved != nullptr) *pbAchieved = (*ach)["earned"];
+            if (punUnlockTime != nullptr) *punUnlockTime = (*ach)["earned_time"];
+            return true;
+        }
+    }
+    catch (...) {}
+
+    if (pbAchieved != nullptr) *pbAchieved = false;
+    if (punUnlockTime != nullptr) *punUnlockTime = 0;
+    return true;
+}
+
+
+// Store the current data on the server, will get a callback when set
+// And one callback for every new achievement
+//
+// If the callback has a result of k_EResultInvalidParam, one or more stats 
+// uploaded has been rejected, either because they broke constraints
+// or were out of date. In this case the server sends back updated values.
+// The stats should be re-iterated to keep in sync.
+bool Steam_User_Stats::StoreStats()
+{
+    PRINT_DEBUG("StoreStats\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    save_achievements();
+
+    UserStatsStored_t data;
+    data.m_nGameID = settings->get_local_game_id().ToUint64();
+    data.m_eResult = k_EResultOK;
+    callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
+    return true;
+}
+
+
+// Achievement / GroupAchievement metadata
+
+// Gets the icon of the achievement, which is a handle to be used in ISteamUtils::GetImageRGBA(), or 0 if none set. 
+// A return value of 0 may indicate we are still fetching data, and you can wait for the UserAchievementIconFetched_t callback
+// which will notify you when the bits are ready. If the callback still returns zero, then there is no image set for the
+// specified achievement.
+int Steam_User_Stats::GetAchievementIcon(const char* pchName)
+{
+    PRINT_DEBUG("GetAchievementIcon\n");
+    if (pchName == nullptr) return 0;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    return 0;
+}
+
+
+// Get general attributes for an achievement. Accepts the following keys:
+// - "name" and "desc" for retrieving the localized achievement name and description (returned in UTF8)
+// - "hidden" for retrieving if an achievement is hidden (returns "0" when not hidden, "1" when hidden)
+const char* Steam_User_Stats::GetAchievementDisplayAttribute(const char* pchName, const char* pchKey)
+{
+    PRINT_DEBUG("GetAchievementDisplayAttribute %s %s\n", pchName, pchKey);
+    if (pchName == nullptr) return "";
+    if (pchKey == nullptr) return "";
+
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    if (strcmp (pchKey, "name") == 0) {
+        try {
+            auto it = std::find_if(defined_achievements.begin(), defined_achievements.end(), [pchName](nlohmann::json& item) {
+                return static_cast<std::string const&>(item["name"]) == pchName;
+                });
+            if (it != defined_achievements.end()) {
+                return it.value()["displayName"].get_ptr<std::string*>()->c_str();
+            }
+        }
+        catch (...) {}
+    }
+
+    if (strcmp(pchKey, "desc") == 0) {
+        try {
+            auto it = std::find_if(defined_achievements.begin(), defined_achievements.end(), [pchName](nlohmann::json& item) {
+                return static_cast<std::string const&>(item["name"]) == pchName;
+                });
+            if (it != defined_achievements.end()) {
+                return it.value()["description"].get_ptr<std::string*>()->c_str();
+            }
+        }
+        catch (...) {}
+    }
+
+    if (strcmp(pchKey, "hidden") == 0) {
+        try {
+            auto it = std::find_if(defined_achievements.begin(), defined_achievements.end(), [pchName](nlohmann::json& item) {
+                return static_cast<std::string const&>(item["name"]) == pchName;
+                });
+            if (it != defined_achievements.end()) {
+                return it.value()["hidden"].get_ptr<std::string*>()->c_str();
+            }
+        }
+        catch (...) {}
+    }
+
+    return "";
+}
+
+
+// Achievement progress - triggers an AchievementProgress callback, that is all.
+// Calling this w/ N out of N progress will NOT set the achievement, the game must still do that.
+bool Steam_User_Stats::IndicateAchievementProgress(const char* pchName, uint32 nCurProgress, uint32 nMaxProgress)
+{
+    PRINT_DEBUG("IndicateAchievementProgress\n");
+    if (pchName == nullptr) return false;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    try {
+        auto it = std::find_if(defined_achievements.begin(), defined_achievements.end(), [pchName](nlohmann::json& item) {
+            return static_cast<std::string const&>(item["name"]) == pchName;
+        });
+        auto ach = user_achievements.find(pchName);
+        if (it != defined_achievements.end()) {
+            bool achieved = false;
+            if (ach != user_achievements.end()) {
+                bool achieved = ach->value("earned", false);
+            }
+
+            UserAchievementStored_t data = {};
+            data.m_nGameID = settings->get_local_game_id().ToUint64();
+            data.m_bGroupAchievement = false;
+            strncpy(data.m_rgchAchievementName, pchName, k_cchStatNameMax);
+
+            if (achieved) {
+                data.m_nCurProgress = 0;
+                data.m_nMaxProgress = 0;
+            }
+            else {
+                user_achievements[pchName]["progress"] = nCurProgress;
+                user_achievements[pchName]["max_progress"] = nMaxProgress;
+                data.m_nCurProgress = nCurProgress;
+                data.m_nMaxProgress = nMaxProgress;
+            }
+
+            save_achievements();
+            callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+            return true;
+        }
+    }
+    catch (...) {}
+
+    return false;
+}
+
+
+// Used for iterating achievements. In general games should not need these functions because they should have a
+// list of existing achievements compiled into them
+uint32 Steam_User_Stats::GetNumAchievements()
+{
+    PRINT_DEBUG("GetNumAchievements\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    return defined_achievements.size();
+}
+
+// Get achievement name iAchievement in [0,GetNumAchievements)
+const char* Steam_User_Stats::GetAchievementName(uint32 iAchievement)
+{
+    PRINT_DEBUG("GetAchievementName\n");
+    try {
+        static std::string achievement_name;
+        achievement_name = defined_achievements[iAchievement]["name"].get<std::string>();
+        return achievement_name.c_str();
+    }
+    catch (...) {}
+    return "";
+}
+
+
+// Friends stats & achievements
+
+// downloads stats for the user
+// returns a UserStatsReceived_t received when completed
+// if the other user has no stats, UserStatsReceived_t.m_eResult will be set to k_EResultFail
+// these stats won't be auto-updated; you'll need to call RequestUserStats() again to refresh any data
+STEAM_CALL_RESULT(UserStatsReceived_t)
+SteamAPICall_t Steam_User_Stats::RequestUserStats(CSteamID steamIDUser)
+{
+    PRINT_DEBUG("Steam_User_Stats::RequestUserStats %llu\n", steamIDUser.ConvertToUint64());
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    // Enable this to allow hot reload achievements status
+    //if (steamIDUser == settings->get_local_steam_id()) {
+    //    load_achievements();
+    //}
+
+
+    UserStatsReceived_t data;
+    data.m_nGameID = settings->get_local_game_id().ToUint64();
+    data.m_eResult = k_EResultOK;
+    data.m_steamIDUser = steamIDUser;
+    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data), 0.1);
+}
+
+
+// requests stat information for a user, usable after a successful call to RequestUserStats()
+bool Steam_User_Stats::GetUserStat(CSteamID steamIDUser, const char* pchName, int32* pData)
+{
+    PRINT_DEBUG("GetUserStat %s %llu\n", pchName, steamIDUser.ConvertToUint64());
+    if (pchName == nullptr) return false;
+
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    if (steamIDUser == settings->get_local_steam_id()) {
+        GetStat(pchName, pData);
+    }
+    else {
+        *pData = 0;
+    }
+
+    return true;
+}
+
+bool Steam_User_Stats::GetUserStat(CSteamID steamIDUser, const char* pchName, float* pData)
+{
+    PRINT_DEBUG("GetUserStat %s %llu\n", pchName, steamIDUser.ConvertToUint64());
+    if (pchName == nullptr) return false;
+
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    if (steamIDUser == settings->get_local_steam_id()) {
+        GetStat(pchName, pData);
+    }
+    else {
+        *pData = 0;
+    }
+
+    return true;
+}
+
+bool Steam_User_Stats::GetUserAchievement(CSteamID steamIDUser, const char* pchName, bool* pbAchieved)
+{
+    PRINT_DEBUG("GetUserAchievement %s\n", pchName);
+    if (pchName == nullptr) return false;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    if (steamIDUser == settings->get_local_steam_id()) {
+        return GetAchievement(pchName, pbAchieved);
+    }
+
+    return false;
+}
+
+// See notes for GetAchievementAndUnlockTime above
+bool Steam_User_Stats::GetUserAchievementAndUnlockTime(CSteamID steamIDUser, const char* pchName, bool* pbAchieved, uint32* punUnlockTime)
+{
+    PRINT_DEBUG("GetUserAchievementAndUnlockTime %s\n", pchName);
+    if (pchName == nullptr) return false;
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    if (steamIDUser == settings->get_local_steam_id()) {
+        return GetAchievementAndUnlockTime(pchName, pbAchieved, punUnlockTime);
+    }
+    return false;
+}
+
+
+// Reset stats 
+bool Steam_User_Stats::ResetAllStats(bool bAchievementsToo)
+{
+    PRINT_DEBUG("ResetAllStats\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    //TODO
+    if (bAchievementsToo) {
+        std::for_each(user_achievements.begin(), user_achievements.end(), [](nlohmann::json& v) {
+            v["earned"] = false;
+            v["earned_time"] = 0;
+            });
+    }
+
+    return true;
+}
+
+
+// Leaderboard functions
+
+// asks the Steam back-end for a leaderboard by name, and will create it if it's not yet
+// This call is asynchronous, with the result returned in LeaderboardFindResult_t
+STEAM_CALL_RESULT(LeaderboardFindResult_t)
+SteamAPICall_t Steam_User_Stats::FindOrCreateLeaderboard(const char* pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType)
+{
+    PRINT_DEBUG("FindOrCreateLeaderboard %s\n", pchLeaderboardName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    unsigned int leader = find_leaderboard(pchLeaderboardName);
+    if (!leader) {
+        struct Steam_Leaderboard leaderboard;
+        leaderboard.name = std::string(pchLeaderboardName);
+        leaderboard.sort_method = eLeaderboardSortMethod;
+        leaderboard.display_type = eLeaderboardDisplayType;
+        leaderboards.push_back(leaderboard);
+        leader = leaderboards.size();
+    }
+
+    LeaderboardFindResult_t data;
+    data.m_hSteamLeaderboard = leader;
+    data.m_bLeaderboardFound = 1;
+    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+}
+
+
+// as above, but won't create the leaderboard if it's not found
+// This call is asynchronous, with the result returned in LeaderboardFindResult_t
+STEAM_CALL_RESULT(LeaderboardFindResult_t)
+SteamAPICall_t Steam_User_Stats::FindLeaderboard(const char* pchLeaderboardName)
+{
+    PRINT_DEBUG("FindLeaderboard %s\n", pchLeaderboardName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    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));
+    }
+}
+
+
+// returns the name of a leaderboard
+const char* Steam_User_Stats::GetLeaderboardName(SteamLeaderboard_t hSteamLeaderboard)
+{
+    PRINT_DEBUG("GetLeaderboardName\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
+    if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return "";
+    return leaderboards[hSteamLeaderboard - 1].name.c_str();
+}
+
+
+// returns the total number of entries in a leaderboard, as of the last request
+int Steam_User_Stats::GetLeaderboardEntryCount(SteamLeaderboard_t hSteamLeaderboard)
+{
+    PRINT_DEBUG("GetLeaderboardEntryCount\n");
+    return 0;
+}
+
+
+// returns the sort method of the leaderboard
+ELeaderboardSortMethod Steam_User_Stats::GetLeaderboardSortMethod(SteamLeaderboard_t hSteamLeaderboard)
+{
+    PRINT_DEBUG("GetLeaderboardSortMethod\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_ELeaderboardSortMethodNone;
+    return leaderboards[hSteamLeaderboard - 1].sort_method;
+}
+
+
+// returns the display type of the leaderboard
+ELeaderboardDisplayType Steam_User_Stats::GetLeaderboardDisplayType(SteamLeaderboard_t hSteamLeaderboard)
+{
+    PRINT_DEBUG("GetLeaderboardDisplayType\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_ELeaderboardDisplayTypeNone;
+    return leaderboards[hSteamLeaderboard - 1].display_type;
+}
+
+
+// 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 
+STEAM_CALL_RESULT(LeaderboardScoresDownloaded_t)
+SteamAPICall_t Steam_User_Stats::DownloadLeaderboardEntries(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd)
+{
+    PRINT_DEBUG("DownloadLeaderboardEntries %llu %i %i %i\n", hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    LeaderboardScoresDownloaded_t data;
+    data.m_hSteamLeaderboard = hSteamLeaderboard;
+    data.m_hSteamLeaderboardEntries = 123;
+    data.m_cEntryCount = 0;
+    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+}
+
+// as above, but downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers
+// if a user doesn't have a leaderboard entry, they won't be included in the result
+// a max of 100 users can be downloaded at a time, with only one outstanding call at a time
+STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers)
+STEAM_CALL_RESULT(LeaderboardScoresDownloaded_t)
+SteamAPICall_t Steam_User_Stats::DownloadLeaderboardEntriesForUsers(SteamLeaderboard_t hSteamLeaderboard,
+    STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID * prgUsers, int cUsers)
+{
+    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;
+    data.m_hSteamLeaderboardEntries = 123;
+    data.m_cEntryCount = 0;
+    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+}
+
+
+// Returns data about a single leaderboard entry
+// use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries
+// e.g.
+//		void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded )
+//		{
+//			for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ )
+//			{
+//				LeaderboardEntry_t leaderboardEntry;
+//				int32 details[3];		// we know this is how many we've stored previously
+//				GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 );
+//				assert( leaderboardEntry.m_cDetails == 3 );
+//				...
+//			}
+// once you've accessed all the entries, the data will be free'd, and the SteamLeaderboardEntries_t handle will become invalid
+bool Steam_User_Stats::GetDownloadedLeaderboardEntry(SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
+{
+    PRINT_DEBUG("GetDownloadedLeaderboardEntry\n");
+    return false;
+}
+
+
+// Uploads a user score to the Steam back-end.
+// This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t
+// Details are extra game-defined information regarding how the user got that score
+// pScoreDetails points to an array of int32's, cScoreDetailsCount is the number of int32's in the list
+STEAM_CALL_RESULT(LeaderboardScoreUploaded_t)
+SteamAPICall_t Steam_User_Stats::UploadLeaderboardScore(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 * pScoreDetails, int cScoreDetailsCount)
+{
+    PRINT_DEBUG("UploadLeaderboardScore\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    LeaderboardScoreUploaded_t data;
+    data.m_bSuccess = 1; //needs to be success or DOA6 freezes when uploading score.
+    //data.m_bSuccess = 0;
+    data.m_hSteamLeaderboard = hSteamLeaderboard;
+    data.m_nScore = nScore;
+    //data.m_bScoreChanged = 1;
+    data.m_bScoreChanged = 0;
+    //data.m_nGlobalRankNew = 1;
+    data.m_nGlobalRankNew = 0;
+    data.m_nGlobalRankPrevious = 0;
+    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+}
+
+SteamAPICall_t Steam_User_Stats::UploadLeaderboardScore(SteamLeaderboard_t hSteamLeaderboard, int32 nScore, int32 * pScoreDetails, int cScoreDetailsCount)
+{
+    PRINT_DEBUG("UploadLeaderboardScore old\n");
+    return UploadLeaderboardScore(hSteamLeaderboard, k_ELeaderboardUploadScoreMethodKeepBest, nScore, pScoreDetails, cScoreDetailsCount);
+}
+
+
+// Attaches a piece of user generated content the user's entry on a leaderboard.
+// hContent is a handle to a piece of user generated content that was shared using ISteamUserRemoteStorage::FileShare().
+// This call is asynchronous, with the result returned in LeaderboardUGCSet_t.
+STEAM_CALL_RESULT(LeaderboardUGCSet_t)
+SteamAPICall_t Steam_User_Stats::AttachLeaderboardUGC(SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC)
+{
+    PRINT_DEBUG("AttachLeaderboardUGC\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    LeaderboardUGCSet_t data = {};
+    if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) {
+        data.m_eResult = k_EResultFail;
+    }
+    else {
+        data.m_eResult = k_EResultOK;
+    }
+
+    data.m_hSteamLeaderboard = hSteamLeaderboard;
+    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+}
+
+
+// Retrieves the number of players currently playing your game (online + offline)
+// This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t
+STEAM_CALL_RESULT(NumberOfCurrentPlayers_t)
+SteamAPICall_t Steam_User_Stats::GetNumberOfCurrentPlayers()
+{
+    PRINT_DEBUG("GetNumberOfCurrentPlayers\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    NumberOfCurrentPlayers_t data;
+    data.m_bSuccess = 1;
+    data.m_cPlayers = 69;
+    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+}
+
+
+// Requests that Steam fetch data on the percentage of players who have received each achievement
+// for the game globally.
+// This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t.
+STEAM_CALL_RESULT(GlobalAchievementPercentagesReady_t)
+SteamAPICall_t Steam_User_Stats::RequestGlobalAchievementPercentages()
+{
+    PRINT_DEBUG("RequestGlobalAchievementPercentages\n");
+}
+
+
+// Get the info on the most achieved achievement for the game, returns an iterator index you can use to fetch
+// the next most achieved afterwards.  Will return -1 if there is no data on achievement 
+// percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback).
+int Steam_User_Stats::GetMostAchievedAchievementInfo(char* pchName, uint32 unNameBufLen, float* pflPercent, bool* pbAchieved)
+{
+    PRINT_DEBUG("GetMostAchievedAchievementInfo\n");
+}
+
+
+// Get the info on the next most achieved achievement for the game. Call this after GetMostAchievedAchievementInfo or another
+// GetNextMostAchievedAchievementInfo call passing the iterator from the previous call. Returns -1 after the last
+// achievement has been iterated.
+int Steam_User_Stats::GetNextMostAchievedAchievementInfo(int iIteratorPrevious, char* pchName, uint32 unNameBufLen, float* pflPercent, bool* pbAchieved)
+{
+    PRINT_DEBUG("GetNextMostAchievedAchievementInfo\n");
+}
+
+
+// Returns the percentage of users who have achieved the specified achievement.
+bool Steam_User_Stats::GetAchievementAchievedPercent(const char* pchName, float* pflPercent)
+{
+    PRINT_DEBUG("GetAchievementAchievedPercent\n");
+}
+
+
+// Requests global stats data, which is available for stats marked as "aggregated".
+// This call is asynchronous, with the results returned in GlobalStatsReceived_t.
+// nHistoryDays specifies how many days of day-by-day history to retrieve in addition
+// to the overall totals. The limit is 60.
+STEAM_CALL_RESULT(GlobalStatsReceived_t)
+SteamAPICall_t Steam_User_Stats::RequestGlobalStats(int nHistoryDays)
+{
+    PRINT_DEBUG("RequestGlobalStats %i\n", nHistoryDays);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    GlobalStatsReceived_t data;
+    data.m_nGameID = settings->get_local_game_id().ToUint64();
+    data.m_eResult = k_EResultOK;
+    return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
+}
+
+
+// Gets the lifetime totals for an aggregated stat
+bool Steam_User_Stats::GetGlobalStat(const char* pchStatName, int64 * pData)
+{
+    PRINT_DEBUG("GetGlobalStat %s\n", pchStatName);
+    return false;
+}
+
+bool Steam_User_Stats::GetGlobalStat(const char* pchStatName, double* pData)
+{
+    PRINT_DEBUG("GetGlobalStat %s\n", pchStatName);
+    return false;
+}
+
+
+// Gets history for an aggregated stat. pData will be filled with daily values, starting with today.
+// So when called, pData[0] will be today, pData[1] will be yesterday, and pData[2] will be two days ago, 
+// etc. cubData is the size in bytes of the pubData buffer. Returns the number of 
+// elements actually set.
+int32 Steam_User_Stats::GetGlobalStatHistory(const char* pchStatName, STEAM_ARRAY_COUNT(cubData) int64 * pData, uint32 cubData)
+{
+    PRINT_DEBUG("GetGlobalStatHistory int64 %s\n", pchStatName);
+    return 0;
+}
+
+int32 Steam_User_Stats::GetGlobalStatHistory(const char* pchStatName, STEAM_ARRAY_COUNT(cubData) double* pData, uint32 cubData)
+{
+    PRINT_DEBUG("GetGlobalStatHistory double %s\n", pchStatName);
+    return 0;
+}

dll/steam_utils.h

@@ -17,6 +17,7 @@
 
 #include "base.h"
 #include "local_storage.h"
+#include "../overlay_experimental/steam_overlay.h"
 
 static std::chrono::time_point<std::chrono::steady_clock> app_initialized_time = std::chrono::steady_clock::now();
 
@@ -34,13 +35,14 @@ public ISteamUtils
 private:
     Settings *settings;
     class SteamCallResults *callback_results;
+    Steam_Overlay* overlay;
 
 public:
-Steam_Utils(Settings *settings, class SteamCallResults *callback_results)
-{
-    this->settings = settings;
-    this->callback_results = callback_results;
-}
+Steam_Utils(Settings *settings, class SteamCallResults *callback_results, Steam_Overlay *overlay):
+    settings(settings),
+    callback_results(callback_results),
+    overlay(overlay)
+{}
 
 // return the number of seconds since the user 
 uint32 GetSecondsSinceAppActive()
@@ -144,6 +146,7 @@ uint32 GetAppID()
 void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition )
 {
     PRINT_DEBUG("SetOverlayNotificationPosition\n");
+    overlay->SetNotificationPosition(eNotificationPosition);
 }
 
 
@@ -218,8 +221,7 @@ void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction )
 bool IsOverlayEnabled()
 {
     PRINT_DEBUG("IsOverlayEnabled\n");
-    //TODO
-    return false;
+    return overlay->Ready();
 }
 
 
@@ -235,7 +237,7 @@ bool IsOverlayEnabled()
 bool BOverlayNeedsPresent()
 {
     PRINT_DEBUG("BOverlayNeedsPresent\n");
-    return false;
+    return overlay->NeedPresent();
 }
 
 
@@ -305,6 +307,7 @@ bool IsSteamRunningInVR()
 void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset )
 {
     PRINT_DEBUG("SetOverlayNotificationInset\n");
+    overlay->SetNotificationInset(nHorizontalInset, nVerticalInset);
 }