Cheevos

app/build.gradle.kts

@@ -210,8 +210,8 @@ dependencies {
     // JavaSteam
     val localBuild = false // Change to 'true' needed when building JavaSteam manually
     if (localBuild) {
-        implementation(files("../../JavaSteam/build/libs/javasteam-1.8.0-11-SNAPSHOT.jar"))
-        implementation(files("../../JavaSteam/javasteam-depotdownloader/build/libs/javasteam-depotdownloader-1.8.0-11-SNAPSHOT.jar"))
+        implementation(files("../../JavaSteam/build/libs/javasteam-1.8.0-12-SNAPSHOT.jar"))
+        implementation(files("../../JavaSteam/javasteam-depotdownloader/build/libs/javasteam-depotdownloader-1.8.0-12-SNAPSHOT.jar"))
         implementation(libs.bundles.javasteam.dev)
     } else {
         implementation(libs.javasteam) {

app/src/main/java/app/gamenative/PrefManager.kt

@@ -304,6 +304,13 @@ object PrefManager {
             setPref(STEAM_OFFLINE_MODE, value)
         }
 
+    private val SHOW_ACHIEVEMENT_POPUPS = booleanPreferencesKey("show_achievement_popups")
+    var showAchievementPopups: Boolean
+        get() = getPref(SHOW_ACHIEVEMENT_POPUPS, false)
+        set(value) {
+            setPref(SHOW_ACHIEVEMENT_POPUPS, value)
+        }
+
     private val USE_LEGACY_DRM = booleanPreferencesKey("use_legacy_drm")
     var useLegacyDRM: Boolean
         get() = getPref(USE_LEGACY_DRM, false)

app/src/main/java/app/gamenative/service/SteamService.kt

@@ -95,6 +95,7 @@ import `in`.dragonbra.javasteam.steam.handlers.steamuser.SteamUser
 import `in`.dragonbra.javasteam.steam.handlers.steamuser.callback.LoggedOffCallback
 import `in`.dragonbra.javasteam.steam.handlers.steamuser.callback.LoggedOnCallback
 import `in`.dragonbra.javasteam.steam.handlers.steamuser.callback.PlayingSessionStateCallback
+import `in`.dragonbra.javasteam.steam.handlers.steamuserstats.Stats
 import `in`.dragonbra.javasteam.steam.handlers.steamuserstats.SteamUserStats
 import `in`.dragonbra.javasteam.steam.handlers.steamworkshop.SteamWorkshop
 import `in`.dragonbra.javasteam.steam.steamclient.AsyncJobFailedException
@@ -157,8 +158,11 @@ import java.util.concurrent.CopyOnWriteArrayList
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.FormBody
+import org.json.JSONArray
 import org.json.JSONObject
 import com.winlator.container.ContainerManager
+import app.gamenative.statsgen.Achievement
+import app.gamenative.statsgen.StatsAchievementsGenerator
 
 @AndroidEntryPoint
 class SteamService : Service(), IChallengeUrlChanged {
@@ -214,6 +218,7 @@ class SteamService : Service(), IChallengeUrlChanged {
     private var _steamApps: SteamApps? = null
     private var _steamFriends: SteamFriends? = null
     private var _steamCloud: SteamCloud? = null
+    private var _steamUserStats: SteamUserStats? = null
     private var _steamFamilyGroups: FamilyGroups? = null
 
     private var _loginResult: LoginResult = LoginResult.Failed
@@ -2115,7 +2120,7 @@ class SteamService : Service(), IChallengeUrlChanged {
             }
         }
 
-        suspend fun closeApp(appId: Int, isOffline: Boolean, prefixToPath: (String) -> String) = withContext(Dispatchers.IO) {
+        suspend fun closeApp(context: Context, appId: Int, isOffline: Boolean, prefixToPath: (String) -> String) = withContext(Dispatchers.IO) {
             async {
                 if (isOffline || !isConnected) {
                     return@async
@@ -2127,6 +2132,12 @@ class SteamService : Service(), IChallengeUrlChanged {
                 }
 
                 try {
+                    try {
+                        syncAchievementsFromGoldberg(context, appId)
+                    } catch (e: Exception) {
+                        Timber.e(e, "Achievement sync failed for appId=$appId, continuing with cloud save sync")
+                    }
+
                     val maxAttempts = 3
                     for (attempt in 1..maxAttempts) {
                         try {
@@ -2600,6 +2611,164 @@ class SteamService : Service(), IChallengeUrlChanged {
                 return emptySet()
             }
         }
+
+        suspend fun generateAchievements(appId: Int, configDirectory: String) {
+            val steamUser = instance!!._steamUser!!
+            val userStats = instance?._steamUserStats!!.getUserStats(appId, steamUser.steamID!!).await()
+            val schemaArray = userStats.schema.toByteArray()
+            val generator = StatsAchievementsGenerator()
+            val result = generator.generateStatsAchievements(schemaArray, configDirectory)
+
+            val nameToBlockBit = result.nameToBlockBit
+            Timber.d("nameToBlockBit size=${nameToBlockBit.size} for appId=$appId")
+            if (nameToBlockBit.isNotEmpty()) {
+                val configDir = File(configDirectory)
+                if (!configDir.exists()) configDir.mkdirs()
+                val mappingJson = JSONObject()
+                nameToBlockBit.forEach { (name, pair) ->
+                    mappingJson.put(name, JSONArray(listOf(pair.first, pair.second)))
+                }
+                File(configDir, "achievement_name_to_block.json").writeText(mappingJson.toString(), Charsets.UTF_8)
+            }
+        }
+
+        suspend fun syncAchievementsFromGoldberg(context: Context, appId: Int) {
+            val imageFs = ImageFs.find(context)
+            val gseSavesDir = File(
+                imageFs.rootDir,
+                "${ImageFs.WINEPREFIX}/drive_c/users/xuser/AppData/Roaming/GSE Saves/$appId"
+            )
+            var goldbergAchFile = File(gseSavesDir, "achievements.json")
+            if (!goldbergAchFile.exists()) {
+                Timber.d("No Goldberg achievements.json at ${goldbergAchFile.absolutePath}, checking userdata path")
+                val accountId = userSteamId?.accountID?.toInt()
+                if (accountId != null) {
+                    val userdataDir = File(
+                        imageFs.rootDir,
+                        "${ImageFs.WINEPREFIX}/drive_c/Program Files (x86)/Steam/userdata/$accountId/$appId"
+                    )
+                    goldbergAchFile = File(userdataDir, "achievements.json")
+                }
+                if (!goldbergAchFile.exists()) {
+                    Timber.d("No Goldberg achievements.json found for appId=$appId")
+                    return
+                }
+            }
+
+            val unlockedNames = mutableSetOf<String>()
+            try {
+                val json = JSONObject(goldbergAchFile.readText(Charsets.UTF_8))
+                for (name in json.keys()) {
+                    val entry = json.optJSONObject(name) ?: continue
+                    if (entry.optBoolean("earned", false)) {
+                        unlockedNames.add(name)
+                    }
+                }
+            } catch (e: Exception) {
+                Timber.e(e, "Failed to parse Goldberg achievements.json for appId=$appId")
+                return
+            }
+
+            if (unlockedNames.isEmpty()) {
+                Timber.d("No earned achievements found in Goldberg output for appId=$appId")
+                return
+            }
+
+            val configDirectory = findSteamSettingsDir(context, appId)
+            if (configDirectory == null) {
+                Timber.w("Could not find steam_settings directory for appId=$appId")
+                return
+            }
+
+            Timber.i("Found ${unlockedNames.size} earned achievements for appId=$appId, syncing to Steam")
+//            val result = storeAchievementUnlocks(appId, configDirectory, unlockedNames)
+//            result.onSuccess {
+//                Timber.i("Successfully synced achievements to Steam for appId=$appId")
+//            }.onFailure { e ->
+//                Timber.e(e, "Failed to sync achievements to Steam for appId=$appId")
+//            }
+        }
+
+        private fun findSteamSettingsDir(context: Context, appId: Int): String? {
+            val appDirPath = getAppDirPath(appId)
+            val appDirSettings = File(appDirPath, "steam_settings")
+            if (File(appDirSettings, "achievement_name_to_block.json").exists()) {
+                return appDirSettings.absolutePath
+            }
+
+            val container = ContainerUtils.getContainer(context, "STEAM_$appId")
+            val coldclientSettings = File(
+                container.rootDir,
+                ".wine/drive_c/Program Files (x86)/Steam/steam_settings"
+            )
+            if (File(coldclientSettings, "achievement_name_to_block.json").exists()) {
+                return coldclientSettings.absolutePath
+            }
+
+            return null
+        }
+
+        suspend fun storeAchievementUnlocks(
+            appId: Int,
+            configDirectory: String,
+            unlockedNames: Set<String>
+        ): Result<Unit> = runCatching {
+            val mappingFile = File(configDirectory, "achievement_name_to_block.json")
+            if (!mappingFile.exists()) {
+                throw IllegalStateException("achievement_name_to_block.json not found in $configDirectory")
+            }
+            val mappingJson = JSONObject(mappingFile.readText(Charsets.UTF_8))
+            val nameToBlockBit = mutableMapOf<String, Pair<Int, Int>>()
+            for (key in mappingJson.keys()) {
+                val arr = mappingJson.optJSONArray(key) ?: continue
+                if (arr.length() >= 2) {
+                    nameToBlockBit[key] = Pair(arr.getInt(0), arr.getInt(1))
+                }
+            }
+            if (nameToBlockBit.isEmpty()) return@runCatching
+
+            val steamUser = instance!!._steamUser!!
+            val userStats = instance?._steamUserStats!!.getUserStats(appId, steamUser.steamID!!).await()
+            if (userStats.result != EResult.OK) {
+                throw IllegalStateException("getUserStats failed: ${userStats.result}")
+            }
+            val rawBlocks = userStats.achievementBlocks ?: emptyList()
+            val blockBitmasks = mutableMapOf<Int, Int>()
+            for (block in rawBlocks) {
+                val blockId = (block.achievementId as? Number)?.toInt() ?: continue
+                var bitmask = 0
+                val unlockTimes = block.unlockTime ?: emptyList()
+                for (i in unlockTimes.indices) {
+                    val t = unlockTimes[i]
+                    if ((t as? Number)?.toLong() != 0L) bitmask = bitmask or (1 shl i)
+                }
+                blockBitmasks[blockId] = bitmask
+            }
+            for (name in unlockedNames) {
+                val (blockId, bitIndex) = nameToBlockBit[name] ?: continue
+                val current = blockBitmasks.getOrDefault(blockId, 0)
+                blockBitmasks[blockId] = current or (1 shl bitIndex)
+            }
+            val statsToStore = blockBitmasks.map { (id, mask) -> Stats(statId = id, statValue = mask) }
+            Timber.d("storeUserStats: appId=$appId, crcStats=${userStats.crcStats}, stats=$statsToStore")
+            val mySteamId = steamUser.steamID!!
+//            val callback = instance?._steamUserStats!!.storeUserStats(
+//                appId, statsToStore, mySteamId, mySteamId, userStats.crcStats
+//            ).await()
+//            if (callback.result != EResult.OK) {
+//                throw IllegalStateException("storeUserStats failed: ${callback.result}")
+//            }
+//            if (callback.statsOutOfDate) {
+//                Timber.w("Stats were out of date on server for appId=$appId")
+//            }
+//            if (callback.statsFailedValidation.isNotEmpty()) {
+//                Timber.w("${callback.statsFailedValidation.size} stats failed validation for appId=$appId")
+//                callback.statsFailedValidation.forEach { f ->
+//                    Timber.w("  statId=${f.statId} reverted to ${f.revertedStatValue}")
+//                }
+//            }
+        }
+
     }
 
     override fun onCreate() {
@@ -2704,7 +2873,6 @@ class SteamService : Service(), IChallengeUrlChanged {
                 removeHandler(SteamMasterServer::class.java)
                 removeHandler(SteamWorkshop::class.java)
                 removeHandler(SteamScreenshots::class.java)
-                removeHandler(SteamUserStats::class.java)
             }
 
             // create the callback manager which will route callbacks to function calls
@@ -2715,6 +2883,7 @@ class SteamService : Service(), IChallengeUrlChanged {
             _steamApps = steamClient!!.getHandler(SteamApps::class.java)
             _steamFriends = steamClient!!.getHandler(SteamFriends::class.java)
             _steamCloud = steamClient!!.getHandler(SteamCloud::class.java)
+            _steamUserStats = steamClient!!.getHandler(SteamUserStats::class.java)
 
             _unifiedFriends = SteamUnifiedFriends(this)
             _steamFamilyGroups = steamClient!!.getHandler<SteamUnifiedMessages>()!!.createService<FamilyGroups>()

app/src/main/java/app/gamenative/statsgen/Models.kt

@@ -0,0 +1,44 @@
+package app.gamenative.statsgen
+
+data class Achievement(
+    val name: String,
+    val displayName: Map<String, String>? = null,
+    val description: Map<String, String>? = null,
+    val hidden: Int = 0,
+    val icon: String? = null,
+    val iconGray: String? = null,
+    val icongray: String? = null,
+    val progress: Map<String, Any>? = null,
+    val unlocked: Boolean? = null,
+    val unlockTimestamp: Int? = null,
+    val formattedUnlockTime: String? = null
+)
+
+data class Stat(
+    val id: String,
+    val name: String,
+    val type: String,
+    val default: String = "0",
+    val global: String = "0",
+    val min: String? = null
+)
+
+data class ProcessingResult(
+    val achievements: List<Achievement>,
+    val stats: List<Stat>,
+    val copyDefaultUnlockedImg: Boolean,
+    val copyDefaultLockedImg: Boolean,
+    val nameToBlockBit: Map<String, Pair<Int, Int>> = emptyMap(),
+)
+
+object StatType {
+    const val STAT_TYPE_INT = "1"
+    const val STAT_TYPE_FLOAT = "2"
+    const val STAT_TYPE_AVGRATE = "3"
+    const val STAT_TYPE_BITS = "4"
+
+    const val ACHIEVEMENTS = "ACHIEVEMENTS"
+    const val INT = "INT"
+    const val FLOAT = "FLOAT"
+    const val AVGRATE = "AVGRATE"
+}