`;
// Apply styles via GM_addStyle
GM_addStyle(`
#${CONFIG.SELECTORS.ui.container.substring(1)} {
position: fixed; bottom: 10px; right: 10px; z-index: 9999;
background: rgba(27, 40, 56, 0.9); color: #c7d5e0; padding: 10px;
border-radius: 5px; font-family: 'Motiva Sans', sans-serif; font-size: 12px;
border: 1px solid #000; box-shadow: 0 0 10px rgba(0,0,0,0.7);
backdrop-filter: blur(5px); -webkit-backdrop-filter: blur(5px);
transition: all 0.3s ease-in-out; width: 250px;
}
#${CONFIG.SELECTORS.ui.container.substring(1)}.wl-minimized {
padding: 5px 10px; height: auto; width: auto; min-width: 150px;
}
#${CONFIG.SELECTORS.ui.container.substring(
1
)}.wl-minimized .wl-controls-body {
display: none;
}
#${CONFIG.SELECTORS.ui.container.substring(1)} button {
padding: 4px 8px; border-radius: 2px; cursor: pointer; font-size: 11px;
margin-right: 5px; border: 1px solid; transition: filter 0.15s ease;
}
#${CONFIG.SELECTORS.ui.container.substring(
1
)} button:last-child { margin-right: 0; }
#${CONFIG.SELECTORS.ui.container.substring(1)} button:disabled {
background-color: #555 !important; color: #999 !important; cursor: not-allowed !important;
border-color: #333 !important; opacity: 0.7; filter: none !important;
}
#${CONFIG.SELECTORS.ui.container.substring(
1
)} button:hover:not(:disabled) { filter: brightness(1.15); }
#${CONFIG.SELECTORS.ui.startButton.substring(
1
)} { background-color: #68932f; color: white; border-color: #3a511b; }
#${CONFIG.SELECTORS.ui.pauseButton.substring(
1
)} { background-color: #4a6b9d; color: white; border-color: #2a3d5e; }
#${CONFIG.SELECTORS.ui.stopButton.substring(
1
)} { background-color: #a33e29; color: white; border-color: #5c2416; }
#${CONFIG.SELECTORS.ui.processOnceButton.substring(1)},
#${CONFIG.SELECTORS.ui.skipButton.substring(
1
)} { background-color: #777; color: white; border-color: #444; }
.${CONFIG.SELECTORS.ui.statusElement.substring(
1
)} { /* Target by class for easier style application */
font-size: 11px; min-height: 1.2em; padding: 4px 0; text-align: left;
transition: color 0.3s ease, font-weight 0.3s ease; color: #c7d5e0;
}
.${CONFIG.SELECTORS.ui.statusElement.substring(
1
)}.wl-status-action { color: #66c0f4 !important; }
.${CONFIG.SELECTORS.ui.statusElement.substring(
1
)}.wl-status-success { color: #a1dd4a !important; }
.${CONFIG.SELECTORS.ui.statusElement.substring(
1
)}.wl-status-skipped { color: #aaa !important; }
.${CONFIG.SELECTORS.ui.statusElement.substring(
1
)}.wl-status-error { color: #ff7a7a !important; font-weight: bold; }
.${CONFIG.SELECTORS.ui.statusElement.substring(
1
)}.wl-status-paused { color: #e4d00a !important; font-style: italic; }
#${CONFIG.SELECTORS.ui.container.substring(1)} label {
display: inline-flex; align-items: center; cursor: pointer;
font-size: 11px; vertical-align: middle; margin-bottom: 3px;
}
#${CONFIG.SELECTORS.ui.container.substring(
1
)} input[type="checkbox"] {
margin-right: 4px; vertical-align: middle; cursor: pointer; accent-color: #66c0f4;
}
#${CONFIG.SELECTORS.ui.versionInfo.substring(1)}.wl-update-available {
color: #ffa500 !important; text-decoration: underline; cursor: pointer; font-weight: bold;
}
`);
// Add to document
document.body.appendChild(controlDiv);
// Store references to UI elements
State.ui.elements = {
container: controlDiv,
startBtn: controlDiv.querySelector(CONFIG.SELECTORS.ui.startButton),
pauseBtn: controlDiv.querySelector(CONFIG.SELECTORS.ui.pauseButton),
stopBtn: controlDiv.querySelector(CONFIG.SELECTORS.ui.stopButton),
processOnce: controlDiv.querySelector(
CONFIG.SELECTORS.ui.processOnceButton
),
skip: controlDiv.querySelector(CONFIG.SELECTORS.ui.skipButton),
status: controlDiv.querySelector(CONFIG.SELECTORS.ui.statusElement),
minimizeBtn: controlDiv.querySelector(
CONFIG.SELECTORS.ui.minimizeButton
),
wishlistCount: controlDiv.querySelector(
CONFIG.SELECTORS.ui.wishlistCountElement
),
autoStartCheckbox: controlDiv.querySelector(
CONFIG.SELECTORS.ui.autoStartCheckbox
),
autoRestartCheckbox: controlDiv.querySelector(
CONFIG.SELECTORS.ui.autoRestartCheckbox
),
requireCardsCheckbox: controlDiv.querySelector(
CONFIG.SELECTORS.ui.requireCardsCheckbox
),
skipOwnedCheckbox: controlDiv.querySelector(
CONFIG.SELECTORS.ui.skipOwnedCheckbox
),
skipNonGamesCheckbox: controlDiv.querySelector(
CONFIG.SELECTORS.ui.skipNonGamesCheckbox
),
versionInfo: controlDiv.querySelector(CONFIG.SELECTORS.ui.versionInfo),
};
// Add event listeners
State.ui.elements.startBtn.addEventListener(
"click",
LoopController.startLoop
);
State.ui.elements.pauseBtn.addEventListener(
"click",
LoopController.pauseLoop
);
State.ui.elements.stopBtn.addEventListener(
"click",
() => LoopController.stopLoop(false) // Stop and disable auto features
);
State.ui.elements.processOnce.addEventListener(
"click",
QueueProcessor.processOnce
);
State.ui.elements.skip.addEventListener("click", QueueProcessor.skipItem);
State.ui.elements.minimizeBtn.addEventListener(
"click",
this.toggleMinimizeUI
);
// Settings listeners using SettingsManager
State.ui.elements.autoStartCheckbox.addEventListener("change", (e) =>
SettingsManager.updateSetting(
CONFIG.STORAGE_KEYS.AUTO_START,
e.target.checked
)
);
State.ui.elements.autoRestartCheckbox.addEventListener("change", (e) =>
SettingsManager.updateSetting(
CONFIG.STORAGE_KEYS.AUTO_RESTART_QUEUE,
e.target.checked
)
);
State.ui.elements.requireCardsCheckbox.addEventListener("change", (e) =>
SettingsManager.updateSetting(
CONFIG.STORAGE_KEYS.REQUIRE_CARDS,
e.target.checked
)
);
State.ui.elements.skipOwnedCheckbox.addEventListener("change", (e) =>
SettingsManager.updateSetting(
CONFIG.STORAGE_KEYS.SKIP_OWNED,
e.target.checked
)
);
State.ui.elements.skipNonGamesCheckbox.addEventListener("change", (e) =>
SettingsManager.updateSetting(
CONFIG.STORAGE_KEYS.SKIP_NON_GAMES,
e.target.checked
)
);
// Update UI to match current state
this.updateUI();
},
/**
* Update all UI elements to match current state
*/
updateUI: function () {
if (!State.ui.elements.container) return;
const isRunning = State.loop.state === "Running";
const isPaused = State.loop.state === "Paused";
// Update button states
State.ui.elements.startBtn.disabled = isRunning;
State.ui.elements.startBtn.textContent = isPaused ? "Resume" : "Start";
State.ui.elements.startBtn.title = isPaused
? "Resume automatic processing"
: "Start automatic processing";
State.ui.elements.pauseBtn.disabled = !isRunning;
State.ui.elements.stopBtn.disabled = !(isRunning || isPaused);
// Update manual action buttons based on state
this.updateManualButtonStates();
// Update checkboxes
State.ui.elements.autoStartCheckbox.checked =
State.settings.autoStartEnabled;
State.ui.elements.autoRestartCheckbox.checked =
State.settings.autoRestartQueueEnabled;
State.ui.elements.requireCardsCheckbox.checked =
State.settings.requireTradingCards;
State.ui.elements.skipOwnedCheckbox.checked =
State.settings.skipOwnedGames;
State.ui.elements.skipNonGamesCheckbox.checked =
State.settings.skipNonGames;
// Update UI minimization state
State.ui.elements.container.classList.toggle(
"wl-minimized",
State.settings.uiMinimized
);
State.ui.elements.minimizeBtn.innerHTML = State.settings.uiMinimized
? "□"
: "▬";
State.ui.elements.minimizeBtn.title = State.settings.uiMinimized
? "Restore"
: "Minimize";
// Update wishlist count
if (State.ui.elements.wishlistCount) {
State.ui.elements.wishlistCount.textContent =
State.stats.wishlistedThisSession;
}
// Initial status text update if needed (avoid overwriting transient messages)
// Check if the current status is just the base "Status: Initializing..." or empty
const currentStatusText = State.ui.elements.status
? State.ui.elements.status.textContent
: "";
if (
!currentStatusText ||
currentStatusText === "Status: Initializing..."
) {
if (isPaused) UI.updateStatusText("Paused", "paused");
else if (isRunning) UI.updateStatusText("Running - Idle...");
else UI.updateStatusText("Stopped.");
}
},
/**
* Toggle UI minimized state
*/
toggleMinimizeUI: function () {
State.settings.uiMinimized = !State.settings.uiMinimized;
GM_setValue(CONFIG.STORAGE_KEYS.UI_MINIMIZED, State.settings.uiMinimized);
UI.updateUI(); // Just call updateUI which handles the class and button text
},
/**
* Update the version info element if a new version is available
* @param {string} latestVersion - The latest version available
* @param {string} updateUrl - The URL to the update page/script
*/
updateVersionInfo: function (latestVersion, updateUrl) {
if (!State.ui.elements.versionInfo) return;
// Simple version comparison (assumes semantic versioning or similar numeric comparison)
const isNewer =
latestVersion &&
latestVersion.localeCompare(CONFIG.CURRENT_VERSION, undefined, {
numeric: true,
sensitivity: "base",
}) === 1;
if (isNewer) {
State.ui.elements.versionInfo.textContent = `v${CONFIG.CURRENT_VERSION} (Update: v${latestVersion})`;
State.ui.elements.versionInfo.classList.add("wl-update-available");
State.ui.elements.versionInfo.title = `New version ${latestVersion} available! Click to view.`;
// Make clickable only if update URL is provided and valid
if (updateUrl && updateUrl !== "#") {
State.ui.elements.versionInfo.style.cursor = "pointer";
// Remove previous listener before adding new one
State.ui.elements.versionInfo.onclick = null;
State.ui.elements.versionInfo.onclick = () => {
window.open(updateUrl, "_blank");
};
} else {
State.ui.elements.versionInfo.style.cursor = "default";
State.ui.elements.versionInfo.onclick = null;
}
} else {
State.ui.elements.versionInfo.textContent = `v${CONFIG.CURRENT_VERSION}`;
State.ui.elements.versionInfo.classList.remove("wl-update-available");
State.ui.elements.versionInfo.title = "";
State.ui.elements.versionInfo.style.cursor = "default";
State.ui.elements.versionInfo.onclick = null;
}
},
};
// ====================================
// Module: Settings Manager
// ====================================
const SettingsManager = {
/**
* Update a setting value in state and GM storage
* @param {string} key - The storage key from CONFIG.STORAGE_KEYS
* @param {any} newValue - The new value for the setting
*/
updateSetting: function (key, newValue) {
GM_setValue(key, newValue);
// Find the corresponding key in State.settings based on the GM key
const stateKeyEntry = Object.entries(CONFIG.STORAGE_KEYS).find(
([stateName, gmKey]) => gmKey === key
);
if (stateKeyEntry) {
// Convert state key from uppercase_snake_case (like AUTO_START) to camelCase (like autoStartEnabled)
const camelCaseKey = stateKeyEntry[0]
.toLowerCase()
.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
if (camelCaseKey in State.settings) {
State.settings[camelCaseKey] = newValue;
Logger.log(`${camelCaseKey} updated to: ${newValue}`, 1);
} else {
Logger.log(
`Warning: No matching key found in State.settings for ${camelCaseKey} (derived from ${key})`,
0
);
}
} else {
Logger.log(
`Warning: No CONFIG.STORAGE_KEYS entry found matching GM key ${key}`,
0
);
}
// Refresh UI to reflect changes (checkboxes, potentially behavior)
// Avoid calling updateUI directly if this might cause rapid updates; maybe defer or be selective.
// For checkbox changes, UI.updateUI() is generally fine.
UI.updateUI();
},
/**
* Toggles a boolean setting and saves it. Used primarily by menu commands.
* @param {string} key - The storage key from CONFIG.STORAGE_KEYS
* @param {boolean} currentValue - The current value to toggle
* @returns {boolean} The new value after toggling
*/
toggleSetting: function (key, currentValue) {
const newValue = !currentValue;
this.updateSetting(key, newValue); // updateSetting handles state update and logging
// Find the state key again to return the accurate new value from the state object
const stateKeyEntry = Object.entries(CONFIG.STORAGE_KEYS).find(
([stateName, gmKey]) => gmKey === key
);
if (stateKeyEntry) {
const camelCaseKey = stateKeyEntry[0]
.toLowerCase()
.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
if (camelCaseKey in State.settings) {
return State.settings[camelCaseKey];
}
}
// Fallback return if state mapping fails (shouldn't happen)
return newValue;
},
};
// ====================================
// Module: Age Verification Bypass
// ====================================
const AgeVerificationBypass = {
/**
* Initialize age verification bypass functionality
*/
init: function () {
// Only run on matching domains
if (
!window.location.hostname.includes("steampowered.com") &&
!window.location.hostname.includes("steamcommunity.com")
) {
return;
}
Logger.log("[Steam Age Skip] Initializing...", 1);
try {
// Set cookies for age verification immediately
this.setCookies();
// Handle based on current site using event listeners for robustness
if (location.hostname.includes("store.steampowered.com")) {
this.handleStoreSite();
} else if (location.hostname.includes("steamcommunity.com")) {
this.handleCommunitySite();
}
} catch (e) {
Logger.log(`[Steam Age Skip] Error during init: ${e.message}`, 0);
}
},
/**
* Set cookies for age verification on both domains
*/
setCookies: function () {
const birthTimeKey = "birthtime";
const matureContentKey = "wants_mature_content";
const sessionMatureContentKey = "session_mature_content"; // Sometimes needed
// Calculate a plausible birth date (e.g., >= 21 years ago for safety)
const twentyOneYearsInSeconds = 21 * 365.25 * 24 * 60 * 60;
const birthTimestamp = Math.floor(
Date.now() / 1000 - twentyOneYearsInSeconds
);
// Use Lax for better compatibility, Secure is important
const baseCookieOptions = `; max-age=315360000; secure; samesite=Lax`; // 10 years expiration
// Construct cookie strings for each domain
const storeDomain = ".store.steampowered.com";
const communityDomain = ".steamcommunity.com";
const genericDomain = ".steampowered.com"; // Some cookies might be set here
const cookiesToSet = [
{ key: birthTimeKey, value: birthTimestamp },
{ key: matureContentKey, value: 1 },
{ key: sessionMatureContentKey, value: 1 }, // Often set without Max-Age
];
cookiesToSet.forEach((cookie) => {
document.cookie = `${cookie.key}=${cookie.value}; path=/; domain=${storeDomain}${baseCookieOptions}`;
document.cookie = `${cookie.key}=${cookie.value}; path=/; domain=${communityDomain}${baseCookieOptions}`;
document.cookie = `${cookie.key}=${cookie.value}; path=/; domain=${genericDomain}${baseCookieOptions}`;
// Set session cookie without max-age too, just in case
if (cookie.key === sessionMatureContentKey) {
document.cookie = `${cookie.key}=${cookie.value}; path=/; domain=${storeDomain}; secure; samesite=Lax`;
document.cookie = `${cookie.key}=${cookie.value}; path=/; domain=${communityDomain}; secure; samesite=Lax`;
document.cookie = `${cookie.key}=${cookie.value}; path=/; domain=${genericDomain}; secure; samesite=Lax`;
}
});
Logger.log(
`[Steam Age Skip] Age cookies set for domains (Store, Community, Generic).`,
1
);
},
/**
* Handle age verification on Steam store page load and dynamically
*/
handleStoreSite: function () {
const checkAndReload = () => {
const ageGate = document.querySelector(
CONFIG.SELECTORS.ageGate.storeContainer
);
// Added more selectors for robustness
const ageGateOverlay = document.querySelector(
".agegate_birthday_desc, #agegate_box .agegate_text_container"
);
if (ageGate || ageGateOverlay) {
Logger.log(
"[Steam Age Skip] Age gate detected on store. Attempting bypass/reload...",
0
);
// Attempt to click the view button first if available
const viewButton = document.querySelector(
"#view_product_page_btn, .btn_medium.btnv6_lightblue_blue > span"
); // Try common view buttons
if (viewButton && viewButton.offsetParent) {
// Check visibility
Logger.log(
"[Steam Age Skip] Found visible view button, attempting click...",
1
);
viewButton.click();
// Don't reload immediately, give click time to work and check again
setTimeout(() => {
const ageGateAfterClick = document.querySelector(
CONFIG.SELECTORS.ageGate.storeContainer
);
const ageGateOverlayAfterClick = document.querySelector(
".agegate_birthday_desc, #agegate_box .agegate_text_container"
);
if (ageGateAfterClick || ageGateOverlayAfterClick) {
Logger.log(
"[Steam Age Skip] Age gate still present after click, reloading.",
1
);
location.reload();
} else {
Logger.log(
"[Steam Age Skip] Age gate seems dismissed by click.",
1
);
}
}, 500); // Wait 500ms
} else {
// If no visible button found, just reload - cookies should handle it.
Logger.log(
"[Steam Age Skip] No view button found or visible, relying on reload.",
1
);
location.reload();
}
return true; // Gate found
}
return false; // No gate found
};
// Run check immediately and on DOMContentLoaded/load
if (!checkAndReload()) {
// If no gate initially
window.addEventListener("DOMContentLoaded", checkAndReload, {
once: true,
});
window.addEventListener("load", checkAndReload, { once: true }); // Backup check on full load
}
},
/**
* Handle age verification on Steam community page load and dynamically
*/
handleCommunitySite: function () {
const checkAndProceed = () => {
const ageCheck = document.querySelector(
CONFIG.SELECTORS.ageGate.communityTextContainer
);
if (ageCheck && ageCheck.offsetParent) {
// Check visibility
Logger.log(
"[Steam Age Skip] Age gate detected on community. Attempting bypass...",
0
);
// Try multiple strategies to bypass age gate
if (!this.tryProceedFunction()) {
Logger.log(
"[Steam Age Skip] Proceed functions failed or not found. Relying on cookies/reload.",
1
);
// Cookies should have been set, maybe a reload is needed if JS fails?
// Avoid reload loops. If the function call didn't work, manual interaction might be needed.
} else {
Logger.log(
"[Steam Age Skip] Proceed function called successfully (or attempted via injection).",
1
);
// Function call might trigger navigation or content loading.
}
return true; // Gate found
}
return false; // No gate found
};
// Run check immediately and on DOMContentLoaded/load
if (!checkAndProceed()) {
// If no gate initially
window.addEventListener("DOMContentLoaded", checkAndProceed, {
once: true,
});
window.addEventListener("load", checkAndProceed, { once: true });
}
},
/**
* Try different methods to call the Proceed/Accept function (more robust)
* @returns {boolean} Whether any attempt was potentially successful
*/
tryProceedFunction: function () {
let executed = false;
const functionsToTry = ["Proceed", "AcceptAppHub", "ViewProductPage"]; // Add more potential function names if needed
// Helper to log execution attempt
const attemptExecution = (source, funcName, func) => {
Logger.log(`[Steam Age Skip] Attempting ${source}.${funcName}()...`, 1);
try {
func();
executed = true; // Mark as executed if call doesn't throw immediately
Logger.log(` -> Call successful (no immediate error).`, 1);
return true; // Stop trying other methods
} catch (e) {
Logger.log(
` -> Error calling ${source}.${funcName}: ${e.message}`,
1
);
return false; // Continue trying other methods
}
};
// 1. Try direct unsafeWindow call (GreaseMonkey/Tampermonkey standard)
if (typeof unsafeWindow !== "undefined") {
for (const funcName of functionsToTry) {
if (typeof unsafeWindow[funcName] === "function") {
if (
attemptExecution("unsafeWindow", funcName, unsafeWindow[funcName])
)
return true;
}
}
}
// 2. Try direct window call (less likely due to sandboxing, but check anyway)
if (!executed) {
for (const funcName of functionsToTry) {
if (typeof window[funcName] === "function") {
if (attemptExecution("window", funcName, window[funcName]))
return true;
}
}
}
// 3. Try wrappedJSObject (Firefox-specific)
if (
!executed &&
typeof XPCNativeWrapper !== "undefined" &&
typeof XPCNativeWrapper.unwrap === "function"
) {
try {
const unwrappedWindow = XPCNativeWrapper.unwrap(window);
for (const funcName of functionsToTry) {
if (typeof unwrappedWindow[funcName] === "function") {
if (
attemptExecution(
"wrappedJSObject",
funcName,
unwrappedWindow[funcName]
)
)
return true;
}
}
} catch (e) {
Logger.log(` -> Error accessing wrappedJSObject: ${e.message}`, 1);
}
}
// 4. Script Injection (Last resort if other methods fail)
if (!executed) {
Logger.log(
"[Steam Age Skip] Direct calls failed, injecting script tag...",
1
);
try {
const script = document.createElement("script");
let scriptContent = `"use strict"; (function() { console.log("[Steam Age Skip - Injected] Trying functions..."); var executed = false;`;
functionsToTry.forEach((funcName) => {
// Check if function exists before calling, prevent errors in injected script
scriptContent += `if (!executed && typeof window.${funcName} === 'function') { console.log('[Steam Age Skip - Injected] Calling ${funcName}()'); try { window.${funcName}(); executed = true; } catch(e) { console.error('Error in injected ${funcName}:', e); } } `;
});
scriptContent += `if (!executed) console.log("[Steam Age Skip - Injected] No known function found or executed successfully."); })();`;
script.textContent = scriptContent;
const target = document.head || document.documentElement;
if (target) {
target.appendChild(script); // Append might be safer than prepend sometimes
executed = true; // Assume injection itself worked, even if function inside fails silently
Logger.log(" -> Script injected.", 1);
// Remove script after a short delay to allow execution
setTimeout(() => script.remove(), 100);
} else {
Logger.log(
" -> Script injection failed: No target element (head/documentElement).",
0
);
}
} catch (e) {
Logger.log(
`[Steam Age Skip] Script injection creation failed: ${e.message}`,
0
);
}
}
return executed; // Return true if any method was attempted (direct call) or if injection was done
},
};
// ====================================
// Module: Game Info Utilities
// ====================================
const GameInfoUtils = {
/**
* Get the app type from various indicators on the page.
* @returns {string} The determined app type (Game, DLC, Soundtrack, Demo, Application, Video, Mod, Unknown)
*/
getAppType: function () {
// 1. Check DLC bubble first (most reliable for DLC)
const dlcIndicator = document.querySelector(
CONFIG.SELECTORS.gameInfo.dlcIndicator
);
if (dlcIndicator?.offsetParent) return "DLC";
// 2. Check details block text content
const appTypeBlock = document.querySelector(
CONFIG.SELECTORS.gameInfo.appTypeElement
);
if (appTypeBlock) {
// Use textContent for broader matching, trim and uppercase
const detailText = appTypeBlock.textContent?.trim().toUpperCase() || "";
if (detailText.includes("DOWNLOADABLE CONTENT")) return "DLC";
if (detailText.includes("SOUNDTRACK")) return "Soundtrack";
if (detailText.includes("DEMO")) return "Demo";
if (detailText.includes("APPLICATION")) return "Application";
if (detailText.includes("VIDEO") || detailText.includes("MOVIE"))
return "Video"; // Added Movie
if (detailText.includes("MOD")) return "Mod";
}
// 3. Check breadcrumbs for clues (e.g., "Software", "Videos")
// Ensure robust selector for breadcrumbs
const breadcrumbs = document.querySelectorAll(
".breadcrumbs .breadcrumb a, .game_title_area .blockbg a"
);
if (breadcrumbs.length > 0) {
// Check all breadcrumbs, not just second-to-last
for (const crumb of breadcrumbs) {
const crumbText = crumb.textContent?.trim().toUpperCase();
if (crumbText === "SOFTWARE") return "Application";
if (crumbText === "VIDEOS" || crumbText === "VIDEO") return "Video"; // Check plural too
if (crumbText === "SOUNDTRACKS" || crumbText === "SOUNDTRACK")
return "Soundtrack";
if (crumbText === "DEMOS" || crumbText === "DEMO") return "Demo";
if (crumbText === "MODS") return "Mod";
// Add more checks if needed (e.g., "HARDWARE"?)
}
}
// 4. Check for specific demo notice elements
const demoNotice = document.querySelector(
".demo_notice, .game_area_purchase_game.demo_above_purchase"
);
if (demoNotice?.offsetParent) return "Demo";
// 5. Check common tags often associated with non-games (less reliable)
// Example: document.querySelector('.app_tag[data-tagid="1774"]') // Utilities tag
// If none of the above match, assume it's a Game
return "Game"; // Default assumption
},
/**
* Checks if the item is considered a "Non-Game" based on settings and type detection.
* @returns {string | null} Reason string if it should be skipped as non-game, or null otherwise.
*/
checkIfNonGame: function () {
if (!State.settings.skipNonGames) {
return null; // Skip check if setting is off
}
const appType = this.getAppType();
// Define the list of types to skip when the setting is enabled
const nonGameTypesToSkip = [
"DLC",
"Soundtrack",
"Demo",
"Application",
"Video",
"Mod",
];
if (nonGameTypesToSkip.includes(appType)) {
return `Type: ${appType}`; // Return the reason for skipping
}
// Additional check: Sometimes items are technically "Games" but act like DLC (e.g., Chapter Packs)
// This requires more complex logic, perhaps checking tags or descriptions, omitted for now.
return null; // Considered a game according to current checks
},
};
// ====================================
// Module: Queue Navigation
// ====================================
const QueueNavigation = {
/**
* Advance to the next item in the queue using the best available method.
* Returns the method used ('Next', 'Ignore', 'FormSubmit', 'Failed')
* @returns {Promise