steamworks-ffi-node 0.1.1 → 0.2.1

package/dist/internal/SteamAchievementManager.js

@@ -0,0 +1,673 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SteamAchievementManager = void 0;
+const koffi = __importStar(require("koffi"));
+/**
+ * Manages all Steam achievement operations
+ */
+class SteamAchievementManager {
+    constructor(libraryLoader, apiCore) {
+        this.libraryLoader = libraryLoader;
+        this.apiCore = apiCore;
+    }
+    /**
+     * Get all achievements from Steam
+     */
+    async getAllAchievements() {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return [];
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return [];
+        }
+        try {
+            // Run callbacks to ensure we have latest data
+            this.apiCore.runCallbacks();
+            const achievements = [];
+            const numAchievements = this.libraryLoader.SteamAPI_ISteamUserStats_GetNumAchievements(userStatsInterface);
+            console.log(`[Steamworks] Found ${numAchievements} achievements in Steam`);
+            for (let i = 0; i < numAchievements; i++) {
+                try {
+                    // Get achievement API name
+                    const apiName = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementName(userStatsInterface, i);
+                    if (!apiName)
+                        continue;
+                    // Get display name
+                    const displayName = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(userStatsInterface, apiName, 'name') || apiName;
+                    // Get description
+                    const description = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(userStatsInterface, apiName, 'desc') || '';
+                    // Check if unlocked and get unlock time
+                    const unlockedPtr = koffi.alloc('bool', 1);
+                    const unlockTimePtr = koffi.alloc('uint32', 1);
+                    const hasAchievement = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime(userStatsInterface, apiName, unlockedPtr, unlockTimePtr);
+                    const unlocked = hasAchievement ? koffi.decode(unlockedPtr, 'bool') : false;
+                    const unlockTime = hasAchievement && unlocked ? koffi.decode(unlockTimePtr, 'uint32') : 0;
+                    achievements.push({
+                        apiName,
+                        displayName,
+                        description,
+                        unlocked,
+                        unlockTime // Now returns actual Steam unlock time (Unix timestamp)
+                    });
+                }
+                catch (error) {
+                    console.warn(`Failed to get achievement ${i}:`, error.message);
+                }
+            }
+            return achievements;
+        }
+        catch (error) {
+            console.error('[Steamworks] ERROR: Failed to get achievements:', error.message);
+            return [];
+        }
+    }
+    /**
+     * Unlock achievement in Steam
+     */
+    async unlockAchievement(achievementName) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return false;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return false;
+        }
+        try {
+            console.log(`[Steamworks] Attempting to unlock achievement: ${achievementName}`);
+            // Set the achievement
+            const result = this.libraryLoader.SteamAPI_ISteamUserStats_SetAchievement(userStatsInterface, achievementName);
+            if (result) {
+                // Store stats to commit the achievement to Steam servers
+                const storeResult = this.libraryLoader.SteamAPI_ISteamUserStats_StoreStats(userStatsInterface);
+                if (storeResult) {
+                    // Run callbacks to process the achievement unlock
+                    this.apiCore.runCallbacks();
+                    console.log(`[Steamworks] Achievement unlocked successfully: ${achievementName}`);
+                    return true;
+                }
+                else {
+                    console.error(`[Steamworks] ERROR: Failed to store stats for achievement: ${achievementName}`);
+                    return false;
+                }
+            }
+            else {
+                console.error(`[Steamworks] ERROR: Failed to set achievement: ${achievementName}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error unlocking achievement ${achievementName}:`, error.message);
+            return false;
+        }
+    }
+    /**
+     * Clear achievement in Steam (for testing)
+     */
+    async clearAchievement(achievementName) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return false;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return false;
+        }
+        try {
+            console.log(`[Steamworks] Attempting to clear achievement: ${achievementName}`);
+            // Clear the achievement
+            const result = this.libraryLoader.SteamAPI_ISteamUserStats_ClearAchievement(userStatsInterface, achievementName);
+            if (result) {
+                // Store stats to commit the change to Steam servers
+                const storeResult = this.libraryLoader.SteamAPI_ISteamUserStats_StoreStats(userStatsInterface);
+                if (storeResult) {
+                    // Run callbacks to process the change
+                    this.apiCore.runCallbacks();
+                    console.log(`[Steamworks] Achievement cleared successfully: ${achievementName}`);
+                    return true;
+                }
+                else {
+                    console.error(`[Steamworks] ERROR: Failed to store stats for clearing achievement: ${achievementName}`);
+                    return false;
+                }
+            }
+            else {
+                console.error(`[Steamworks] ERROR: Failed to clear achievement: ${achievementName}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error clearing achievement ${achievementName}:`, error.message);
+            return false;
+        }
+    }
+    /**
+     * Check if achievement is unlocked
+     */
+    async isAchievementUnlocked(achievementName) {
+        if (!this.apiCore.isInitialized()) {
+            return false;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            return false;
+        }
+        try {
+            const unlockedPtr = koffi.alloc('bool', 1);
+            const unlockTimePtr = koffi.alloc('uint32', 1);
+            const hasAchievement = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime(userStatsInterface, achievementName, unlockedPtr, unlockTimePtr);
+            return hasAchievement ? koffi.decode(unlockedPtr, 'bool') : false;
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error checking achievement ${achievementName}:`, error.message);
+            return false;
+        }
+    }
+    /**
+     * Get achievement by API name
+     */
+    async getAchievementByName(achievementName) {
+        const achievements = await this.getAllAchievements();
+        return achievements.find(a => a.apiName === achievementName) || null;
+    }
+    /**
+     * Get total number of achievements
+     */
+    async getTotalAchievementCount() {
+        if (!this.apiCore.isInitialized()) {
+            return 0;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            return 0;
+        }
+        try {
+            return this.libraryLoader.SteamAPI_ISteamUserStats_GetNumAchievements(userStatsInterface);
+        }
+        catch (error) {
+            console.error('[Steamworks] ERROR: Error getting achievement count:', error.message);
+            return 0;
+        }
+    }
+    /**
+     * Get number of unlocked achievements
+     */
+    async getUnlockedAchievementCount() {
+        const achievements = await this.getAllAchievements();
+        return achievements.filter(a => a.unlocked).length;
+    }
+    /**
+     * Get achievement icon handle
+     * Returns icon handle for use with ISteamUtils::GetImageRGBA()
+     * Returns 0 if no icon set or still loading
+     */
+    async getAchievementIcon(achievementName) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return 0;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return 0;
+        }
+        try {
+            const iconHandle = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementIcon(userStatsInterface, achievementName);
+            console.log(`[Steamworks] Achievement icon handle for ${achievementName}: ${iconHandle}`);
+            return iconHandle;
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error getting achievement icon:`, error.message);
+            return 0;
+        }
+    }
+    /**
+     * Indicate achievement progress to user
+     * Shows a progress notification in Steam overlay
+     */
+    async indicateAchievementProgress(achievementName, currentProgress, maxProgress) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return false;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return false;
+        }
+        try {
+            console.log(`[Steamworks] Indicating achievement progress: ${achievementName} (${currentProgress}/${maxProgress})`);
+            const result = this.libraryLoader.SteamAPI_ISteamUserStats_IndicateAchievementProgress(userStatsInterface, achievementName, currentProgress, maxProgress);
+            if (result) {
+                this.apiCore.runCallbacks();
+                console.log(`[Steamworks] Achievement progress indicated successfully`);
+                return true;
+            }
+            else {
+                console.error(`[Steamworks] ERROR: Failed to indicate achievement progress`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error indicating achievement progress:`, error.message);
+            return false;
+        }
+    }
+    /**
+     * Get achievement progress limits (for integer-based progress)
+     */
+    async getAchievementProgressLimitsInt(achievementName) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return null;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return null;
+        }
+        try {
+            const minPtr = koffi.alloc('int32', 1);
+            const maxPtr = koffi.alloc('int32', 1);
+            const result = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementProgressLimitsInt32(userStatsInterface, achievementName, minPtr, maxPtr);
+            if (result) {
+                return {
+                    minProgress: koffi.decode(minPtr, 'int32'),
+                    maxProgress: koffi.decode(maxPtr, 'int32')
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error getting achievement progress limits:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Get achievement progress limits (for float-based progress)
+     */
+    async getAchievementProgressLimitsFloat(achievementName) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return null;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return null;
+        }
+        try {
+            const minPtr = koffi.alloc('float', 1);
+            const maxPtr = koffi.alloc('float', 1);
+            const result = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementProgressLimitsFloat(userStatsInterface, achievementName, minPtr, maxPtr);
+            if (result) {
+                return {
+                    minProgress: koffi.decode(minPtr, 'float'),
+                    maxProgress: koffi.decode(maxPtr, 'float')
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error getting achievement progress limits:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Request stats for another user (friend)
+     * This is async - you need to wait for the callback before calling getUserAchievement
+     */
+    async requestUserStats(steamId) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return false;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return false;
+        }
+        try {
+            console.log(`[Steamworks] Requesting user stats for Steam ID: ${steamId}`);
+            const steamIdNum = BigInt(steamId);
+            const callHandle = this.libraryLoader.SteamAPI_ISteamUserStats_RequestUserStats(userStatsInterface, steamIdNum);
+            if (callHandle !== BigInt(0)) {
+                console.log(`[Steamworks] User stats request sent (call handle: ${callHandle})`);
+                return true;
+            }
+            else {
+                console.error(`[Steamworks] ERROR: Failed to request user stats`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error requesting user stats:`, error.message);
+            return false;
+        }
+    }
+    /**
+     * Get achievement status for another user (friend)
+     * Must call requestUserStats() first and wait for callback
+     */
+    async getUserAchievement(steamId, achievementName) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return null;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return null;
+        }
+        try {
+            const steamIdNum = BigInt(steamId);
+            const unlockedPtr = koffi.alloc('bool', 1);
+            const unlockTimePtr = koffi.alloc('uint32', 1);
+            const result = this.libraryLoader.SteamAPI_ISteamUserStats_GetUserAchievementAndUnlockTime(userStatsInterface, steamIdNum, achievementName, unlockedPtr, unlockTimePtr);
+            if (result) {
+                // Get display info for achievement
+                const displayName = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(userStatsInterface, achievementName, 'name') || achievementName;
+                const description = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(userStatsInterface, achievementName, 'desc') || '';
+                const unlocked = koffi.decode(unlockedPtr, 'bool');
+                const unlockTime = unlocked ? koffi.decode(unlockTimePtr, 'uint32') : 0;
+                return {
+                    steamId,
+                    apiName: achievementName,
+                    displayName,
+                    description,
+                    unlocked,
+                    unlockTime
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error getting user achievement:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Request global achievement percentages
+     * This is async - wait for callback before calling getAchievementAchievedPercent
+     */
+    async requestGlobalAchievementPercentages() {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return false;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return false;
+        }
+        try {
+            console.log(`[Steamworks] Requesting global achievement percentages...`);
+            const callHandle = this.libraryLoader.SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages(userStatsInterface);
+            if (callHandle !== BigInt(0)) {
+                console.log(`[Steamworks] Global achievement percentages request sent (call handle: ${callHandle})`);
+                return true;
+            }
+            else {
+                console.error(`[Steamworks] ERROR: Failed to request global achievement percentages`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error requesting global achievement percentages:`, error.message);
+            return false;
+        }
+    }
+    /**
+     * Get percentage of users who unlocked a specific achievement
+     * Must call requestGlobalAchievementPercentages() first
+     */
+    async getAchievementAchievedPercent(achievementName) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return null;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return null;
+        }
+        try {
+            const percentPtr = koffi.alloc('float', 1);
+            const result = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementAchievedPercent(userStatsInterface, achievementName, percentPtr);
+            if (result) {
+                const percent = koffi.decode(percentPtr, 'float');
+                console.log(`[Steamworks] Achievement ${achievementName} global unlock: ${percent.toFixed(2)}%`);
+                return percent;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error getting achievement percentage:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Get all achievements with global unlock percentages
+     * Must call requestGlobalAchievementPercentages() first and wait for callback
+     */
+    async getAllAchievementsWithGlobalStats() {
+        const achievements = await this.getAllAchievements();
+        const result = [];
+        for (const ach of achievements) {
+            const percent = await this.getAchievementAchievedPercent(ach.apiName);
+            result.push({
+                apiName: ach.apiName,
+                displayName: ach.displayName,
+                description: ach.description,
+                unlocked: ach.unlocked,
+                globalUnlockPercentage: percent ?? 0
+            });
+        }
+        return result;
+    }
+    /**
+     * Get most achieved achievement info
+     * Returns iterator for use with getNextMostAchievedAchievementInfo
+     */
+    async getMostAchievedAchievementInfo() {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return null;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return null;
+        }
+        try {
+            const nameBuffer = Buffer.alloc(256);
+            const percentPtr = koffi.alloc('float', 1);
+            const unlockedPtr = koffi.alloc('bool', 1);
+            const iterator = this.libraryLoader.SteamAPI_ISteamUserStats_GetMostAchievedAchievementInfo(userStatsInterface, nameBuffer, 256, percentPtr, unlockedPtr);
+            if (iterator !== -1) {
+                const apiName = nameBuffer.toString('utf8').split('\0')[0];
+                const percent = koffi.decode(percentPtr, 'float');
+                const unlocked = koffi.decode(unlockedPtr, 'bool');
+                return { apiName, percent, unlocked, iterator };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error getting most achieved achievement:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Get next most achieved achievement info (iterate by popularity)
+     */
+    async getNextMostAchievedAchievementInfo(previousIterator) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return null;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return null;
+        }
+        try {
+            const nameBuffer = Buffer.alloc(256);
+            const percentPtr = koffi.alloc('float', 1);
+            const unlockedPtr = koffi.alloc('bool', 1);
+            const iterator = this.libraryLoader.SteamAPI_ISteamUserStats_GetNextMostAchievedAchievementInfo(userStatsInterface, previousIterator, nameBuffer, 256, percentPtr, unlockedPtr);
+            if (iterator !== -1) {
+                const apiName = nameBuffer.toString('utf8').split('\0')[0];
+                const percent = koffi.decode(percentPtr, 'float');
+                const unlocked = koffi.decode(unlockedPtr, 'bool');
+                return { apiName, percent, unlocked, iterator };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error getting next most achieved achievement:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Get all achievements sorted by global unlock percentage (most achieved first)
+     * Must call requestGlobalAchievementPercentages() first
+     */
+    async getAllAchievementsSortedByPopularity() {
+        const results = [];
+        // Get first achievement
+        const first = await this.getMostAchievedAchievementInfo();
+        if (!first) {
+            console.warn('[Steamworks] WARNING: No global achievement data available. Call requestGlobalAchievementPercentages() first.');
+            return results;
+        }
+        // Get display info
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (userStatsInterface) {
+            const displayName = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(userStatsInterface, first.apiName, 'name') || first.apiName;
+            const description = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(userStatsInterface, first.apiName, 'desc') || '';
+            results.push({
+                apiName: first.apiName,
+                displayName,
+                description,
+                unlocked: first.unlocked,
+                globalUnlockPercentage: first.percent
+            });
+        }
+        // Iterate through remaining achievements
+        let iterator = first.iterator;
+        while (iterator !== -1) {
+            const next = await this.getNextMostAchievedAchievementInfo(iterator);
+            if (!next)
+                break;
+            if (userStatsInterface) {
+                const displayName = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(userStatsInterface, next.apiName, 'name') || next.apiName;
+                const description = this.libraryLoader.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(userStatsInterface, next.apiName, 'desc') || '';
+                results.push({
+                    apiName: next.apiName,
+                    displayName,
+                    description,
+                    unlocked: next.unlocked,
+                    globalUnlockPercentage: next.percent
+                });
+            }
+            iterator = next.iterator;
+        }
+        return results;
+    }
+    /**
+     * Reset all stats and optionally achievements
+     * WARNING: This clears ALL user stats and achievements!
+     */
+    async resetAllStats(includeAchievements = false) {
+        if (!this.apiCore.isInitialized()) {
+            console.warn('[Steamworks] WARNING: Steam API not initialized');
+            return false;
+        }
+        const userStatsInterface = this.apiCore.getUserStatsInterface();
+        if (!userStatsInterface) {
+            console.warn('[Steamworks] WARNING: UserStats interface not available');
+            return false;
+        }
+        try {
+            console.log(`[Steamworks] Resetting all stats (achievements: ${includeAchievements ? 'YES' : 'NO'})`);
+            console.warn('[Steamworks] WARNING: This will reset ALL user statistics!');
+            const result = this.libraryLoader.SteamAPI_ISteamUserStats_ResetAllStats(userStatsInterface, includeAchievements);
+            if (result) {
+                // Store the reset
+                const storeResult = this.libraryLoader.SteamAPI_ISteamUserStats_StoreStats(userStatsInterface);
+                if (storeResult) {
+                    this.apiCore.runCallbacks();
+                    console.log(`[Steamworks] All stats reset successfully`);
+                    return true;
+                }
+                else {
+                    console.error(`[Steamworks] ERROR: Failed to store stats after reset`);
+                    return false;
+                }
+            }
+            else {
+                console.error(`[Steamworks] ERROR: Failed to reset stats`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error(`[Steamworks] ERROR: Error resetting stats:`, error.message);
+            return false;
+        }
+    }
+    /**
+     * Get all achievements with icon handles
+     */
+    async getAllAchievementsWithIcons() {
+        const achievements = await this.getAllAchievements();
+        const result = [];
+        for (const ach of achievements) {
+            const iconHandle = await this.getAchievementIcon(ach.apiName);
+            result.push({
+                ...ach,
+                iconHandle
+            });
+        }
+        return result;
+    }
+}
+exports.SteamAchievementManager = SteamAchievementManager;
+//# sourceMappingURL=SteamAchievementManager.js.map