Enable user_stats module for achievements and leaderboards

- Uncomment user_stats module declaration and exports in lib.rs
- Add user_stats() method to Client implementation
- Update user_stats.rs to use dynamic library pattern (self.inner.lib.*)
- Update stats.rs achievement helper to use dynamic library pattern
- Add missing callback struct definitions to steamworks-sys:
  - UserStatsReceived_t, UserStatsStored_t, UserAchievementStored_t
  - UserAchievementIconFetched_t, LeaderboardFindResult_t
  - LeaderboardScoreUploaded_t, LeaderboardScoresDownloaded_t
  - GlobalAchievementPercentagesReady_t

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Jasper-Bekkers

src/lib.rs

@@ -12,7 +12,7 @@ use sys::{ESteamAPIInitResult, SteamErrMsg};
 
 use core::ffi::c_void;
 use std::collections::HashMap;
-use std::ffi::CStr;
+use std::ffi::{CStr, CString};
 use std::fmt::Debug;
 use std::sync::{Arc, Mutex};
 
@@ -33,7 +33,7 @@ pub use crate::error::*;
 // pub use crate::timeline::*;
 // pub use crate::ugc::*;
 // pub use crate::user::*;
-// pub use crate::user_stats::*;
+pub use crate::user_stats::*;
 // pub use crate::utils::*;
 
 mod app;
@@ -56,7 +56,7 @@ mod error;
 // pub mod timeline;
 // mod ugc;
 // mod user;
-// mod user_stats;
+mod user_stats;
 // mod utils;
 
 pub type SResult<T> = Result<T, SteamError>;
@@ -349,6 +349,18 @@ where
         }
     }
 
+    /// Returns an accessor to the steam user stats interface
+    pub fn user_stats(&self) -> UserStats<Manager> {
+        unsafe {
+            let us = self.inner.lib.SteamAPI_SteamUserStats_v013();
+            debug_assert!(!us.is_null());
+            UserStats {
+                user_stats: us,
+                inner: self.inner.clone(),
+            }
+        }
+    }
+
     // /// Returns an accessor to the steam friends interface
     // pub fn friends(&self) -> Friends<Manager> {
     //     unsafe {

src/user_stats.rs

@@ -21,7 +21,7 @@ impl<Manager> UserStats<Manager> {
     {
         unsafe {
             let name = CString::new(name).unwrap();
-            let api_call = sys::SteamAPI_ISteamUserStats_FindLeaderboard(
+            let api_call = self.inner.lib.SteamAPI_ISteamUserStats_FindLeaderboard(
                 self.user_stats,
                 name.as_ptr() as *const _,
             );
@@ -78,7 +78,7 @@ impl<Manager> UserStats<Manager> {
                 }
             };
 
-            let api_call = sys::SteamAPI_ISteamUserStats_FindOrCreateLeaderboard(
+            let api_call = self.inner.lib.SteamAPI_ISteamUserStats_FindOrCreateLeaderboard(
                 self.user_stats,
                 name.as_ptr() as *const _,
                 sort_method,
@@ -122,7 +122,7 @@ impl<Manager> UserStats<Manager> {
                     sys::ELeaderboardUploadScoreMethod::k_ELeaderboardUploadScoreMethodForceUpdate
                 }
             };
-            let api_call = sys::SteamAPI_ISteamUserStats_UploadLeaderboardScore(
+            let api_call = self.inner.lib.SteamAPI_ISteamUserStats_UploadLeaderboardScore(
                 self.user_stats,
                 leaderboard.0,
                 method,
@@ -177,14 +177,15 @@ impl<Manager> UserStats<Manager> {
                     sys::ELeaderboardDataRequest::k_ELeaderboardDataRequestFriends
                 }
             };
-            let api_call = sys::SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(
+            let api_call = self.inner.lib.SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(
                 self.user_stats,
                 leaderboard.0,
                 request,
                 start as _,
                 end as _,
             );
             let user_stats = self.user_stats as isize;
+            let lib = self.inner.lib.clone();
             register_call_result::<sys::LeaderboardScoresDownloaded_t, _, _>(
                 &self.inner,
                 api_call,
@@ -199,7 +200,7 @@ impl<Manager> UserStats<Manager> {
                             let mut entry: sys::LeaderboardEntry_t = std::mem::zeroed();
                             let mut details = Vec::with_capacity(max_details_len);
 
-                            sys::SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry(
+                            lib.SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry(
                                 user_stats as *mut _,
                                 v.m_hSteamLeaderboardEntries,
                                 idx,
@@ -229,7 +230,7 @@ impl<Manager> UserStats<Manager> {
         leaderboard: &Leaderboard,
     ) -> Option<LeaderboardDisplayType> {
         unsafe {
-            match sys::SteamAPI_ISteamUserStats_GetLeaderboardDisplayType(
+            match self.inner.lib.SteamAPI_ISteamUserStats_GetLeaderboardDisplayType(
                 self.user_stats,
                 leaderboard.0,
             ) {
@@ -253,7 +254,7 @@ impl<Manager> UserStats<Manager> {
         leaderboard: &Leaderboard,
     ) -> Option<LeaderboardSortMethod> {
         unsafe {
-            match sys::SteamAPI_ISteamUserStats_GetLeaderboardSortMethod(
+            match self.inner.lib.SteamAPI_ISteamUserStats_GetLeaderboardSortMethod(
                 self.user_stats,
                 leaderboard.0,
             ) {
@@ -271,7 +272,7 @@ impl<Manager> UserStats<Manager> {
     /// Returns the name of a leaderboard handle. Returns an empty string if the leaderboard handle is invalid.
     pub fn get_leaderboard_name(&self, leaderboard: &Leaderboard) -> String {
         unsafe {
-            let name = CStr::from_ptr(sys::SteamAPI_ISteamUserStats_GetLeaderboardName(
+            let name = CStr::from_ptr(self.inner.lib.SteamAPI_ISteamUserStats_GetLeaderboardName(
                 self.user_stats,
                 leaderboard.0,
             ));
@@ -282,14 +283,14 @@ impl<Manager> UserStats<Manager> {
     /// Returns the total number of entries in a leaderboard. Returns 0 if the leaderboard handle is invalid.
     pub fn get_leaderboard_entry_count(&self, leaderboard: &Leaderboard) -> i32 {
         unsafe {
-            sys::SteamAPI_ISteamUserStats_GetLeaderboardEntryCount(self.user_stats, leaderboard.0)
+            self.inner.lib.SteamAPI_ISteamUserStats_GetLeaderboardEntryCount(self.user_stats, leaderboard.0)
         }
     }
 
     /// Triggers a [`UserStatsReceived`](./struct.UserStatsReceived.html) callback.
     pub fn request_user_stats(&self, steam_user_id: u64) {
         unsafe {
-            sys::SteamAPI_ISteamUserStats_RequestUserStats(self.user_stats, steam_user_id);
+            self.inner.lib.SteamAPI_ISteamUserStats_RequestUserStats(self.user_stats, steam_user_id);
         }
     }
 
@@ -308,7 +309,7 @@ impl<Manager> UserStats<Manager> {
     {
         unsafe {
             let api_call =
-                sys::SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages(self.user_stats);
+                self.inner.lib.SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages(self.user_stats);
             register_call_result::<sys::GlobalAchievementPercentagesReady_t, _, _>(
                 &self.inner,
                 api_call,
@@ -335,7 +336,7 @@ impl<Manager> UserStats<Manager> {
     /// Requires [`request_current_stats()`](#method.request_current_stats) to have been called
     /// and a successful [`UserStatsReceived`](./struct.UserStatsReceived.html) callback processed.
     pub fn store_stats(&self) -> Result<(), ()> {
-        let success = unsafe { sys::SteamAPI_ISteamUserStats_StoreStats(self.user_stats) };
+        let success = unsafe { self.inner.lib.SteamAPI_ISteamUserStats_StoreStats(self.user_stats) };
         if success {
             Ok(())
         } else {
@@ -346,7 +347,7 @@ impl<Manager> UserStats<Manager> {
     /// Resets the current users stats and, optionally achievements.
     pub fn reset_all_stats(&self, achievements_too: bool) -> Result<(), ()> {
         let success = unsafe {
-            sys::SteamAPI_ISteamUserStats_ResetAllStats(self.user_stats, achievements_too)
+            self.inner.lib.SteamAPI_ISteamUserStats_ResetAllStats(self.user_stats, achievements_too)
         };
         if success {
             Ok(())
@@ -366,7 +367,7 @@ impl<Manager> UserStats<Manager> {
 
         let mut value: i32 = 0;
         let success = unsafe {
-            sys::SteamAPI_ISteamUserStats_GetStatInt32(
+            self.inner.lib.SteamAPI_ISteamUserStats_GetStatInt32(
                 self.user_stats,
                 name.as_ptr() as *const _,
                 &mut value,
@@ -392,7 +393,7 @@ impl<Manager> UserStats<Manager> {
         let name = CString::new(name).unwrap();
 
         let success = unsafe {
-            sys::SteamAPI_ISteamUserStats_SetStatInt32(
+            self.inner.lib.SteamAPI_ISteamUserStats_SetStatInt32(
                 self.user_stats,
                 name.as_ptr() as *const _,
                 stat,
@@ -416,7 +417,7 @@ impl<Manager> UserStats<Manager> {
 
         let mut value: f32 = 0.0;
         let success = unsafe {
-            sys::SteamAPI_ISteamUserStats_GetStatFloat(
+            self.inner.lib.SteamAPI_ISteamUserStats_GetStatFloat(
                 self.user_stats,
                 name.as_ptr() as *const _,
                 &mut value,
@@ -442,7 +443,7 @@ impl<Manager> UserStats<Manager> {
         let name = CString::new(name).unwrap();
 
         let success = unsafe {
-            sys::SteamAPI_ISteamUserStats_SetStatFloat(
+            self.inner.lib.SteamAPI_ISteamUserStats_SetStatFloat(
                 self.user_stats,
                 name.as_ptr() as *const _,
                 stat,
@@ -477,7 +478,7 @@ impl<Manager> UserStats<Manager> {
     /// *Note: Returns an error for AppId `480` (Spacewar)!*
     pub fn get_num_achievements(&self) -> Result<u32, ()> {
         unsafe {
-            let num = sys::SteamAPI_ISteamUserStats_GetNumAchievements(self.user_stats);
+            let num = self.inner.lib.SteamAPI_ISteamUserStats_GetNumAchievements(self.user_stats);
             if num != 0 {
                 Ok(num)
             } else {
@@ -498,7 +499,7 @@ impl<Manager> UserStats<Manager> {
 
         for i in 0..num {
             unsafe {
-                let name = sys::SteamAPI_ISteamUserStats_GetAchievementName(self.user_stats, i);
+                let name = self.inner.lib.SteamAPI_ISteamUserStats_GetAchievementName(self.user_stats, i);
 
                 let c_str = CStr::from_ptr(name).to_string_lossy().into_owned();
 

src/user_stats/stats.rs

@@ -33,7 +33,7 @@ impl<M> AchievementHelper<'_, M> {
     pub fn get(&self) -> Result<bool, ()> {
         unsafe {
             let mut achieved = false;
-            let success = sys::SteamAPI_ISteamUserStats_GetAchievement(
+            let success = self.parent.inner.lib.SteamAPI_ISteamUserStats_GetAchievement(
                 self.parent.user_stats,
                 self.name.as_ptr() as *const _,
                 &mut achieved as *mut _,
@@ -56,7 +56,7 @@ impl<M> AchievementHelper<'_, M> {
     /// [`UserStatsReceived`](../struct.UserStatsReceived.html).
     pub fn set(&self) -> Result<(), ()> {
         let success = unsafe {
-            sys::SteamAPI_ISteamUserStats_SetAchievement(
+            self.parent.inner.lib.SteamAPI_ISteamUserStats_SetAchievement(
                 self.parent.user_stats,
                 self.name.as_ptr() as *const _,
             )
@@ -78,7 +78,7 @@ impl<M> AchievementHelper<'_, M> {
     /// [`UserStatsReceived`](../struct.UserStatsReceived.html).
     pub fn clear(&self) -> Result<(), ()> {
         let success = unsafe {
-            sys::SteamAPI_ISteamUserStats_ClearAchievement(
+            self.parent.inner.lib.SteamAPI_ISteamUserStats_ClearAchievement(
                 self.parent.user_stats,
                 self.name.as_ptr() as *const _,
             )
@@ -120,7 +120,7 @@ impl<M> AchievementHelper<'_, M> {
     pub fn get_achievement_achieved_percent(&self) -> Result<f32, ()> {
         unsafe {
             let mut percent = 0.0;
-            let success = sys::SteamAPI_ISteamUserStats_GetAchievementAchievedPercent(
+            let success = self.parent.inner.lib.SteamAPI_ISteamUserStats_GetAchievementAchievedPercent(
                 self.parent.user_stats,
                 self.name.as_ptr() as *const _,
                 &mut percent as *mut _,
@@ -170,7 +170,7 @@ impl<M> AchievementHelper<'_, M> {
             let key_c_str = CString::new(key).expect("Failed to create c_str from key parameter");
             let ptr = key_c_str.as_ptr() as *const i8;
 
-            let str = sys::SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(
+            let str = self.parent.inner.lib.SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(
                 self.parent.user_stats,
                 self.name.as_ptr() as *const _,
                 ptr,
@@ -200,8 +200,9 @@ impl<M> AchievementHelper<'_, M> {
 
     fn internal_get_achievement_icon(&self, avoid_big_icons: bool) -> Option<(Vec<u8>, u32, u32)> {
         unsafe {
-            let utils: *mut sys::ISteamUtils = sys::SteamAPI_SteamUtils_v010();
-            let img = sys::SteamAPI_ISteamUserStats_GetAchievementIcon(
+            let lib = &self.parent.inner.lib;
+            let utils: *mut sys::ISteamUtils = lib.SteamAPI_SteamUtils_v010();
+            let img = lib.SteamAPI_ISteamUserStats_GetAchievementIcon(
                 self.parent.user_stats,
                 self.name.as_ptr() as *const _,
             );
@@ -210,14 +211,14 @@ impl<M> AchievementHelper<'_, M> {
             }
             let mut width = 0;
             let mut height = 0;
-            if !sys::SteamAPI_ISteamUtils_GetImageSize(utils, img, &mut width, &mut height) {
+            if !lib.SteamAPI_ISteamUtils_GetImageSize(utils, img, &mut width, &mut height) {
                 return None;
             }
             if avoid_big_icons && (width != 64 || height != 64) {
                 return None;
             }
             let mut dest = vec![0; (width * height * 4).try_into().unwrap()];
-            if !sys::SteamAPI_ISteamUtils_GetImageRGBA(
+            if !lib.SteamAPI_ISteamUtils_GetImageRGBA(
                 utils,
                 img,
                 dest.as_mut_ptr(),

steamworks-sys/src/lib.rs

@@ -10,3 +10,81 @@ include!("macos_bindings.rs");
 
 #[cfg(target_os = "linux")]
 include!("linux_bindings.rs");
+
+// User stats callback structures
+// These are used for receiving callback data from Steam
+
+/// Callback for RequestCurrentStats
+#[repr(C, packed(4))]
+#[derive(Copy, Clone)]
+pub struct UserStatsReceived_t {
+    pub m_nGameID: u64,
+    pub m_eResult: EResult,
+    pub m_steamIDUser: CSteamID,
+}
+
+/// Callback for StoreStats
+#[repr(C, packed(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct UserStatsStored_t {
+    pub m_nGameID: u64,
+    pub m_eResult: EResult,
+}
+
+/// Callback for achievement storage
+#[repr(C, packed(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct UserAchievementStored_t {
+    pub m_nGameID: u64,
+    pub m_bGroupAchievement: bool,
+    pub m_rgchAchievementName: [::std::os::raw::c_char; 128],
+    pub m_nCurProgress: u32,
+    pub m_nMaxProgress: u32,
+}
+
+/// Callback for achievement icon fetch
+#[repr(C, packed(4))]
+#[derive(Copy, Clone)]
+pub struct UserAchievementIconFetched_t {
+    pub m_nGameID: CGameID,
+    pub m_rgchAchievementName: [::std::os::raw::c_char; 128],
+    pub m_bAchieved: bool,
+    pub m_nIconHandle: ::std::os::raw::c_int,
+}
+
+/// Callback for FindLeaderboard
+#[repr(C, packed(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct LeaderboardFindResult_t {
+    pub m_hSteamLeaderboard: u64,
+    pub m_bLeaderboardFound: u8,
+}
+
+/// Callback for UploadLeaderboardScore
+#[repr(C, packed(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct LeaderboardScoreUploaded_t {
+    pub m_bSuccess: u8,
+    pub m_hSteamLeaderboard: u64,
+    pub m_nScore: i32,
+    pub m_bScoreChanged: u8,
+    pub m_nGlobalRankNew: ::std::os::raw::c_int,
+    pub m_nGlobalRankPrevious: ::std::os::raw::c_int,
+}
+
+/// Callback for DownloadLeaderboardEntries
+#[repr(C, packed(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct LeaderboardScoresDownloaded_t {
+    pub m_hSteamLeaderboard: u64,
+    pub m_hSteamLeaderboardEntries: u64,
+    pub m_cEntryCount: ::std::os::raw::c_int,
+}
+
+/// Callback for RequestGlobalAchievementPercentages
+#[repr(C, packed(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct GlobalAchievementPercentagesReady_t {
+    pub m_nGameID: u64,
+    pub m_eResult: EResult,
+}