Windows components: picked automatically by each game's source (#554)

Each game's Windows components now come from the list its own source
trusts, and the ones that list names turn on by themselves. The user's own
on/off switches always win; each automatic row says why it is on.

- Steam games: the Steamworks Shared redistributables Steam installs with
  the game (appmanifest SharedDepots, else the client's appinfo.vdf).
  Steam keeps its install scripts marked as already run.
- GOG: the build manifest's dependencies. Epic: the manifest's
  prerequisite (Unreal's maps to VC++ and DirectX). Amazon: fuel.json
  PostInstall. Older GOG/Epic installs get their list fetched once with the
  saved sign-in; game files are never downloaded again.
- Custom games (the + button, Add all, migrated folders): one shared Steam
  match per game, also used for artwork. An appid from the game's files
  turns components on; a name-only match stays Recommended; no match falls
  back to the folder scan.
- Steam app info for apps the client never saw comes from an anonymous
  Steam PICS lookup (CM websocket, anonymous logon, product info), cached
  per appid; the user's Steam sign-in is never used.
- Missing components download in the background on one low-priority
  worker that pauses during sessions and waits on battery saver, heat or a
  metered network unless the user asked. A game Steam installs during a
  session is readied right away so it can be played without ending the
  session; the launch waits up to 10 s only for a component still on its
  way.
- Page: "On for this game" with reasons, a quiet "Checking what this game
  needs..." only for games never worked out, rows that ease in, pieces that
  need a download greyed out while offline. The intro names no other app.
- The folder scan skips Unity's *_Data/Managed (Mono, not .NET Framework).
This commit is contained in:
The412Banner authored and GitHub committed 2026-10-10 21:15:56 -04:00
1 parent d45933e559
commit a2e596a200
35 files changed
+3810 -146

No files matched your search

@@ -33,27 +33,40 @@ class AddedGameArtLookupTest {
}
@Test fun anAppidFromTheGamesFilesIsUsedWithoutASearch() {
val lookup = File(tmp.newFolder(), "steam-appid")
val id = AddedGameArt.steamAppId("Palworld", 1623730, lookup) { fail("searched"); null }
assertEquals("1623730", id)
assertEquals("1623730", lookup.readText())
// An earlier "none" from a search does not stand in its way.
lookup.writeText("none")
assertEquals("1623730", AddedGameArt.steamAppId("Palworld", 1623730, lookup) { fail("searched"); null })
val dir = tmp.newFolder("Palworld")
File(dir, "steam_appid.txt").writeText("1623730")
val exe = File(dir, "Palworld.exe").apply { writeText("x") }
val match = SteamMatch.resolve(app, dir.path, exe, "Palworld") { fail("searched"); null }
assertEquals(1623730, match.appId)
assertEquals(SteamMatch.Certainty.FILES, match.certainty)
// The same record for everyone who asks.
assertEquals(1623730, SteamMatch.get(app, dir.path)!!.appId)
}
@Test fun withoutAnAppidTheTitleIsSearchedOnceAWeek() {
val lookup = File(tmp.newFolder(), "steam-appid")
val dir = tmp.newFolder("Nothing Like It")
val exe = File(dir, "game.exe").apply { writeText("x") }
var searches = 0
assertNull(AddedGameArt.steamAppId("Nothing Like It", null, lookup) { searches++; null })
assertEquals("none", lookup.readText())
assertNull(AddedGameArt.steamAppId("Nothing Like It", null, lookup) { searches++; "1" })
assertEquals(null, SteamMatch.resolve(app, dir.path, exe, "Nothing Like It") { searches++; null }.appId)
assertEquals(null, SteamMatch.resolve(app, dir.path, exe, "Nothing Like It") { searches++; 1 }.appId)
assertEquals(1, searches)
lookup.setLastModified(System.currentTimeMillis() - 8L * 24 * 3600 * 1000)
assertEquals("42", AddedGameArt.steamAppId("Nothing Like It", null, lookup) { searches++; "42" })
val old = SteamMatch.get(app, dir.path)!!
SteamMatch.put(app, dir.path, SteamMatch.Match(null, SteamMatch.Certainty.NONE, "", old.checkedAt - 8L * 24 * 3600 * 1000))
val found = SteamMatch.resolve(app, dir.path, exe, "Nothing Like It") { searches++; 42 }
assertEquals(42, found.appId)
assertEquals(SteamMatch.Certainty.NAME, found.certainty)
assertEquals(2, searches)
}
@Test fun anEarlierBuildsArtLookupIsKeptAsANameMatch() {
val dir = tmp.newFolder("Hades")
val exe = File(dir, "Hades.exe").apply { writeText("x") }
val legacy = File(tmp.newFolder(), "steam-appid").apply { writeText("1145360") }
val match = SteamMatch.resolve(app, dir.path, exe, "Hades", legacy = legacy) { fail("searched"); null }
assertEquals(1145360, match.appId)
assertEquals(SteamMatch.Certainty.NAME, match.certainty)
}
@Test fun aStoreResultIsTakenOnlyWhenItsNameMatches() {
// The first result is no longer taken for being first.
assertNull(AddedGameArt.pickStoreResult("My Obscure Game", listOf("10" to "Totally Different", "11" to "Another One")))
@@ -0,0 +1,95 @@
package com.droiddeck.launcher.frontend
import java.io.ByteArrayOutputStream
import java.io.File
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.util.zip.GZIPOutputStream
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Assert.fail
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
import org.robolectric.annotation.Config
/** Steam's app info asked anonymously: the answer read, batched, kept, and asked only when needed. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [33])
class SteamPicsTest {
private val app get() = RuntimeEnvironment.getApplication()
/** Dragon's Dogma 2's app info as Steam's anonymous PICS answer carried it (recorded 2026-10-10). */
private val recorded: String get() = javaClass.classLoader!!.getResource("steam-pics/app_2054970.vdf")!!.readText()
@After fun tearDown() { SteamAppInfo.pics = { SteamPics.lookup(it) } }
@Test fun theRecordedAnswerGivesTheSharedRedistAndTheName() {
val info = SteamPics.infoFromKeyValues(recorded)!!
assertEquals("Dragon's Dogma 2", info.name)
assertEquals(listOf("228988"), info.sharedDepots)
// VC++ 2019 for the Windows components.
assertEquals(listOf("vcredist2019_dll" to "VC++ 2019"), WinCompSources.steamDepots(info.sharedDepots))
}
private fun message(emsg: Int, body: ByteArray): ByteArray =
ByteBuffer.allocate(8 + body.size).order(ByteOrder.LITTLE_ENDIAN).putInt(emsg or 0x80000000.toInt()).putInt(0).put(body).array()
@Test fun aProductInfoResponseInsideAGzippedMultiIsRead() {
val appEntry = SteamPics.Proto().varint(1, 2054970).varint(2, 123).bytes(5, recorded.toByteArray() + byteArrayOf(0)).bytes()
val response = SteamPics.Proto().bytes(1, appEntry).varint(2, 999).bytes()
val inner = message(8904, response)
val packed = ByteBuffer.allocate(4 + inner.size).order(ByteOrder.LITTLE_ENDIAN).putInt(inner.size).put(inner).array()
val gz = ByteArrayOutputStream().also { o -> GZIPOutputStream(o).use { it.write(packed) } }.toByteArray()
val multi = message(1, SteamPics.Proto().varint(1, packed.size.toLong()).bytes(2, gz).bytes())
val msgs = SteamPics.messages(multi)
assertEquals(listOf(8904), msgs.map { it.first })
val r = SteamPics.parseInfoResponse(msgs.single().third)
assertEquals(listOf("228988"), r.apps.getValue(2054970).sharedDepots)
assertEquals(listOf(999), r.unknown)
assertFalse(r.pending)
}
@Test fun requestsAreBatchedByTwentyFive() {
val ids = (1..60).toList() + listOf(5, 6)
val batches = SteamPics.batches(ids)
assertEquals(listOf(25, 25, 10), batches.map { it.size })
assertEquals((1..60).toList(), batches.flatten())
}
@Test fun answersAreKeptAndAMissIsAskedAgainOnlyAfterAWeek() {
val calls = ArrayList<List<Int>>()
SteamAppInfo.pics = { ids -> calls.add(ids); mapOf(2054970 to SteamPics.infoFromKeyValues(recorded), 7 to null) }
assertTrue(SteamAppInfo.lookup(app, listOf(2054970, 7)))
// One connection for both.
assertEquals(listOf(listOf(2054970, 7)), calls)
assertEquals(listOf("228988"), SteamAppInfo.info(app, 2054970)!!.sharedDepots)
assertNull(SteamAppInfo.info(app, 7))
// Kept: nothing asked again (the miss waits a week).
assertFalse(SteamAppInfo.lookup(app, listOf(2054970, 7)))
assertEquals(1, calls.size)
assertEquals("hit", SteamAppInfo.state(app, 2054970))
assertEquals("miss", SteamAppInfo.state(app, 7))
}
@Test fun noNetworkWhenTheClientsCacheHasTheApp() {
// An appinfo.vdf with the app in it (built as in WinCompSourcesTest).
val file = SteamAppInfo.appinfoFile(app)
WinCompSourcesTest.writeAppinfo(file, 1145360)
SteamAppInfo.pics = { fail("asked Steam"); null }
assertTrue(SteamAppInfo.needLookup(app, listOf(1145360)).isEmpty())
assertFalse(SteamAppInfo.lookup(app, listOf(1145360)))
assertEquals(listOf("228986", "228990"), SteamAppInfo.info(app, 1145360)!!.sharedDepots)
}
@Test fun anUnreachableSteamKeepsNothingAndTriesAgain() {
SteamAppInfo.pics = { null }
assertFalse(SteamAppInfo.lookup(app, listOf(42)))
assertEquals(listOf(42), SteamAppInfo.needLookup(app, listOf(42)))
}
}
@@ -0,0 +1,465 @@
package com.droiddeck.launcher.frontend
import com.droiddeck.launcher.runtime.LinuxRuntime
import com.droiddeck.launcher.session.WinComponents
import com.droiddeck.launcher.stores.Store
import com.droiddeck.launcher.stores.StoreGameSidecar
import java.io.ByteArrayOutputStream
import java.io.File
import java.nio.ByteBuffer
import java.nio.ByteOrder
import org.json.JSONObject
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Rule
import org.junit.Test
import org.junit.rules.TemporaryFolder
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
import org.robolectric.annotation.Config
/** Each source's list of Windows components, how it maps to the catalog, and what turns on by itself. */
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [33])
class WinCompSourcesTest {
private val app get() = RuntimeEnvironment.getApplication()
@get:Rule val tmp = TemporaryFolder()
private fun game(folder: File?, source: String, appId: Int = 0x8123_4567.toInt(), library: String = Library.ADDED, name: String = "Game") =
Library.SteamGame(appId, name, null, library, gameFiles = folder, source = source)
private fun sidecar(folder: File, store: Store, extra: Map<String, String>) =
StoreGameSidecar(store, "1", "Game", exe = "Game.exe", extra = extra).write(folder)
private fun auto(findings: List<WinCompSources.Finding>) = findings.filter { it.auto }.map { it.component to it.origin }
// ---- mapping tables ----
@Test fun gogDependencyIdsMapToComponents() {
assertEquals(listOf("vcredist2015"), WinCompSources.gog("MSVC2017_x64"))
assertEquals(listOf("vcredist2022"), WinCompSources.gog("MSVC2022"))
assertEquals(listOf("vcredist2013"), WinCompSources.gog("msvc2013"))
assertEquals(listOf("d3dx9"), WinCompSources.gog("DirectX"))
assertEquals(listOf("dotnet48"), WinCompSources.gog("DOTNET48"))
assertEquals(listOf("dotnet472"), WinCompSources.gog("DotNet471"))
assertEquals(listOf("physx"), WinCompSources.gog("PhysX"))
assertEquals(listOf("oalinst"), WinCompSources.gog("OpenAL"))
assertEquals(listOf("xna40"), WinCompSources.gog("XNA4"))
assertEquals(emptyList<String>(), WinCompSources.gog("ISI"))
}
@Test fun epicPrerequisitesMapToComponents() {
assertEquals(listOf("vcredist2022", "d3dx9"), WinCompSources.epic("Engine/Extras/Redist/en-us/UEPrereqSetup_x64.exe", ""))
assertEquals(listOf("vcredist2022", "d3dx9"), WinCompSources.epic("Engine/Extras/Redist/en-us/UE4PrereqSetup_x64.exe", "UE4 Prerequisites (x64)"))
assertEquals(listOf("vcredist2022", "d3dx9"), WinCompSources.epic("", "UE4 Prerequisites (x64)"))
assertEquals(listOf("vcredist2013"), WinCompSources.epic("Redist/vcredist/2013/vcredist_x64.exe", "Visual C++"))
assertEquals(emptyList<String>(), WinCompSources.epic("Installers/LauncherHelper.exe", "Launcher Helper"))
}
@Test fun steamworksSharedDepotsMapToComponents() {
assertEquals(listOf("vcredist2015_dll" to "VC++ 2015", "d3dx9" to "DirectX (June 2010)"), WinCompSources.steamDepots(listOf("228986", "228990", "999")))
}
// ---- per source ----
@Test fun steamTakesItsSharedDepotsAndTurnsThemOn() {
val steamapps = tmp.newFolder("steamapps")
val folder = File(steamapps, "common/Game").apply { mkdirs() }
File(steamapps, "appmanifest_570.acf").writeText(
"\"AppState\"\n{\n\t\"appid\"\t\t\"570\"\n\t\"SharedDepots\"\n\t{\n\t\t\"228986\"\t\t\"228980\"\n\t\t\"228990\"\t\t\"228980\"\n\t}\n}\n",
)
val findings = WinCompSources.forGame(app, game(folder, Library.SOURCE_STEAM, 570, library = "steam", name = "Dota"))
assertEquals(listOf("vcredist2015_dll" to WinCompSources.Origin.STEAM, "d3dx9" to WinCompSources.Origin.STEAM), auto(findings))
assertEquals(listOf("VC++ 2015", "Dota", "570"), findings.first().args)
}
@Test fun gogTakesTheBuildsDependencies() {
val folder = tmp.newFolder("GogGame")
sidecar(folder, Store.GOG, mapOf(WinCompSources.GOG_DEPENDENCIES to "MSVC2017_x64,DirectX,ISI"))
val findings = WinCompSources.forGame(app, game(folder, "gog"))
assertEquals(listOf("vcredist2015" to WinCompSources.Origin.GOG, "d3dx9" to WinCompSources.Origin.GOG), auto(findings))
// ISI is none of ours: a suggestion under its own name.
assertEquals(listOf("ISI"), findings.filter { it.component == null }.map { it.original })
}
@Test fun epicTakesTheManifestsPrerequisite() {
val folder = tmp.newFolder("EpicGame")
sidecar(folder, Store.EPIC, mapOf(WinCompSources.EPIC_PREREQ_PATH to "Engine/Extras/Redist/en-us/UEPrereqSetup_x64.exe", WinCompSources.EPIC_PREREQ_NAME to "UE Prerequisites"))
assertEquals(listOf("vcredist2022" to WinCompSources.Origin.EPIC, "d3dx9" to WinCompSources.Origin.EPIC), auto(WinCompSources.forGame(app, game(folder, "epic"))))
}
@Test fun amazonTakesFuelJsonsPostInstall() {
val folder = tmp.newFolder("AmazonGame")
sidecar(folder, Store.AMAZON, emptyMap())
File(folder, "fuel.json").writeText(JSONObject()
.put("Main", JSONObject().put("Command", "Game.exe"))
.put("PostInstall", org.json.JSONArray()
.put(JSONObject().put("Command", "_CommonRedist\\vcredist\\2015\\vc_redist.x64.exe").put("Args", org.json.JSONArray().put("/q")))
.put(JSONObject().put("Command", "_CommonRedist\\DirectX\\Jun2010\\DXSETUP.exe"))
.put(JSONObject().put("Command", "Tools\\Activate.exe")))
.toString())
val findings = WinCompSources.forGame(app, game(folder, "amazon"))
assertEquals(listOf("vcredist2015" to WinCompSources.Origin.AMAZON, "d3dx9" to WinCompSources.Origin.AMAZON), auto(findings))
assertEquals(listOf("Activate.exe"), findings.filter { it.component == null }.map { it.original })
}
// ---- Custom: certainty decides ----
private fun appinfo(file: File, appId: Int) = writeAppinfo(file, appId)
companion object {
/** A version 29 appinfo.vdf with one app, whose depots point at two Steamworks Shared ones. */
fun writeAppinfo(file: File, appId: Int) {
val strings = listOf("appinfo", "common", "name", "depots", "228986", "depotfromapp", "228990", "1001", "maxsize")
fun key(s: String) = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(strings.indexOf(s)).array()
val kv = ByteArrayOutputStream().apply {
fun map(k: String) { write(0x00); write(key(k)) }
fun str(k: String, v: String) { write(0x01); write(key(k)); write(v.toByteArray()); write(0) }
fun end() = write(0x08)
map("appinfo"); map("common"); str("name", "Some Game"); end()
map("depots"); map("228986"); str("depotfromapp", "228980"); end(); map("228990"); str("depotfromapp", "228980"); end()
map("1001"); str("maxsize", "1"); end(); end(); end(); end()
}.toByteArray()
val body = ByteArray(60) + kv
val table = ByteArrayOutputStream().apply {
write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(strings.size).array())
strings.forEach { write(it.toByteArray()); write(0) }
}.toByteArray()
val head = ByteBuffer.allocate(16).order(ByteOrder.LITTLE_ENDIAN).putInt(0x07564429).putInt(1)
val entries = ByteBuffer.allocate(8 + body.size + 4).order(ByteOrder.LITTLE_ENDIAN).putInt(appId).putInt(body.size).put(body).putInt(0).array()
head.putLong(16L + entries.size)
file.parentFile!!.mkdirs()
file.writeBytes(head.array() + entries + table)
}
}
@Test fun steamsAppInfoIsReadForAnAppWithoutAManifest() {
val file = File(tmp.newFolder(), "appinfo.vdf")
appinfo(file, 1145360)
val info = SteamAppInfo.read(file, 1145360)!!
assertEquals("Some Game", info.name)
assertEquals(listOf("228986", "228990"), info.sharedDepots)
assertEquals(null, SteamAppInfo.read(file, 1))
}
@Test fun customWithAnAppidInItsFilesIsCertainAndOnByItself() {
appinfo(SteamAppInfo.appinfoFile(app), 1145360)
val folder = tmp.newFolder("Hades")
File(folder, "steam_appid.txt").writeText("1145360")
val exe = File(folder, "Hades.exe").apply { writeText("x") }
assertEquals(SteamMatch.Certainty.FILES, SteamMatch.resolve(app, folder.path, exe, "Hades").certainty)
val findings = WinCompSources.forGame(app, game(folder, Library.ADDED, name = "Hades"))
assertEquals(listOf("vcredist2015_dll" to WinCompSources.Origin.STEAM, "d3dx9" to WinCompSources.Origin.STEAM), auto(findings))
}
@Test fun customMatchedByNameIsOnlyRecommended() {
appinfo(SteamAppInfo.appinfoFile(app), 1145360)
val folder = tmp.newFolder("Hades Named")
val exe = File(folder, "Hades.exe").apply { writeText("x") }
assertEquals(SteamMatch.Certainty.NAME, SteamMatch.resolve(app, folder.path, exe, "Hades") { 1145360 }.certainty)
val findings = WinCompSources.forGame(app, game(folder, Library.ADDED, name = "Hades"))
assertTrue(auto(findings).isEmpty())
assertEquals(listOf("vcredist2015_dll", "d3dx9"), findings.filter { it.origin == WinCompSources.Origin.STEAM_NAME }.map { it.component })
}
@Test fun customWithNoMatchHasTheFolderScanOnly() {
val folder = tmp.newFolder("Unknown")
File(folder, "_CommonRedist/vcredist/2013").mkdirs()
File(folder, "_CommonRedist/vcredist/2013/vcredist_x64.exe").writeText("x")
val findings = WinCompSources.forGame(app, game(folder, Library.ADDED))
assertTrue(auto(findings).isEmpty())
assertEquals(listOf("vcredist2013" to WinCompSources.Origin.FOLDER), findings.map { it.component to it.origin })
}
// ---- what turns on, and the user's switches ----
private fun ready(name: String) = WinComponents.Component(name, "", "", "ready", emptyList(),
listOf(WinComponents.Step("override_dll", JSONObject().put("dll", "x").put("type", "native"))))
@Test fun onlyAutoFindingsThatInstallHereTurnOn() {
val catalog = listOf(ready("vcredist2015_dll"), ready("vcredist2015"), ready("d3dx9"),
WinComponents.Component("physx", "", "", "broken", emptyList(), emptyList())).associateBy { it.name }
val findings = listOf(
WinCompSources.Finding("vcredist2015", "MSVC2017", WinCompSources.Origin.GOG, true),
WinCompSources.Finding("physx", "PhysX", WinCompSources.Origin.GOG, true),
WinCompSources.Finding("d3dx9", "d3dx9_43.dll", WinCompSources.Origin.FOLDER, false),
)
val picks = AutoComponents.autoPicks(findings, catalog)
// The detector's name installs as its DLL twin; physx cannot install; the folder scan only recommends.
assertEquals(listOf("vcredist2015_dll"), picks.keys.toList())
assertEquals("GOG", picks.getValue("vcredist2015_dll").kind)
}
@Test fun theUsersSwitchWinsOverAnAutoPickEitherWay() {
val key = "12345"
WinComponents.setAuto(app, key, mapOf("d3dx9" to WinComponents.AutoReason("GOG", listOf("DirectX")), "xact" to WinComponents.AutoReason("GOG", listOf("XACT"))))
assertEquals(listOf("d3dx9", "xact"), WinComponents.picks(app, key))
WinComponents.setUser(app, key, "d3dx9", false)
WinComponents.setUser(app, key, "oalinst_dll", true)
assertEquals(listOf("xact", "oalinst_dll"), WinComponents.picks(app, key))
// A new automatic list keeps the user's switches.
WinComponents.setAuto(app, key, mapOf("d3dx9" to WinComponents.AutoReason("GOG", listOf("DirectX"))))
assertEquals(listOf("oalinst_dll"), WinComponents.picks(app, key))
assertEquals(mapOf("d3dx9" to false, "oalinst_dll" to true), WinComponents.selection(app, key).user)
// What the launch reads stays version 1 with the effective list.
val text = File(app.filesDir, "wincomponents.json").readText()
assertEquals(1, JSONObject(text).getInt("version"))
assertEquals("oalinst_dll", JSONObject(text).getJSONObject("games").getJSONArray(key).getString(0))
}
@Test fun picksFromBeforeOverridesAreTheUsersOwn() {
File(app.filesDir, "wincomponents.json").writeText("""{"version":1,"games":{"777":["d3dx9","xact"]}}""")
assertEquals(mapOf("d3dx9" to true, "xact" to true), WinComponents.selection(app, "777").user)
assertEquals(listOf("d3dx9", "xact"), WinComponents.picks(app, "777"))
}
@Test fun artAndComponentsShareOneSteamMatch() {
val folder = tmp.newFolder("Shared")
val exe = File(folder, "Shared.exe").apply { writeText("x") }
val art = AddedGames.Game(folder, "Shared", exe, "/g/Shared.exe", "/g", 0x81234567L, 0L, emptyList())
// The art fetch finds it by name ...
val match = AddedGameArt.steamMatch(app, art) { 4242 }
assertEquals(4242, match.appId)
// ... and the components read the same record.
assertEquals(4242, SteamMatch.get(app, folder.path)!!.appId)
assertEquals(SteamMatch.Certainty.NAME, SteamMatch.get(app, folder.path)!!.certainty)
assertFalse(WinCompSources.forGame(app, game(folder, Library.ADDED)).any { it.auto })
}
private val catalog3 = listOf(ready("d3dx9"), ready("vcredist2013_dll"), ready("vcredist2019_dll"))
private val installedNow = mutableSetOf<String>()
private val downloaded = ArrayList<String>()
private var session = false
private var gameUp = false
private fun payback(): Library.SteamGame {
val steamapps = tmp.newFolder("steamapps")
val folder = File(steamapps, "common/Payback").apply { mkdirs() }
File(steamapps, "appmanifest_1262580.acf").writeText(
"\"AppState\"\n{\n\t\"SharedDepots\"\n\t{\n\t\t\"228985\"\t\t\"228980\"\n\t\t\"228988\"\t\t\"228980\"\n\t\t\"228990\"\t\t\"228980\"\n\t}\n}\n",
)
return game(folder, Library.SOURCE_STEAM, 1262580, library = "steam", name = "Need for Speed Payback")
}
private fun <T> withFakeWorker(block: () -> T): T {
AutoComponents.catalogOf = { _, _ -> catalog3 }
AutoComponents.installedOf = { installedNow.toSet() }
AutoComponents.installer = { _, c, _, _ -> downloaded.add(c.name); installedNow.add(c.name); null }
AutoComponents.sessionRunning = { session }
AutoComponents.unfavourable = { false }
AutoComponents.online = { true }
AutoComponents.gameRunning = { gameUp }
AutoComponents.runNow = true
try {
return block()
} finally {
AutoComponents.runNow = false
AutoComponents.catalogOf = { c, network -> if (network) WinComponents.fetch(c) else WinComponents.cached(c) }
AutoComponents.installedOf = { WinComponents.installedIds(it).toSet() }
AutoComponents.installer = { c, comp, all, progress -> WinComponents.install(c, comp, all, progress) }
AutoComponents.sessionRunning = { com.droiddeck.launcher.session.SessionState.running }
AutoComponents.online = { c -> AutoComponents.isOnline(c) }
AutoComponents.gameRunning = { false }
}
}
@Test fun aSteamListedComponentNotYetDownloadedTurnsOnWhenItLands() = withFakeWorker {
installedNow.add("d3dx9")
val game = payback()
// The user had switched one off: it is never downloaded for an automatic pick.
WinComponents.setUser(app, "1262580", "vcredist2019_dll", false)
AutoComponents.queueGame(app, game, asked = true)
assertEquals(listOf("vcredist2013_dll"), downloaded)
val sel = WinComponents.selection(app, "1262580")
assertEquals(setOf("d3dx9", "vcredist2013_dll", "vcredist2019_dll"), sel.auto.keys)
assertEquals(setOf("d3dx9", "vcredist2013_dll"), WinComponents.picks(app, "1262580").toSet())
assertEquals("STEAM", sel.auto.getValue("vcredist2013_dll").kind)
// The list is kept for the page.
assertEquals(3, AutoComponents.cachedFindings(app, "1262580")!!.count { it.auto })
}
@Test fun theQueueWaitsWhileASessionRunsAndResumesAfter() = withFakeWorker {
val game = payback()
session = true
AutoComponents.queueGame(app, game, asked = true)
assertTrue(downloaded.isEmpty())
assertEquals(listOf("g:1262580"), AutoComponents.queued())
session = false
AutoComponents.drain(app)
assertEquals(listOf("vcredist2013_dll", "vcredist2019_dll", "d3dx9"), downloaded)
assertTrue(AutoComponents.queued().isEmpty())
}
@Test fun aJobNobodyAskedForWaitsOnAnUnfavourableDevice() = withFakeWorker {
val game = payback()
AutoComponents.unfavourable = { true }
AutoComponents.queueGame(app, game, asked = false)
assertTrue(downloaded.isEmpty())
// The user opens the page: asked for, it goes.
AutoComponents.queueGame(app, game, asked = true)
assertEquals(3, downloaded.size)
}
@Test fun aGameAndAComponentAreQueuedOnceEach() = withFakeWorker {
val first = payback()
val other = game(first.gameFiles, Library.SOURCE_STEAM, 1262580, library = "steam", name = "Same app again")
session = true
AutoComponents.queueGame(app, first, asked = false)
AutoComponents.queueGame(app, other, asked = false)
assertEquals(listOf("g:1262580"), AutoComponents.queued())
session = false
AutoComponents.drain(app)
// Each component once, though two games could want it.
assertEquals(downloaded.distinct(), downloaded)
}
@Test fun aDownloadWaitsForANetwork() = withFakeWorker {
val game = payback()
AutoComponents.online = { false }
AutoComponents.queueGame(app, game, asked = true)
// The list is worked out offline; the downloads wait.
assertTrue(downloaded.isEmpty())
assertTrue(AutoComponents.queued().all { it.startsWith("c:") })
AutoComponents.online = { true }
AutoComponents.drain(app)
assertEquals(3, downloaded.size)
}
// ---- older store installs: the list read once from the store ----
@Test fun anOlderGogInstallGetsItsListFromTheStoreOnce() {
val folder = tmp.newFolder("DOOM I Enhanced")
StoreGameSidecar(Store.GOG, "2015545325", "DOOM", exe = "DOOM.exe", installVersion = "123").write(folder)
var fetches = 0
StoreListBackfill.fetcher = StoreListBackfill.Fetcher { _, sc -> fetches++; assertEquals("123", sc.installVersion); mapOf(WinCompSources.GOG_DEPENDENCIES to "MSVC2019_x64,DirectX") }
AutoComponents.online = { true }
try {
assertTrue(StoreListBackfill.fill(app, folder))
assertEquals("MSVC2019_x64,DirectX", StoreGameSidecar.read(folder)!!.extra[WinCompSources.GOG_DEPENDENCIES])
// Kept like a fresh install: not fetched again.
assertFalse(StoreListBackfill.fill(app, folder))
assertEquals(1, fetches)
assertEquals(listOf("vcredist2019" to WinCompSources.Origin.GOG, "d3dx9" to WinCompSources.Origin.GOG), auto(WinCompSources.forGame(app, game(folder, "gog"))))
} finally {
StoreListBackfill.fetcher = StoreListBackfill.storeFetcher
AutoComponents.online = { c -> AutoComponents.isOnline(c) }
}
}
@Test fun anOlderEpicInstallGetsItsPrerequisite() {
val folder = tmp.newFolder("DOOMBLADE")
StoreGameSidecar(Store.EPIC, "abc", "DOOMBLADE", exe = "DOOMBLADE.exe", extra = mapOf("namespace" to "ns", "catalogItemId" to "cat")).write(folder)
StoreListBackfill.fetcher = StoreListBackfill.Fetcher { _, _ ->
mapOf(WinCompSources.EPIC_PREREQ_NAME to "UE4 Prerequisites (x64)", WinCompSources.EPIC_PREREQ_PATH to "Engine/Extras/Redist/en-us/UE4PrereqSetup_x64.exe")
}
AutoComponents.online = { true }
try {
assertTrue(StoreListBackfill.fill(app, folder))
assertEquals("ns", StoreGameSidecar.read(folder)!!.extra["namespace"])
assertEquals(listOf("vcredist2022" to WinCompSources.Origin.EPIC, "d3dx9" to WinCompSources.Origin.EPIC), auto(WinCompSources.forGame(app, game(folder, "epic"))))
} finally {
StoreListBackfill.fetcher = StoreListBackfill.storeFetcher
AutoComponents.online = { c -> AutoComponents.isOnline(c) }
}
}
@Test fun aFailedFetchWaitsAWeekAndOfflineIsNoTry() {
val folder = tmp.newFolder("Metalstorm")
StoreGameSidecar(Store.EPIC, "m", "Metalstorm", exe = "M.exe").write(folder)
var fetches = 0
StoreListBackfill.fetcher = StoreListBackfill.Fetcher { _, _ -> fetches++; null }
try {
AutoComponents.online = { false }
assertFalse(StoreListBackfill.fill(app, folder))
assertEquals(0, fetches)
AutoComponents.online = { true }
assertFalse(StoreListBackfill.fill(app, folder))
assertFalse(StoreListBackfill.fill(app, folder))
// Signed out or the store refused: once, then a week's rest; the sidecar is untouched.
assertEquals(1, fetches)
assertTrue(StoreListBackfill.needs(StoreGameSidecar.read(folder)!!))
} finally {
StoreListBackfill.fetcher = StoreListBackfill.storeFetcher
AutoComponents.online = { c -> AutoComponents.isOnline(c) }
}
}
// ---- apps the client never saw ----
@Test fun anAppTheClientLearnsLaterIsReadOnceItsCacheIsWritten() {
val file = SteamAppInfo.appinfoFile(app)
appinfo(file, 1)
file.setLastModified(1_000_000_000_000L)
assertEquals(null, SteamAppInfo.info(app, 1145360))
// Unchanged file: the miss stands (no re-read).
assertEquals(null, SteamAppInfo.info(app, 1145360))
// The client wrote its cache with the app in it: read at once, not a week later.
appinfo(file, 1145360)
file.setLastModified(1_000_000_100_000L)
assertEquals(listOf("228986", "228990"), SteamAppInfo.info(app, 1145360)!!.sharedDepots)
}
@Test fun unitysManagedFolderIsNotADotNetRequirement() {
val folder = tmp.newFolder("DOOMBLADE")
File(folder, "DOOMBLADE_Data/Managed").mkdirs()
File(folder, "DOOMBLADE_Data/Managed/com.rlabrecque.steamworks.net.dll").writeText("x")
File(folder, "DOOMBLADE_Data/Managed/System.Net.Http.dll").writeText("x")
assertTrue(DependencyDetector.detect(folder).isEmpty())
}
@Test fun aListReadWholeIsNotFetchedAgainButAnUnmarkedEmptyOneIs() {
val read = tmp.newFolder("Read")
StoreGameSidecar(Store.EPIC, "a", "A", exe = "A.exe", extra = mapOf(WinCompSources.EPIC_PREREQ_NAME to "", WinCompSources.EPIC_PREREQ_PATH to "", WinCompSources.LIST_READ to "1")).write(read)
val older = tmp.newFolder("Older")
StoreGameSidecar(Store.EPIC, "b", "B", exe = "B.exe", extra = mapOf(WinCompSources.EPIC_PREREQ_NAME to "", WinCompSources.EPIC_PREREQ_PATH to "")).write(older)
assertFalse(StoreListBackfill.needs(StoreGameSidecar.read(read)!!))
assertTrue(StoreListBackfill.needs(StoreGameSidecar.read(older)!!))
}
// ---- a game installed during the session ----
private fun manifest(dir: File, appId: Int, state: Int, time: Long) =
File(dir, "appmanifest_$appId.acf").apply {
writeText("\"AppState\"\n{\n\t\"appid\"\t\t\"$appId\"\n\t\"name\"\t\t\"Audiosurf\"\n\t\"installdir\"\t\t\"Audiosurf\"\n\t\"StateFlags\"\t\t\"$state\"\n}\n")
setLastModified(time)
}
@Test fun aManifestTurningInstalledIsNoticedOnce() {
val steamapps = tmp.newFolder("steamapps")
manifest(steamapps, 12900, 1026, 1_000_000L)
manifest(steamapps, 570, 4, 1_000_000L)
val watch = SessionInstalls.Watch { listOf(steamapps) }
// What was there when the session started is not new.
assertTrue(watch.poll().isEmpty())
assertTrue(watch.poll().isEmpty())
manifest(steamapps, 12900, 4, 2_000_000L)
manifest(steamapps, 440, 4, 2_000_000L)
val done = watch.poll()
assertEquals(setOf(12900, 440), done.map { it.appId }.toSet())
assertEquals(File(steamapps, "common/Audiosurf"), SessionInstalls.gameOf(done.first { it.appId == 12900 }).gameFiles)
assertTrue(watch.poll().isEmpty())
}
@Test fun anInSessionJobWaitsWhileAGameRunsThenReadiesItsComponents() = withFakeWorker {
val installed = payback()
session = true
gameUp = true
AutoComponents.queueInSession(app, installed)
assertTrue(downloaded.isEmpty())
// Other work stays paused in the session.
val other = game(tmp.newFolder("Other"), Library.ADDED)
AutoComponents.queueGame(app, other, asked = false)
gameUp = false
AutoComponents.drain(app)
assertEquals(3, downloaded.size)
assertEquals(setOf("d3dx9", "vcredist2013_dll", "vcredist2019_dll"), WinComponents.picks(app, "1262580").toSet())
// Nothing left pending for the launch to wait on; the other game still waits for the session's end.
assertEquals(0, AutoComponents.Pending.read(app).length())
assertEquals(listOf("g:${AutoComponents.appKey(other)}"), AutoComponents.queued())
session = false
AutoComponents.drain(app)
assertTrue(AutoComponents.queued().isEmpty())
}
}
@@ -0,0 +1,882 @@
"appinfo"
{
"appid" "2054970"
"common"
{
"name" "Dragon's Dogma 2"
"type" "Game"
"releasestate" "released"
"oslist" "windows"
"osarch" "64"
"osextended" ""
"icon" "f3d469e0d7a0e25ddd13db8ebf08f1c24d6478b0"
"clienticon" "a8eaa474f143bfdab634907e034ea6fa47086ccb"
"clienttga" "0c02d7c5b9790c444597578019b02937234b90d2"
"languages"
{
"english" "1"
"german" "1"
"french" "1"
"italian" "1"
"koreana" "1"
"spanish" "1"
"schinese" "1"
"tchinese" "1"
"russian" "1"
"japanese" "1"
"portuguese" "1"
"polish" "1"
"arabic" "1"
"brazilian" "1"
"latam" "1"
}
"eulas"
{
"0"
{
"id" "2054970_eula_0"
"name" "Dragon's Dogma 2 EULA"
"url" "https://store.steampowered.com//eula/2054970_eula_0"
"version" "3"
}
}
"content_descriptors"
{
"0" "1"
"1" "5"
}
"steam_deck_compatibility"
{
"category" "1"
"steamos_compatibility" "2"
"steam_machine_compatibility" "3"
"test_timestamp" "1784764800"
"tested_build_id" "2054970"
"tests"
{
"0"
{
"display" "2"
"token" "#SteamDeckVerified_TestResult_UnsupportedGraphicsPerformance"
}
}
"steam_machine_tests"
{
"0"
{
"display" "4"
"token" "#SteamMachine_TestResult_DefaultControllerConfigFullyFunctional"
}
"1"
{
"display" "4"
"token" "#SteamMachine_TestResult_ControllerGlyphsMatchDevice"
}
"2"
{
"display" "4"
"token" "#SteamMachine_TestResult_DefaultConfigurationIsPerformant"
}
}
"steamos_tests"
{
"0"
{
"display" "3"
"token" "#SteamOS_TestResult_GameStartupFunctional"
}
"1"
{
"display" "1"
"token" "#SteamOS_TestResult_ExternalControllersNotSupportedPrimaryPlayer"
}
}
"configuration"
{
"supported_input" "other"
"requires_manual_keyboard_invoke" "0"
"requires_non_controller_launcher_nav" "0"
"primary_player_is_controller_slot_0" "1"
"non_deck_display_glyphs" "0"
"small_text" "1"
"requires_internet_for_setup" "0"
"requires_internet_for_singleplayer" "0"
"recommended_runtime" "proton-11.0-beta"
"requires_h264" "0"
"requires_voice_files" "0"
"gamescope_frame_limiter_not_supported" "0"
"hdr_support" "0"
"requires_proton_soundfonts" "0"
}
}
"metacritic_name" "Dragon's Dogma 2"
"controllertagwizard" "1"
"controller_support" "partial"
"small_capsule"
{
"english" "capsule_231x87.jpg"
}
"header_image"
{
"english" "header.jpg"
}
"library_assets"
{
"library_capsule" "en"
"library_hero" "en"
"library_logo" "en"
"library_header" "en"
"logo_position"
{
"pinned_position" "BottomLeft"
"width_pct" "23.186781828785556"
"height_pct" "41.66700658287976"
}
}
"library_assets_full"
{
"library_capsule"
{
"image"
{
"english" "library_600x900.jpg"
}
"image2x"
{
"english" "library_600x900_2x.jpg"
}
}
"library_hero"
{
"image"
{
"english" "library_hero.jpg"
}
"image2x"
{
"english" "library_hero_2x.jpg"
}
}
"library_logo"
{
"logo_position"
{
"pinned_position" "BottomLeft"
"width_pct" "23.186781828785556"
"height_pct" "41.66700658287976"
}
"image"
{
"english" "logo.png"
}
"image2x"
{
"english" "logo_2x.png"
}
}
"library_header"
{
"image"
{
"english" "library_header.jpg"
}
}
}
"store_asset_mtime" "1753923539"
"associations"
{
"0"
{
"type" "developer"
"name" "CAPCOM Co., Ltd."
}
"1"
{
"type" "publisher"
"name" "CAPCOM Co., Ltd."
}
"2"
{
"type" "franchise"
"name" "Dragon's Dogma"
}
}
"primary_genre" "3"
"genres"
{
"0" "1"
"1" "3"
}
"category"
{
"category_2" "1"
"category_18" "1"
"category_55" "1"
"category_57" "1"
"category_60" "1"
"category_22" "1"
"category_29" "1"
"category_23" "1"
"category_61" "1"
"category_45" "1"
"category_46" "1"
"category_62" "1"
}
"supported_languages"
{
"english"
{
"supported" "true"
"full_audio" "true"
"subtitles" "true"
}
"french"
{
"supported" "true"
"subtitles" "true"
}
"italian"
{
"supported" "true"
"subtitles" "true"
}
"german"
{
"supported" "true"
"subtitles" "true"
}
"spanish"
{
"supported" "true"
"subtitles" "true"
}
"arabic"
{
"supported" "true"
"subtitles" "true"
}
"latam"
{
"supported" "true"
"subtitles" "true"
}
"brazilian"
{
"supported" "true"
"subtitles" "true"
}
"russian"
{
"supported" "true"
"subtitles" "true"
}
"schinese"
{
"supported" "true"
"subtitles" "true"
}
"tchinese"
{
"supported" "true"
"subtitles" "true"
}
"japanese"
{
"supported" "true"
"full_audio" "true"
"subtitles" "true"
}
"koreana"
{
"supported" "true"
"subtitles" "true"
}
"polish"
{
"supported" "true"
"subtitles" "true"
}
}
"steam_release_date" "1711065600"
"metacritic_score" "88"
"metacritic_fullurl" "https://www.metacritic.com/game/pc/dragons-dogma-2?ftag=MCD-06-10aaa1f"
"community_visible_stats" "1"
"community_hub_visible" "1"
"gameid" "2054970"
"content_descriptors_including_dlc"
{
"0" "1"
"1" "5"
}
"store_tags"
{
"0" "1695"
"1" "122"
"2" "4231"
"3" "1684"
"4" "4182"
"5" "19"
"6" "21"
"7" "4747"
"8" "4046"
"9" "4057"
"10" "4106"
"11" "4172"
"12" "4608"
"13" "1697"
"14" "3968"
"15" "3854"
"16" "3859"
"17" "7926"
"18" "4191"
"19" "6730"
}
"review_score" "5"
"review_percentage" "63"
}
"extended"
{
"additional_dependencies"
{
"0"
{
"src_os" "windows"
"dest_os" "linux"
"h264" "1"
}
}
"developer" "CAPCOM Co., Ltd."
"publisher" "CAPCOM Co., Ltd."
"homepage" "https://www.dragonsdogma.com/2da/"
"aliases" "ドグマ,ドグマ2,DD2,龙信2,ドラゴンズドグマ,龙之信条"
"listofdlc" "2581000,2593170,2593180,2593190,2593200,2593210,2593220,2593230,2593240,2593250,2593260,2593270,2593280,2593290,2694820,2694830,2694840,2694850,2757060,2757080,2757090,2757120,2757130,2757140,2757170"
"dlcavailableonstore" "1"
}
"config"
{
"installdir" "Dragons Dogma 2"
"launch"
{
"0"
{
"executable" "DD2.exe"
}
}
"steamcontrollertemplateindex" "2"
"steamdecktouchscreen" "1"
"steamconfigurator3rdpartynative" "65534"
}
"depots"
{
"baselanguages" "english,german,french,italian,koreana,spanish,schinese,tchinese,russian,japanese,polish,arabic,brazilian,latam"
"228988"
{
"config"
{
"oslist" "windows"
}
"depotfromapp" "228980"
"sharedinstall" "1"
}
"2054971"
{
"manifests"
{
"public"
{
"gid" "3438547366935427234"
"size" "154689650"
"download" "49702016"
}
}
}
"2054972"
{
"manifests"
{
"public"
{
"gid" "2497482018950166086"
"size" "154689650"
"download" "49702016"
}
}
}
"2054973"
{
"manifests"
{
"public"
{
"gid" "5096395230065303989"
"size" "69392135623"
"download" "68155907184"
}
}
}
"2054974"
{
"manifests"
{
"public"
{
"gid" "4433477873043462508"
"size" "69392135912"
"download" "68163333808"
}
}
}
"2581000"
{
"dlcappid" "2581000"
"manifests"
{
"public"
{
"gid" "6150746279967323915"
"size" "732"
"download" "784"
}
}
}
"2593170"
{
"dlcappid" "2593170"
"manifests"
{
"public"
{
"gid" "810106481153607467"
"size" "731"
"download" "784"
}
}
}
"2593180"
{
"dlcappid" "2593180"
"manifests"
{
"public"
{
"gid" "2908546599585986601"
"size" "14463"
"download" "14528"
}
}
}
"2593190"
{
"dlcappid" "2593190"
"manifests"
{
"public"
{
"gid" "1427647465435055606"
"size" "197908084"
"download" "180975120"
}
}
}
"2593200"
{
"dlcappid" "2593200"
"manifests"
{
"public"
{
"gid" "6641524981969165665"
"size" "5583"
"download" "5472"
}
}
}
"2593210"
{
"dlcappid" "2593210"
"manifests"
{
"public"
{
"gid" "971487897150453015"
"size" "8506"
"download" "8416"
}
}
}
"2593220"
{
"dlcappid" "2593220"
"manifests"
{
"public"
{
"gid" "7751533332300224932"
"size" "6072"
"download" "5984"
}
}
}
"2593230"
{
"dlcappid" "2593230"
"manifests"
{
"public"
{
"gid" "3205009877271857381"
"size" "4433"
"download" "4320"
}
}
}
"2593240"
{
"dlcappid" "2593240"
"manifests"
{
"public"
{
"gid" "2644417301132228564"
"size" "5471"
"download" "5360"
}
}
}
"2593250"
{
"dlcappid" "2593250"
"manifests"
{
"public"
{
"gid" "4059800356804376977"
"size" "727"
"download" "784"
}
}
}
"2593260"
{
"dlcappid" "2593260"
"manifests"
{
"public"
{
"gid" "1542297718911676562"
"size" "5004"
"download" "4944"
}
}
}
"2593270"
{
"dlcappid" "2593270"
"manifests"
{
"public"
{
"gid" "2999068646104164918"
"size" "5098"
"download" "5024"
}
}
}
"2593280"
{
"dlcappid" "2593280"
"manifests"
{
"public"
{
"gid" "3305444330840079072"
"size" "693"
"download" "752"
}
}
}
"2593290"
{
"dlcappid" "2593290"
"manifests"
{
"public"
{
"gid" "3353726914325255074"
"size" "26906257761"
"download" "26506078656"
}
}
}
"2694820"
{
"dlcappid" "2694820"
"manifests"
{
"public"
{
"gid" "8323545382908063536"
"size" "4994"
"download" "4928"
}
}
}
"2694830"
{
"dlcappid" "2694830"
"manifests"
{
"public"
{
"gid" "8243393096252728659"
"size" "4980"
"download" "4912"
}
}
}
"2694840"
{
"dlcappid" "2694840"
"manifests"
{
"public"
{
"gid" "7407203756785514772"
"size" "4980"
"download" "4912"
}
}
}
"2694850"
{
"dlcappid" "2694850"
"manifests"
{
"public"
{
"gid" "8989014742962253789"
"size" "4992"
"download" "4928"
}
}
}
"2757060"
{
"dlcappid" "2757060"
"manifests"
{
"public"
{
"gid" "4478133242487678390"
"size" "727"
"download" "784"
}
}
}
"2757080"
{
"dlcappid" "2757080"
"manifests"
{
"public"
{
"gid" "4246061750770449019"
"size" "729"
"download" "784"
}
}
}
"2757090"
{
"dlcappid" "2757090"
"manifests"
{
"public"
{
"gid" "6279084752133001593"
"size" "726"
"download" "784"
}
}
}
"2757100"
{
"dlcappid" "2757100"
"manifests"
{
"public"
{
"gid" "2163371650537928331"
"size" "728"
"download" "784"
}
}
}
"2757110"
{
"dlcappid" "2757110"
"manifests"
{
"public"
{
"gid" "6048538284791812257"
"size" "728"
"download" "784"
}
}
}
"2757120"
{
"dlcappid" "2757120"
"manifests"
{
"public"
{
"gid" "4411956497046953058"
"size" "730"
"download" "784"
}
}
}
"2757130"
{
"dlcappid" "2757130"
"manifests"
{
"public"
{
"gid" "1901727257188878695"
"size" "726"
"download" "784"
}
}
}
"2757140"
{
"dlcappid" "2757140"
"manifests"
{
"public"
{
"gid" "3192862444394827561"
"size" "730"
"download" "784"
}
}
}
"2757150"
{
"dlcappid" "2757150"
"manifests"
{
"public"
{
"gid" "6674463851485663659"
"size" "730"
"download" "784"
}
}
}
"2757160"
{
"dlcappid" "2757160"
"manifests"
{
"public"
{
"gid" "9188163296361277604"
"size" "729"
"download" "784"
}
}
}
"2757170"
{
"dlcappid" "2757170"
"manifests"
{
"public"
{
"gid" "3408012598466658697"
"size" "727"
"download" "784"
}
}
}
"2757180"
{
"dlcappid" "2757180"
"manifests"
{
"public"
{
"gid" "7470516453980211807"
"size" "731"
"download" "784"
}
}
}
"2757190"
{
"dlcappid" "2757190"
"manifests"
{
"public"
{
"gid" "488116235793758299"
"size" "726"
"download" "784"
}
}
}
"2757200"
{
"dlcappid" "2757200"
"manifests"
{
"public"
{
"gid" "3018062872582304551"
"size" "729"
"download" "784"
}
}
}
"2757210"
{
"dlcappid" "2757210"
"manifests"
{
"public"
{
"gid" "6248888390153964942"
"size" "726"
"download" "784"
}
}
}
"5184170"
{
"dlcappid" "5184170"
"manifests"
{
}
}
"branches"
{
"public"
{
"buildid" "25290080"
"timeupdated" "1791503987"
"timebuildupdated" "1789345188"
}
}
"privatebranches" "1"
}
"ufs"
{
"quota" "2000000000"
"maxnumfiles" "1000"
}
}