Public-Mirror/gbe_fork
1
0
Fork 0
mirror of https://github.com/Detanup01/gbe_fork.git synced 2024-12-25 09:54:15 +08:00
Code Issues 1 Projects Releases Wiki Activity

bunch of scoped debug messages

Browse Source
This commit is contained in:
otavepto 2024-01-20 03:32:01 +02:00
parent 43debcbaf8
commit 45d76fbc31
17 changed files with 508 additions and 491 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
dll/dll/steam_controller.h
View File

@ -368,14 +368,14 @@ void SetOverrideMode( const char *pchMode )
// configurations inside of the game depot instead of using the Steam Workshop // configurations inside of the game depot instead of using the Steam Workshop
bool SetInputActionManifestFilePath( const char *pchInputActionManifestAbsolutePath ) bool SetInputActionManifestFilePath( const char *pchInputActionManifestAbsolutePath )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return false; return false;
} }
bool BWaitForData( bool bWaitForever, uint32 unTimeout ) bool BWaitForData( bool bWaitForever, uint32 unTimeout )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return false; return false;
} }
@ -385,7 +385,7 @@ bool BWaitForData( bool bWaitForever, uint32 unTimeout )
// SteamInput()->RunFrame() or SteamAPI_RunCallbacks() before this to update the data stream // SteamInput()->RunFrame() or SteamAPI_RunCallbacks() before this to update the data stream
bool BNewDataAvailable() bool BNewDataAvailable()
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return false; return false;
} }
@ -395,7 +395,7 @@ bool BNewDataAvailable()
// callback when you enable them // callback when you enable them
void EnableDeviceCallbacks() void EnableDeviceCallbacks()
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return; return;
} }
@ -405,7 +405,7 @@ void EnableDeviceCallbacks()
// Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks // Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks
void EnableActionEventCallbacks( SteamInputActionEventCallbackPointer pCallback ) void EnableActionEventCallbacks( SteamInputActionEventCallbackPointer pCallback )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return; return;
} }
@ -749,7 +749,7 @@ int GetDigitalActionOrigins( InputHandle_t inputHandle, InputActionSetHandle_t a
// Returns a localized string (from Steam's language setting) for the user-facing action name corresponding to the specified handle // Returns a localized string (from Steam's language setting) for the user-facing action name corresponding to the specified handle
const char *GetStringForDigitalActionName( InputDigitalActionHandle_t eActionHandle ) const char *GetStringForDigitalActionName( InputDigitalActionHandle_t eActionHandle )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return "Button String"; return "Button String";
} }
@ -922,7 +922,7 @@ void Legacy_TriggerRepeatedHapticPulse( InputHandle_t inputHandle, ESteamControl
// Send a haptic pulse, works on Steam Deck and Steam Controller devices // Send a haptic pulse, works on Steam Deck and Steam Controller devices
void TriggerSimpleHapticEvent( InputHandle_t inputHandle, EControllerHapticLocation eHapticLocation, uint8 nIntensity, char nGainDB, uint8 nOtherIntensity, char nOtherGainDB ) void TriggerSimpleHapticEvent( InputHandle_t inputHandle, EControllerHapticLocation eHapticLocation, uint8 nIntensity, char nGainDB, uint8 nOtherIntensity, char nOtherGainDB )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
} }
// Tigger a vibration event on supported controllers. // Tigger a vibration event on supported controllers.
@ -952,7 +952,7 @@ void TriggerVibration( ControllerHandle_t controllerHandle, unsigned short usLef
// Trigger a vibration event on supported controllers including Xbox trigger impulse rumble - Steam will translate these commands into haptic pulses for Steam Controllers // Trigger a vibration event on supported controllers including Xbox trigger impulse rumble - Steam will translate these commands into haptic pulses for Steam Controllers
void TriggerVibrationExtended( InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed, unsigned short usLeftTriggerSpeed, unsigned short usRightTriggerSpeed ) void TriggerVibrationExtended( InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed, unsigned short usLeftTriggerSpeed, unsigned short usRightTriggerSpeed )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
TriggerVibration(inputHandle, usLeftSpeed, usRightSpeed); TriggerVibration(inputHandle, usLeftSpeed, usRightSpeed);
//TODO trigger impulse rumbles //TODO trigger impulse rumbles
} }
@ -1026,7 +1026,7 @@ const char *GetStringForActionOrigin( EInputActionOrigin eOrigin )
// Returns a localized string (from Steam's language setting) for the user-facing action name corresponding to the specified handle // Returns a localized string (from Steam's language setting) for the user-facing action name corresponding to the specified handle
const char *GetStringForAnalogActionName( InputAnalogActionHandle_t eActionHandle ) const char *GetStringForAnalogActionName( InputAnalogActionHandle_t eActionHandle )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return "Button String"; return "Button String";
} }
@ -1119,7 +1119,7 @@ const char *GetGlyphForActionOrigin( EInputActionOrigin eOrigin )
// Get a local path to a PNG file for the provided origin's glyph. // Get a local path to a PNG file for the provided origin's glyph.
const char *GetGlyphPNGForActionOrigin( EInputActionOrigin eOrigin, ESteamInputGlyphSize eSize, uint32 unFlags ) const char *GetGlyphPNGForActionOrigin( EInputActionOrigin eOrigin, ESteamInputGlyphSize eSize, uint32 unFlags )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return GetGlyphForActionOrigin(eOrigin); return GetGlyphForActionOrigin(eOrigin);
} }
@ -1127,7 +1127,7 @@ const char *GetGlyphPNGForActionOrigin( EInputActionOrigin eOrigin, ESteamInputG
// Get a local path to a SVG file for the provided origin's glyph. // Get a local path to a SVG file for the provided origin's glyph.
const char *GetGlyphSVGForActionOrigin( EInputActionOrigin eOrigin, uint32 unFlags ) const char *GetGlyphSVGForActionOrigin( EInputActionOrigin eOrigin, uint32 unFlags )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
//TODO SteamInput005 //TODO SteamInput005
return ""; return "";
} }
@ -1210,14 +1210,14 @@ uint32 GetRemotePlaySessionID( InputHandle_t inputHandle )
// Note: user can override the settings from the Steamworks Partner site so the returned values may not exactly match your default configuration // Note: user can override the settings from the Steamworks Partner site so the returned values may not exactly match your default configuration
uint16 GetSessionInputConfigurationSettings() uint16 GetSessionInputConfigurationSettings()
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
return 0; return 0;
} }
// Set the trigger effect for a DualSense controller // Set the trigger effect for a DualSense controller
void SetDualSenseTriggerEffect( InputHandle_t inputHandle, const ScePadTriggerEffectParam *pParam ) void SetDualSenseTriggerEffect( InputHandle_t inputHandle, const ScePadTriggerEffectParam *pParam )
{ {
PRINT_DEBUG("TODO %s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_Controller::%s\n", __FUNCTION__);
} }
void RunCallbacks() void RunCallbacks()

96
dll/dll/steam_inventory.h
View File

@ -92,7 +92,7 @@ struct Steam_Inventory_Requests *get_inventory_result(SteamInventoryResult_t res
void read_items_db() void read_items_db()
{ {
std::string items_db_path = Local_Storage::get_game_settings_path() + items_user_file; std::string items_db_path = Local_Storage::get_game_settings_path() + items_user_file;
PRINT_DEBUG("Items file path: %s\n", items_db_path.c_str()); PRINT_DEBUG("Steam_Inventory::Items file path: %s\n", items_db_path.c_str());
local_storage->load_json(items_db_path, defined_items); local_storage->load_json(items_db_path, defined_items);
} }
@ -103,7 +103,7 @@ void read_inventory_db()
{ {
// Try to load a default one // Try to load a default one
std::string items_db_path = Local_Storage::get_game_settings_path() + items_default_file; std::string items_db_path = Local_Storage::get_game_settings_path() + items_default_file;
PRINT_DEBUG("Default items file path: %s\n", items_db_path.c_str()); PRINT_DEBUG("Steam_Inventory::Default items file path: %s\n", items_db_path.c_str());
local_storage->load_json(items_db_path, user_items); local_storage->load_json(items_db_path, user_items);
} }
} }
@ -156,7 +156,7 @@ Steam_Inventory(class Settings *settings, class SteamCallResults *callback_resul
STEAM_METHOD_DESC(Find out the status of an asynchronous inventory result handle.) STEAM_METHOD_DESC(Find out the status of an asynchronous inventory result handle.)
EResult GetResultStatus( SteamInventoryResult_t resultHandle ) EResult GetResultStatus( SteamInventoryResult_t resultHandle )
{ {
PRINT_DEBUG("GetResultStatus\n"); PRINT_DEBUG("Steam_Inventory::GetResultStatus\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Steam_Inventory_Requests *request = get_inventory_result(resultHandle); struct Steam_Inventory_Requests *request = get_inventory_result(resultHandle);
if (!request) return k_EResultInvalidParam; if (!request) return k_EResultInvalidParam;
@ -172,7 +172,7 @@ bool GetResultItems( SteamInventoryResult_t resultHandle,
STEAM_OUT_ARRAY_COUNT( punOutItemsArraySize,Output array) SteamItemDetails_t *pOutItemsArray, STEAM_OUT_ARRAY_COUNT( punOutItemsArraySize,Output array) SteamItemDetails_t *pOutItemsArray,
uint32 *punOutItemsArraySize ) uint32 *punOutItemsArraySize )
{ {
PRINT_DEBUG("GetResultItems\n"); PRINT_DEBUG("Steam_Inventory::GetResultItems\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Steam_Inventory_Requests *request = get_inventory_result(resultHandle); struct Steam_Inventory_Requests *request = get_inventory_result(resultHandle);
if (!request) return false; if (!request) return false;
@ -235,7 +235,7 @@ bool GetResultItems( SteamInventoryResult_t resultHandle,
} }
} }
PRINT_DEBUG("GetResultItems good\n"); PRINT_DEBUG("Steam_Inventory::GetResultItems good\n");
return true; return true;
} }
@ -257,7 +257,7 @@ bool GetResultItemProperty( SteamInventoryResult_t resultHandle,
const char *pchPropertyName, const char *pchPropertyName,
STEAM_OUT_STRING_COUNT( punValueBufferSizeOut ) char *pchValueBuffer, uint32 *punValueBufferSizeOut ) STEAM_OUT_STRING_COUNT( punValueBufferSizeOut ) char *pchValueBuffer, uint32 *punValueBufferSizeOut )
{ {
PRINT_DEBUG("GetResultItemProperty\n"); PRINT_DEBUG("Steam_Inventory::GetResultItemProperty\n");
//TODO //TODO
return false; return false;
} }
@ -268,7 +268,7 @@ bool GetResultItemProperty( SteamInventoryResult_t resultHandle,
STEAM_METHOD_DESC(Returns the server time at which the result was generated. Compare against the value of IClientUtils::GetServerRealTime() to determine age.) STEAM_METHOD_DESC(Returns the server time at which the result was generated. Compare against the value of IClientUtils::GetServerRealTime() to determine age.)
uint32 GetResultTimestamp( SteamInventoryResult_t resultHandle ) uint32 GetResultTimestamp( SteamInventoryResult_t resultHandle )
{ {
PRINT_DEBUG("GetResultTimestamp\n"); PRINT_DEBUG("Steam_Inventory::GetResultTimestamp\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Steam_Inventory_Requests *request = get_inventory_result(resultHandle); struct Steam_Inventory_Requests *request = get_inventory_result(resultHandle);
if (!request || !request->result_done()) return 0; if (!request || !request->result_done()) return 0;
@ -282,7 +282,7 @@ uint32 GetResultTimestamp( SteamInventoryResult_t resultHandle )
STEAM_METHOD_DESC(Returns true if the result belongs to the target steam ID or false if the result does not. This is important when using DeserializeResult to verify that a remote player is not pretending to have a different users inventory.) STEAM_METHOD_DESC(Returns true if the result belongs to the target steam ID or false if the result does not. This is important when using DeserializeResult to verify that a remote player is not pretending to have a different users inventory.)
bool CheckResultSteamID( SteamInventoryResult_t resultHandle, CSteamID steamIDExpected ) bool CheckResultSteamID( SteamInventoryResult_t resultHandle, CSteamID steamIDExpected )
{ {
PRINT_DEBUG("CheckResultSteamID %llu\n", steamIDExpected.ConvertToUint64()); PRINT_DEBUG("Steam_Inventory::CheckResultSteamID %llu\n", steamIDExpected.ConvertToUint64());
//TODO //TODO
return true; return true;
} }
@ -292,7 +292,7 @@ bool CheckResultSteamID( SteamInventoryResult_t resultHandle, CSteamID steamIDEx
STEAM_METHOD_DESC(Destroys a result handle and frees all associated memory.) STEAM_METHOD_DESC(Destroys a result handle and frees all associated memory.)
void DestroyResult( SteamInventoryResult_t resultHandle ) void DestroyResult( SteamInventoryResult_t resultHandle )
{ {
PRINT_DEBUG("DestroyResult\n"); PRINT_DEBUG("Steam_Inventory::DestroyResult\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto request = std::find_if(inventory_requests.begin(), inventory_requests.end(), [&resultHandle](struct Steam_Inventory_Requests const& item) { return item.inventory_result == resultHandle; }); auto request = std::find_if(inventory_requests.begin(), inventory_requests.end(), [&resultHandle](struct Steam_Inventory_Requests const& item) { return item.inventory_result == resultHandle; });
if (inventory_requests.end() == request) if (inventory_requests.end() == request)
@ -316,7 +316,7 @@ void DestroyResult( SteamInventoryResult_t resultHandle )
STEAM_METHOD_DESC(Captures the entire state of the current users Steam inventory.) STEAM_METHOD_DESC(Captures the entire state of the current users Steam inventory.)
bool GetAllItems( SteamInventoryResult_t *pResultHandle ) bool GetAllItems( SteamInventoryResult_t *pResultHandle )
{ {
PRINT_DEBUG("GetAllItems\n"); PRINT_DEBUG("Steam_Inventory::GetAllItems\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Steam_Inventory_Requests* request = new_inventory_result(); struct Steam_Inventory_Requests* request = new_inventory_result();
@ -338,7 +338,7 @@ bool GetAllItems( SteamInventoryResult_t *pResultHandle )
STEAM_METHOD_DESC(Captures the state of a subset of the current users Steam inventory identified by an array of item instance IDs.) STEAM_METHOD_DESC(Captures the state of a subset of the current users Steam inventory identified by an array of item instance IDs.)
bool GetItemsByID( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT( unCountInstanceIDs ) const SteamItemInstanceID_t *pInstanceIDs, uint32 unCountInstanceIDs ) bool GetItemsByID( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT( unCountInstanceIDs ) const SteamItemInstanceID_t *pInstanceIDs, uint32 unCountInstanceIDs )
{ {
PRINT_DEBUG("GetItemsByID\n"); PRINT_DEBUG("Steam_Inventory::GetItemsByID\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pResultHandle) { if (pResultHandle) {
struct Steam_Inventory_Requests *request = new_inventory_result(false, pInstanceIDs, unCountInstanceIDs); struct Steam_Inventory_Requests *request = new_inventory_result(false, pInstanceIDs, unCountInstanceIDs);
@ -368,7 +368,7 @@ bool GetItemsByID( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT( unC
// an hour has elapsed. See DeserializeResult for expiration handling. // an hour has elapsed. See DeserializeResult for expiration handling.
bool SerializeResult( SteamInventoryResult_t resultHandle, STEAM_OUT_BUFFER_COUNT(punOutBufferSize) void *pOutBuffer, uint32 *punOutBufferSize ) bool SerializeResult( SteamInventoryResult_t resultHandle, STEAM_OUT_BUFFER_COUNT(punOutBufferSize) void *pOutBuffer, uint32 *punOutBufferSize )
{ {
PRINT_DEBUG("SerializeResult %i\n", resultHandle); PRINT_DEBUG("Steam_Inventory::SerializeResult %i\n", resultHandle);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
//TODO //TODO
struct Steam_Inventory_Requests *request = get_inventory_result(resultHandle); struct Steam_Inventory_Requests *request = get_inventory_result(resultHandle);
@ -379,7 +379,7 @@ bool SerializeResult( SteamInventoryResult_t resultHandle, STEAM_OUT_BUFFER_COUN
memset(buffer, 0x5F, sizeof(buffer)); memset(buffer, 0x5F, sizeof(buffer));
if (!punOutBufferSize) return false; if (!punOutBufferSize) return false;
PRINT_DEBUG("Size %u\n", *punOutBufferSize); PRINT_DEBUG(" Size %u\n", *punOutBufferSize);
if (!pOutBuffer) { if (!pOutBuffer) {
*punOutBufferSize = sizeof(buffer); *punOutBufferSize = sizeof(buffer);
return true; return true;
@ -414,7 +414,7 @@ bool SerializeResult( SteamInventoryResult_t resultHandle, STEAM_OUT_BUFFER_COUN
// could challenge the player with expired data to send an updated result set. // could challenge the player with expired data to send an updated result set.
bool DeserializeResult( SteamInventoryResult_t *pOutResultHandle, STEAM_BUFFER_COUNT(punOutBufferSize) const void *pBuffer, uint32 unBufferSize, bool bRESERVED_MUST_BE_FALSE) bool DeserializeResult( SteamInventoryResult_t *pOutResultHandle, STEAM_BUFFER_COUNT(punOutBufferSize) const void *pBuffer, uint32 unBufferSize, bool bRESERVED_MUST_BE_FALSE)
{ {
PRINT_DEBUG("DeserializeResult\n"); PRINT_DEBUG("Steam_Inventory::DeserializeResult\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
//TODO //TODO
if (pOutResultHandle) { if (pOutResultHandle) {
@ -439,7 +439,7 @@ bool DeserializeResult( SteamInventoryResult_t *pOutResultHandle, STEAM_BUFFER_C
// describe the quantity of each item to generate. // describe the quantity of each item to generate.
bool GenerateItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, STEAM_ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength ) bool GenerateItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, STEAM_ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength )
{ {
PRINT_DEBUG("GenerateItems\n"); PRINT_DEBUG("Steam_Inventory::GenerateItems\n");
return false; return false;
} }
@ -451,7 +451,7 @@ bool GenerateItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unA
STEAM_METHOD_DESC(GrantPromoItems() checks the list of promotional items for which the user may be eligible and grants the items (one time only).) STEAM_METHOD_DESC(GrantPromoItems() checks the list of promotional items for which the user may be eligible and grants the items (one time only).)
bool GrantPromoItems( SteamInventoryResult_t *pResultHandle ) bool GrantPromoItems( SteamInventoryResult_t *pResultHandle )
{ {
PRINT_DEBUG("GrantPromoItems\n"); PRINT_DEBUG("Steam_Inventory::GrantPromoItems\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Steam_Inventory_Requests* request = new_inventory_result(false); struct Steam_Inventory_Requests* request = new_inventory_result(false);
@ -467,7 +467,7 @@ bool GrantPromoItems( SteamInventoryResult_t *pResultHandle )
// showing a specific promo item to the user. // showing a specific promo item to the user.
bool AddPromoItem( SteamInventoryResult_t *pResultHandle, SteamItemDef_t itemDef ) bool AddPromoItem( SteamInventoryResult_t *pResultHandle, SteamItemDef_t itemDef )
{ {
PRINT_DEBUG("AddPromoItem\n"); PRINT_DEBUG("Steam_Inventory::AddPromoItem\n");
//TODO //TODO
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Steam_Inventory_Requests* request = new_inventory_result(false); struct Steam_Inventory_Requests* request = new_inventory_result(false);
@ -479,7 +479,7 @@ bool AddPromoItem( SteamInventoryResult_t *pResultHandle, SteamItemDef_t itemDef
bool AddPromoItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, uint32 unArrayLength ) bool AddPromoItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, uint32 unArrayLength )
{ {
PRINT_DEBUG("AddPromoItems\n"); PRINT_DEBUG("Steam_Inventory::AddPromoItems\n");
//TODO //TODO
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Steam_Inventory_Requests* request = new_inventory_result(false); struct Steam_Inventory_Requests* request = new_inventory_result(false);
@ -496,7 +496,7 @@ bool AddPromoItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unA
STEAM_METHOD_DESC(ConsumeItem() removes items from the inventory permanently.) STEAM_METHOD_DESC(ConsumeItem() removes items from the inventory permanently.)
bool ConsumeItem( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity ) bool ConsumeItem( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity )
{ {
PRINT_DEBUG("ConsumeItem %llu %u\n", itemConsume, unQuantity); PRINT_DEBUG("Steam_Inventory::ConsumeItem %llu %u\n", itemConsume, unQuantity);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto it = user_items.find(std::to_string(itemConsume)); auto it = user_items.find(std::to_string(itemConsume));
@ -504,7 +504,7 @@ bool ConsumeItem( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t i
try try
{ {
uint32 current = it->get<int>(); uint32 current = it->get<int>();
PRINT_DEBUG("ConsumeItem previous %u\n", current); PRINT_DEBUG("Steam_Inventory::ConsumeItem previous %u\n", current);
if (current < unQuantity) unQuantity = current; if (current < unQuantity) unQuantity = current;
uint32 result = current - unQuantity; uint32 result = current - unQuantity;
if (result == 0) { if (result == 0) {
@ -540,7 +540,7 @@ bool ExchangeItems( SteamInventoryResult_t *pResultHandle,
STEAM_ARRAY_COUNT(unArrayGenerateLength) const SteamItemDef_t *pArrayGenerate, STEAM_ARRAY_COUNT(unArrayGenerateLength) const uint32 *punArrayGenerateQuantity, uint32 unArrayGenerateLength, STEAM_ARRAY_COUNT(unArrayGenerateLength) const SteamItemDef_t *pArrayGenerate, STEAM_ARRAY_COUNT(unArrayGenerateLength) const uint32 *punArrayGenerateQuantity, uint32 unArrayGenerateLength,
STEAM_ARRAY_COUNT(unArrayDestroyLength) const SteamItemInstanceID_t *pArrayDestroy, STEAM_ARRAY_COUNT(unArrayDestroyLength) const uint32 *punArrayDestroyQuantity, uint32 unArrayDestroyLength ) STEAM_ARRAY_COUNT(unArrayDestroyLength) const SteamItemInstanceID_t *pArrayDestroy, STEAM_ARRAY_COUNT(unArrayDestroyLength) const uint32 *punArrayDestroyQuantity, uint32 unArrayDestroyLength )
{ {
PRINT_DEBUG("ExchangeItems\n"); PRINT_DEBUG("Steam_Inventory::ExchangeItems\n");
return false; return false;
} }
@ -552,7 +552,7 @@ bool ExchangeItems( SteamInventoryResult_t *pResultHandle,
// two, pass k_SteamItemInstanceIDInvalid for itemIdDest and a new item will be generated. // two, pass k_SteamItemInstanceIDInvalid for itemIdDest and a new item will be generated.
bool TransferItemQuantity( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest ) bool TransferItemQuantity( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest )
{ {
PRINT_DEBUG("TransferItemQuantity\n"); PRINT_DEBUG("Steam_Inventory::TransferItemQuantity\n");
return false; return false;
} }
@ -565,7 +565,7 @@ bool TransferItemQuantity( SteamInventoryResult_t *pResultHandle, SteamItemInsta
STEAM_METHOD_DESC( Deprecated method. Playtime accounting is performed on the Steam servers. ) STEAM_METHOD_DESC( Deprecated method. Playtime accounting is performed on the Steam servers. )
void SendItemDropHeartbeat() void SendItemDropHeartbeat()
{ {
PRINT_DEBUG("SendItemDropHeartbeat\n"); PRINT_DEBUG("Steam_Inventory::SendItemDropHeartbeat\n");
} }
@ -581,7 +581,7 @@ void SendItemDropHeartbeat()
STEAM_METHOD_DESC(Playtime credit must be consumed and turned into item drops by your game.) STEAM_METHOD_DESC(Playtime credit must be consumed and turned into item drops by your game.)
bool TriggerItemDrop( SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition ) bool TriggerItemDrop( SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition )
{ {
PRINT_DEBUG("TriggerItemDrop %p %i\n", pResultHandle, dropListDefinition); PRINT_DEBUG("Steam_Inventory::TriggerItemDrop %p %i\n", pResultHandle, dropListDefinition);
//TODO: if gameserver return false //TODO: if gameserver return false
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Steam_Inventory_Requests* request = new_inventory_result(false); struct Steam_Inventory_Requests* request = new_inventory_result(false);
@ -598,7 +598,7 @@ bool TradeItems( SteamInventoryResult_t *pResultHandle, CSteamID steamIDTradePar
STEAM_ARRAY_COUNT(nArrayGiveLength) const SteamItemInstanceID_t *pArrayGive, STEAM_ARRAY_COUNT(nArrayGiveLength) const uint32 *pArrayGiveQuantity, uint32 nArrayGiveLength, STEAM_ARRAY_COUNT(nArrayGiveLength) const SteamItemInstanceID_t *pArrayGive, STEAM_ARRAY_COUNT(nArrayGiveLength) const uint32 *pArrayGiveQuantity, uint32 nArrayGiveLength,
STEAM_ARRAY_COUNT(nArrayGetLength) const SteamItemInstanceID_t *pArrayGet, STEAM_ARRAY_COUNT(nArrayGetLength) const uint32 *pArrayGetQuantity, uint32 nArrayGetLength ) STEAM_ARRAY_COUNT(nArrayGetLength) const SteamItemInstanceID_t *pArrayGet, STEAM_ARRAY_COUNT(nArrayGetLength) const uint32 *pArrayGetQuantity, uint32 nArrayGetLength )
{ {
PRINT_DEBUG("TradeItems\n"); PRINT_DEBUG("Steam_Inventory::TradeItems\n");
return false; return false;
} }
@ -621,7 +621,7 @@ bool TradeItems( SteamInventoryResult_t *pResultHandle, CSteamID steamIDTradePar
STEAM_METHOD_DESC(LoadItemDefinitions triggers the automatic load and refresh of item definitions.) STEAM_METHOD_DESC(LoadItemDefinitions triggers the automatic load and refresh of item definitions.)
bool LoadItemDefinitions() bool LoadItemDefinitions()
{ {
PRINT_DEBUG("LoadItemDefinitions\n"); PRINT_DEBUG("Steam_Inventory::LoadItemDefinitions\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!item_definitions_loaded) { if (!item_definitions_loaded) {
@ -643,12 +643,12 @@ bool GetItemDefinitionIDs(
STEAM_OUT_ARRAY_COUNT(punItemDefIDsArraySize,List of item definition IDs) SteamItemDef_t *pItemDefIDs, STEAM_OUT_ARRAY_COUNT(punItemDefIDsArraySize,List of item definition IDs) SteamItemDef_t *pItemDefIDs,
STEAM_DESC(Size of array is passed in and actual size used is returned in this param) uint32 *punItemDefIDsArraySize ) STEAM_DESC(Size of array is passed in and actual size used is returned in this param) uint32 *punItemDefIDsArraySize )
{ {
PRINT_DEBUG("GetItemDefinitionIDs %p\n", pItemDefIDs); PRINT_DEBUG("Steam_Inventory::GetItemDefinitionIDs %p\n", pItemDefIDs);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!punItemDefIDsArraySize) if (!punItemDefIDsArraySize)
return false; return false;
PRINT_DEBUG("array_size %u\n", *punItemDefIDsArraySize); PRINT_DEBUG(" array_size %u\n", *punItemDefIDsArraySize);
if (!item_definitions_loaded) if (!item_definitions_loaded)
return false; return false;
@ -681,7 +681,7 @@ bool GetItemDefinitionIDs(
bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPropertyName, bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPropertyName,
STEAM_OUT_STRING_COUNT(punValueBufferSizeOut) char *pchValueBuffer, uint32 *punValueBufferSizeOut ) STEAM_OUT_STRING_COUNT(punValueBufferSizeOut) char *pchValueBuffer, uint32 *punValueBufferSizeOut )
{ {
PRINT_DEBUG("GetItemDefinitionProperty %i %s\n", iDefinition, pchPropertyName); PRINT_DEBUG("Steam_Inventory::GetItemDefinitionProperty %i %s\n", iDefinition, pchPropertyName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto item = defined_items.find(std::to_string(iDefinition)); auto item = defined_items.find(std::to_string(iDefinition));
@ -703,7 +703,7 @@ bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPrope
{ {
pchPropertyName = ""; pchPropertyName = "";
*punValueBufferSizeOut = 0; *punValueBufferSizeOut = 0;
PRINT_DEBUG("Error, item: %d, attr: %s is not a string!", iDefinition, pchPropertyName); PRINT_DEBUG(" Error, item: %d, attr: %s is not a string!", iDefinition, pchPropertyName);
return true; return true;
} }
if (pchValueBuffer != nullptr) if (pchValueBuffer != nullptr)
@ -728,7 +728,7 @@ bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPrope
else else
{ {
*punValueBufferSizeOut = 0; *punValueBufferSizeOut = 0;
PRINT_DEBUG("Attr %s not found for item %d\n", pchPropertyName, iDefinition); PRINT_DEBUG(" Attr %s not found for item %d\n", pchPropertyName, iDefinition);
return false; return false;
} }
} }
@ -779,7 +779,7 @@ bool GetItemDefinitionProperty( SteamItemDef_t iDefinition, const char *pchPrope
STEAM_CALL_RESULT( SteamInventoryEligiblePromoItemDefIDs_t ) STEAM_CALL_RESULT( SteamInventoryEligiblePromoItemDefIDs_t )
SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs( CSteamID steamID ) SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs( CSteamID steamID )
{ {
PRINT_DEBUG("RequestEligiblePromoItemDefinitionsIDs\n"); PRINT_DEBUG("Steam_Inventory::RequestEligiblePromoItemDefinitionsIDs\n");
return 0; return 0;
} }
@ -792,7 +792,7 @@ bool GetEligiblePromoItemDefinitionIDs(
STEAM_OUT_ARRAY_COUNT(punItemDefIDsArraySize,List of item definition IDs) SteamItemDef_t *pItemDefIDs, STEAM_OUT_ARRAY_COUNT(punItemDefIDsArraySize,List of item definition IDs) SteamItemDef_t *pItemDefIDs,
STEAM_DESC(Size of array is passed in and actual size used is returned in this param) uint32 *punItemDefIDsArraySize ) STEAM_DESC(Size of array is passed in and actual size used is returned in this param) uint32 *punItemDefIDsArraySize )
{ {
PRINT_DEBUG("GetEligiblePromoItemDefinitionIDs\n"); PRINT_DEBUG("Steam_Inventory::GetEligiblePromoItemDefinitionIDs\n");
return false; return false;
} }
@ -805,7 +805,7 @@ bool GetEligiblePromoItemDefinitionIDs(
STEAM_CALL_RESULT( SteamInventoryStartPurchaseResult_t ) STEAM_CALL_RESULT( SteamInventoryStartPurchaseResult_t )
SteamAPICall_t StartPurchase( STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, STEAM_ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength ) SteamAPICall_t StartPurchase( STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, STEAM_ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength )
{ {
PRINT_DEBUG("StartPurchase\n"); PRINT_DEBUG("Steam_Inventory::StartPurchase\n");
return 0; return 0;
} }
@ -814,7 +814,7 @@ SteamAPICall_t StartPurchase( STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDe
STEAM_CALL_RESULT( SteamInventoryRequestPricesResult_t ) STEAM_CALL_RESULT( SteamInventoryRequestPricesResult_t )
SteamAPICall_t RequestPrices() SteamAPICall_t RequestPrices()
{ {
PRINT_DEBUG("RequestPrices\n"); PRINT_DEBUG("Steam_Inventory::RequestPrices\n");
SteamInventoryRequestPricesResult_t data; SteamInventoryRequestPricesResult_t data;
data.m_result = k_EResultOK; data.m_result = k_EResultOK;
memcpy(data.m_rgchCurrency, "USD", 4); memcpy(data.m_rgchCurrency, "USD", 4);
@ -825,7 +825,7 @@ SteamAPICall_t RequestPrices()
// Returns the number of items with prices. Need to call RequestPrices() first. // Returns the number of items with prices. Need to call RequestPrices() first.
uint32 GetNumItemsWithPrices() uint32 GetNumItemsWithPrices()
{ {
PRINT_DEBUG("GetNumItemsWithPrices\n"); PRINT_DEBUG("Steam_Inventory::GetNumItemsWithPrices\n");
return 0; return 0;
} }
@ -834,7 +834,7 @@ bool GetItemsWithPrices( STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(
STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pPrices, List of prices for the given item defs) uint64 *pBasePrices, STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pPrices, List of prices for the given item defs) uint64 *pBasePrices,
uint32 unArrayLength ) uint32 unArrayLength )
{ {
PRINT_DEBUG("GetItemsWithPrices\n"); PRINT_DEBUG("Steam_Inventory::GetItemsWithPrices\n");
return false; return false;
} }
@ -844,13 +844,13 @@ bool GetItemsWithPrices( STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(
STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pPrices, List of prices for the given item defs) uint64 *pPrices, STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(pPrices, List of prices for the given item defs) uint64 *pPrices,
uint32 unArrayLength ) uint32 unArrayLength )
{ {
PRINT_DEBUG("GetItemsWithPrices old\n"); PRINT_DEBUG("Steam_Inventory::GetItemsWithPrices old\n");
return GetItemsWithPrices(pArrayItemDefs, pPrices, NULL, unArrayLength); return GetItemsWithPrices(pArrayItemDefs, pPrices, NULL, unArrayLength);
} }
bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pCurrentPrice, uint64 *pBasePrice ) bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pCurrentPrice, uint64 *pBasePrice )
{ {
PRINT_DEBUG("GetItemPrice\n"); PRINT_DEBUG("Steam_Inventory::GetItemPrice\n");
return false; return false;
} }
@ -858,7 +858,7 @@ bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pCurrentPrice, uint64 *pB
// Returns false if there is no price stored for the item definition. // Returns false if there is no price stored for the item definition.
bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pPrice ) bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pPrice )
{ {
PRINT_DEBUG("GetItemPrice old\n"); PRINT_DEBUG("Steam_Inventory::GetItemPrice old\n");
return GetItemPrice(iDefinition, pPrice, NULL); return GetItemPrice(iDefinition, pPrice, NULL);
} }
@ -866,52 +866,52 @@ bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pPrice )
// Create a request to update properties on items // Create a request to update properties on items
SteamInventoryUpdateHandle_t StartUpdateProperties() SteamInventoryUpdateHandle_t StartUpdateProperties()
{ {
PRINT_DEBUG("StartUpdateProperties\n"); PRINT_DEBUG("Steam_Inventory::StartUpdateProperties\n");
return 0; return 0;
} }
// Remove the property on the item // Remove the property on the item
bool RemoveProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName ) bool RemoveProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName )
{ {
PRINT_DEBUG("RemoveProperty\n"); PRINT_DEBUG("Steam_Inventory::RemoveProperty\n");
return false; return false;
} }
// Accessor methods to set properties on items // Accessor methods to set properties on items
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, const char *pchPropertyValue ) bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, const char *pchPropertyValue )
{ {
PRINT_DEBUG("SetProperty\n"); PRINT_DEBUG("Steam_Inventory::SetProperty\n");
return false; return false;
} }
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, bool bValue ) bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, bool bValue )
{ {
PRINT_DEBUG("SetProperty\n"); PRINT_DEBUG("Steam_Inventory::SetProperty\n");
return false; return false;
} }
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, int64 nValue ) bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, int64 nValue )
{ {
PRINT_DEBUG("SetProperty\n"); PRINT_DEBUG("Steam_Inventory::SetProperty\n");
return false; return false;
} }
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, float flValue ) bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, float flValue )
{ {
PRINT_DEBUG("SetProperty\n"); PRINT_DEBUG("Steam_Inventory::SetProperty\n");
return false; return false;
} }
// Submit the update request by handle // Submit the update request by handle
bool SubmitUpdateProperties( SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle ) bool SubmitUpdateProperties( SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle )
{ {
PRINT_DEBUG("SubmitUpdateProperties\n"); PRINT_DEBUG("Steam_Inventory::SubmitUpdateProperties\n");
return false; return false;
} }
bool InspectItem( SteamInventoryResult_t *pResultHandle, const char *pchItemToken ) bool InspectItem( SteamInventoryResult_t *pResultHandle, const char *pchItemToken )
{ {
PRINT_DEBUG("InspectItem\n"); PRINT_DEBUG("Steam_Inventory::InspectItem\n");
return false; return false;
} }

164
dll/dll/steam_matchmaking.h
View File

@ -123,11 +123,11 @@ Lobby *get_lobby(CSteamID id)
void send_lobby_data() void send_lobby_data()
{ {
PRINT_DEBUG("Sending lobbies %zu\n", lobbies.size()); PRINT_DEBUG("Steam_MatchMaking::Sending lobbies %zu\n", lobbies.size());
for(auto & l: lobbies) { for(auto & l: lobbies) {
if (get_lobby_member(&l, settings->get_local_steam_id()) && l.owner() == settings->get_local_steam_id().ConvertToUint64() && !l.deleted()) { if (get_lobby_member(&l, settings->get_local_steam_id()) && l.owner() == settings->get_local_steam_id().ConvertToUint64() && !l.deleted()) {
PRINT_DEBUG("Sending lobby " "%" PRIu64 "\n", l.room_id()); PRINT_DEBUG("Steam_MatchMaking::Sending lobby " "%" PRIu64 "\n", l.room_id());
Common_Message msg = Common_Message(); Common_Message msg = Common_Message();
msg.set_source_id(settings->get_local_steam_id().ConvertToUint64()); msg.set_source_id(settings->get_local_steam_id().ConvertToUint64());
msg.set_allocated_lobby(new Lobby(l)); msg.set_allocated_lobby(new Lobby(l));
@ -138,7 +138,7 @@ void send_lobby_data()
void trigger_lobby_dataupdate(CSteamID lobby, CSteamID member, bool success, double cb_timeout=0.005, bool send_changed_lobby=true) void trigger_lobby_dataupdate(CSteamID lobby, CSteamID member, bool success, double cb_timeout=0.005, bool send_changed_lobby=true)
{ {
PRINT_DEBUG("Lobby dataupdate %llu %llu\n", lobby.ConvertToUint64(), member.ConvertToUint64()); PRINT_DEBUG("Steam_MatchMaking::Lobby dataupdate %llu %llu\n", lobby.ConvertToUint64(), member.ConvertToUint64());
LobbyDataUpdate_t data; LobbyDataUpdate_t data;
memset(&data, 0, sizeof(data)); memset(&data, 0, sizeof(data));
@ -264,7 +264,7 @@ void remove_lobbies()
auto g = std::begin(lobbies); auto g = std::begin(lobbies);
while (g != std::end(lobbies)) { while (g != std::end(lobbies)) {
if (g->members().size() == 0 || (g->deleted() && (g->time_deleted() + LOBBY_DELETED_TIMEOUT < current_time))) { if (g->members().size() == 0 || (g->deleted() && (g->time_deleted() + LOBBY_DELETED_TIMEOUT < current_time))) {
PRINT_DEBUG("REMOVING LOBBY " "%" PRIu64 "\n", g->room_id()); PRINT_DEBUG("Steam_MatchMaking::REMOVING LOBBY " "%" PRIu64 "\n", g->room_id());
self_lobby_member_data.erase(g->room_id()); self_lobby_member_data.erase(g->room_id());
g = lobbies.erase(g); g = lobbies.erase(g);
} else { } else {
@ -289,7 +289,7 @@ void on_self_enter_leave_lobby(CSteamID id, int type, bool leaving)
public: public:
static void steam_matchmaking_callback(void *object, Common_Message *msg) static void steam_matchmaking_callback(void *object, Common_Message *msg)
{ {
PRINT_DEBUG("steam_matchmaking_callback\n"); PRINT_DEBUG("Steam_MatchMaking::steam_matchmaking_callback\n");
Steam_Matchmaking *steam_matchmaking = (Steam_Matchmaking *)object; Steam_Matchmaking *steam_matchmaking = (Steam_Matchmaking *)object;
steam_matchmaking->Callback(msg); steam_matchmaking->Callback(msg);
@ -297,7 +297,7 @@ static void steam_matchmaking_callback(void *object, Common_Message *msg)
static void steam_matchmaking_run_every_runcb(void *object) static void steam_matchmaking_run_every_runcb(void *object)
{ {
PRINT_DEBUG("steam_matchmaking_run_every_runcb\n"); PRINT_DEBUG("Steam_MatchMaking::steam_matchmaking_run_every_runcb\n");
Steam_Matchmaking *steam_matchmaking = (Steam_Matchmaking *)object; Steam_Matchmaking *steam_matchmaking = (Steam_Matchmaking *)object;
steam_matchmaking->RunCallbacks(); steam_matchmaking->RunCallbacks();
@ -342,7 +342,7 @@ static Lobby_Member *get_lobby_member(Lobby *lobby, CSteamID user_id)
// returns the number of favorites servers the user has stored // returns the number of favorites servers the user has stored
int GetFavoriteGameCount() int GetFavoriteGameCount()
{ {
PRINT_DEBUG("GetFavoriteGameCount\n"); PRINT_DEBUG("Steam_MatchMaking::GetFavoriteGameCount\n");
std::string file_path = Local_Storage::get_user_appdata_path() + "/7/" + Local_Storage::remote_storage_folder + "/serverbrowser_favorites.txt"; std::string file_path = Local_Storage::get_user_appdata_path() + "/7/" + Local_Storage::remote_storage_folder + "/serverbrowser_favorites.txt";
unsigned long long file_size = file_size_(file_path); unsigned long long file_size = file_size_(file_path);
if (file_size) { if (file_size) {
@ -364,7 +364,7 @@ int GetFavoriteGameCount()
// *pRTime32LastPlayedOnServer is filled in the with the Unix time the favorite was added // *pRTime32LastPlayedOnServer is filled in the with the Unix time the favorite was added
bool GetFavoriteGame( int iGame, AppId_t *pnAppID, uint32 *pnIP, uint16 *pnConnPort, uint16 *pnQueryPort, uint32 *punFlags, uint32 *pRTime32LastPlayedOnServer ) bool GetFavoriteGame( int iGame, AppId_t *pnAppID, uint32 *pnIP, uint16 *pnConnPort, uint16 *pnQueryPort, uint32 *punFlags, uint32 *pRTime32LastPlayedOnServer )
{ {
PRINT_DEBUG("GetFavoriteGame\n"); PRINT_DEBUG("Steam_MatchMaking::GetFavoriteGame\n");
return false; return false;
} }
@ -372,7 +372,7 @@ bool GetFavoriteGame( int iGame, AppId_t *pnAppID, uint32 *pnIP, uint16 *pnConnP
// adds the game server to the local list; updates the time played of the server if it already exists in the list // adds the game server to the local list; updates the time played of the server if it already exists in the list
int AddFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer ) int AddFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer )
{ {
PRINT_DEBUG("AddFavoriteGame %u %u %hu %hu %u %u\n", nAppID, nIP, nConnPort, nQueryPort, unFlags, rTime32LastPlayedOnServer); PRINT_DEBUG("Steam_MatchMaking::AddFavoriteGame %u %u %hu %hu %u %u\n", nAppID, nIP, nConnPort, nQueryPort, unFlags, rTime32LastPlayedOnServer);
std::string file_path; std::string file_path;
unsigned long long file_size; unsigned long long file_size;
@ -445,7 +445,7 @@ int AddFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQuery
// removes the game server from the local storage; returns true if one was removed // removes the game server from the local storage; returns true if one was removed
bool RemoveFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags ) bool RemoveFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags )
{ {
PRINT_DEBUG("RemoveFavoriteGame\n"); PRINT_DEBUG("Steam_MatchMaking::RemoveFavoriteGame\n");
std::string file_path; std::string file_path;
unsigned long long file_size; unsigned long long file_size;
@ -530,7 +530,7 @@ bool RemoveFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQ
STEAM_CALL_RESULT( LobbyMatchList_t ) STEAM_CALL_RESULT( LobbyMatchList_t )
SteamAPICall_t RequestLobbyList() SteamAPICall_t RequestLobbyList()
{ {
PRINT_DEBUG("RequestLobbyList\n"); PRINT_DEBUG("Steam_MatchMaking::RequestLobbyList\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
filtered_lobbies.clear(); filtered_lobbies.clear();
lobby_last_search = std::chrono::high_resolution_clock::now(); lobby_last_search = std::chrono::high_resolution_clock::now();
@ -558,7 +558,7 @@ void RequestLobbyList_OLD()
// these are cleared on each call to RequestLobbyList() // these are cleared on each call to RequestLobbyList()
void AddRequestLobbyListStringFilter( const char *pchKeyToMatch, const char *pchValueToMatch, ELobbyComparison eComparisonType ) void AddRequestLobbyListStringFilter( const char *pchKeyToMatch, const char *pchValueToMatch, ELobbyComparison eComparisonType )
{ {
PRINT_DEBUG("AddRequestLobbyListStringFilter %s %s %i\n", pchKeyToMatch, pchValueToMatch, eComparisonType); PRINT_DEBUG("Steam_MatchMaking::AddRequestLobbyListStringFilter %s %s %i\n", pchKeyToMatch, pchValueToMatch, eComparisonType);
if (!pchValueToMatch) return; if (!pchValueToMatch) return;
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
@ -574,7 +574,7 @@ void AddRequestLobbyListStringFilter( const char *pchKeyToMatch, const char *pch
// numerical comparison // numerical comparison
void AddRequestLobbyListNumericalFilter( const char *pchKeyToMatch, int nValueToMatch, ELobbyComparison eComparisonType ) void AddRequestLobbyListNumericalFilter( const char *pchKeyToMatch, int nValueToMatch, ELobbyComparison eComparisonType )
{ {
PRINT_DEBUG("AddRequestLobbyListNumericalFilter %s %i %i\n", pchKeyToMatch, nValueToMatch, eComparisonType); PRINT_DEBUG("Steam_MatchMaking::AddRequestLobbyListNumericalFilter %s %i %i\n", pchKeyToMatch, nValueToMatch, eComparisonType);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Filter_Values fv; struct Filter_Values fv;
fv.key = std::string(pchKeyToMatch); fv.key = std::string(pchKeyToMatch);
@ -588,7 +588,7 @@ void AddRequestLobbyListNumericalFilter( const char *pchKeyToMatch, int nValueTo
// returns results closest to the specified value. Multiple near filters can be added, with early filters taking precedence // returns results closest to the specified value. Multiple near filters can be added, with early filters taking precedence
void AddRequestLobbyListNearValueFilter( const char *pchKeyToMatch, int nValueToBeCloseTo ) void AddRequestLobbyListNearValueFilter( const char *pchKeyToMatch, int nValueToBeCloseTo )
{ {
PRINT_DEBUG("AddRequestLobbyListNearValueFilter %s %u\n", pchKeyToMatch, nValueToBeCloseTo); PRINT_DEBUG("Steam_MatchMaking::AddRequestLobbyListNearValueFilter %s %u\n", pchKeyToMatch, nValueToBeCloseTo);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
@ -597,7 +597,7 @@ void AddRequestLobbyListNearValueFilter( const char *pchKeyToMatch, int nValueTo
// returns only lobbies with the specified number of slots available // returns only lobbies with the specified number of slots available
void AddRequestLobbyListFilterSlotsAvailable( int nSlotsAvailable ) void AddRequestLobbyListFilterSlotsAvailable( int nSlotsAvailable )
{ {
PRINT_DEBUG("AddRequestLobbyListFilterSlotsAvailable %i\n", nSlotsAvailable); PRINT_DEBUG("Steam_MatchMaking::AddRequestLobbyListFilterSlotsAvailable %i\n", nSlotsAvailable);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
@ -606,7 +606,7 @@ void AddRequestLobbyListFilterSlotsAvailable( int nSlotsAvailable )
// sets the distance for which we should search for lobbies (based on users IP address to location map on the Steam backed) // sets the distance for which we should search for lobbies (based on users IP address to location map on the Steam backed)
void AddRequestLobbyListDistanceFilter( ELobbyDistanceFilter eLobbyDistanceFilter ) void AddRequestLobbyListDistanceFilter( ELobbyDistanceFilter eLobbyDistanceFilter )
{ {
PRINT_DEBUG("AddRequestLobbyListDistanceFilter %i\n", eLobbyDistanceFilter); PRINT_DEBUG("Steam_MatchMaking::AddRequestLobbyListDistanceFilter %i\n", eLobbyDistanceFilter);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
@ -615,7 +615,7 @@ void AddRequestLobbyListDistanceFilter( ELobbyDistanceFilter eLobbyDistanceFilte
// sets how many results to return, the lower the count the faster it is to download the lobby results & details to the client // sets how many results to return, the lower the count the faster it is to download the lobby results & details to the client
void AddRequestLobbyListResultCountFilter( int cMaxResults ) void AddRequestLobbyListResultCountFilter( int cMaxResults )
{ {
PRINT_DEBUG("AddRequestLobbyListResultCountFilter %i\n", cMaxResults); PRINT_DEBUG("Steam_MatchMaking::AddRequestLobbyListResultCountFilter %i\n", cMaxResults);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
filter_max_results = cMaxResults; filter_max_results = cMaxResults;
@ -624,7 +624,7 @@ void AddRequestLobbyListResultCountFilter( int cMaxResults )
void AddRequestLobbyListCompatibleMembersFilter( CSteamID steamIDLobby ) void AddRequestLobbyListCompatibleMembersFilter( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("AddRequestLobbyListCompatibleMembersFilter\n"); PRINT_DEBUG("Steam_MatchMaking::AddRequestLobbyListCompatibleMembersFilter\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
@ -651,11 +651,11 @@ void AddRequestLobbyListSlotsAvailableFilter()
// the returned CSteamID::IsValid() will be false if iLobby is out of range // the returned CSteamID::IsValid() will be false if iLobby is out of range
CSteamID GetLobbyByIndex( int iLobby ) CSteamID GetLobbyByIndex( int iLobby )
{ {
PRINT_DEBUG("GetLobbyByIndex %i\n", iLobby); PRINT_DEBUG("Steam_MatchMaking::GetLobbyByIndex %i\n", iLobby);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
CSteamID id = k_steamIDNil; CSteamID id = k_steamIDNil;
if (0 <= iLobby && iLobby < filtered_lobbies.size()) id = filtered_lobbies[iLobby]; if (0 <= iLobby && iLobby < filtered_lobbies.size()) id = filtered_lobbies[iLobby];
PRINT_DEBUG("Lobby %llu\n", id.ConvertToUint64()); PRINT_DEBUG(" Lobby %llu\n", id.ConvertToUint64());
return id; return id;
} }
@ -743,7 +743,7 @@ void Create_pending_lobbies()
STEAM_CALL_RESULT( LobbyCreated_t ) STEAM_CALL_RESULT( LobbyCreated_t )
SteamAPICall_t CreateLobby( ELobbyType eLobbyType, int cMaxMembers ) SteamAPICall_t CreateLobby( ELobbyType eLobbyType, int cMaxMembers )
{ {
PRINT_DEBUG("CreateLobby type: %i max_members: %i\n", eLobbyType, cMaxMembers); PRINT_DEBUG("Steam_MatchMaking::CreateLobby type: %i max_members: %i\n", eLobbyType, cMaxMembers);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Pending_Creates p_c; struct Pending_Creates p_c;
p_c.api_id = callback_results->reserveCallResult(); p_c.api_id = callback_results->reserveCallResult();
@ -776,7 +776,7 @@ void CreateLobby( bool bPrivate )
STEAM_CALL_RESULT( LobbyEnter_t ) STEAM_CALL_RESULT( LobbyEnter_t )
SteamAPICall_t JoinLobby( CSteamID steamIDLobby ) SteamAPICall_t JoinLobby( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("JoinLobby %llu\n", steamIDLobby.ConvertToUint64()); PRINT_DEBUG("Steam_MatchMaking::JoinLobby %llu\n", steamIDLobby.ConvertToUint64());
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto pj = std::find_if(pending_joins.begin(), pending_joins.end(), [&steamIDLobby](Pending_Joins const& item) {return item.lobby_id == steamIDLobby;}); auto pj = std::find_if(pending_joins.begin(), pending_joins.end(), [&steamIDLobby](Pending_Joins const& item) {return item.lobby_id == steamIDLobby;});
@ -804,22 +804,22 @@ void JoinLobby_OLD( CSteamID steamIDLobby )
// other users in the lobby will be notified by a LobbyChatUpdate_t callback // other users in the lobby will be notified by a LobbyChatUpdate_t callback
void LeaveLobby( CSteamID steamIDLobby ) void LeaveLobby( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("LeaveLobby\n"); PRINT_DEBUG("Steam_MatchMaking::LeaveLobby\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
PRINT_DEBUG("LeaveLobby pass mutex\n"); PRINT_DEBUG("Steam_MatchMaking::LeaveLobby pass mutex\n");
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (lobby) { if (lobby) {
if (!lobby->deleted()) { if (!lobby->deleted()) {
on_self_enter_leave_lobby((uint64)lobby->room_id(), lobby->type(), true); on_self_enter_leave_lobby((uint64)lobby->room_id(), lobby->type(), true);
self_lobby_member_data.erase(lobby->room_id()); self_lobby_member_data.erase(lobby->room_id());
if (lobby->owner() != settings->get_local_steam_id().ConvertToUint64()) { if (lobby->owner() != settings->get_local_steam_id().ConvertToUint64()) {
PRINT_DEBUG("LeaveLobby not owner\n"); PRINT_DEBUG("Steam_MatchMaking::LeaveLobby not owner\n");
leave_lobby(&(*lobby), settings->get_local_steam_id()); leave_lobby(&(*lobby), settings->get_local_steam_id());
Lobby_Messages *message = new Lobby_Messages(); Lobby_Messages *message = new Lobby_Messages();
message->set_type(Lobby_Messages::LEAVE); message->set_type(Lobby_Messages::LEAVE);
send_owner_packet(steamIDLobby, message); send_owner_packet(steamIDLobby, message);
} else { } else {
PRINT_DEBUG("LeaveLobby owner\n"); PRINT_DEBUG("Steam_MatchMaking::LeaveLobby owner\n");
Lobby_Messages *message = new Lobby_Messages(); Lobby_Messages *message = new Lobby_Messages();
message->set_type(Lobby_Messages::LEAVE); message->set_type(Lobby_Messages::LEAVE);
@ -836,7 +836,7 @@ void LeaveLobby( CSteamID steamIDLobby )
} }
} }
PRINT_DEBUG("LeaveLobby Done\n"); PRINT_DEBUG("Steam_MatchMaking::LeaveLobby Done\n");
} }
@ -849,7 +849,7 @@ void LeaveLobby( CSteamID steamIDLobby )
// or if the game isn't running yet the game will be launched with the parameter +connect_lobby <64-bit lobby id> // or if the game isn't running yet the game will be launched with the parameter +connect_lobby <64-bit lobby id>
bool InviteUserToLobby( CSteamID steamIDLobby, CSteamID steamIDInvitee ) bool InviteUserToLobby( CSteamID steamIDLobby, CSteamID steamIDInvitee )
{ {
PRINT_DEBUG("InviteUserToLobby\n"); PRINT_DEBUG("Steam_MatchMaking::InviteUserToLobby\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby) return false; if (!lobby) return false;
@ -873,13 +873,13 @@ bool InviteUserToLobby( CSteamID steamIDLobby, CSteamID steamIDInvitee )
// returns the number of users in the specified lobby // returns the number of users in the specified lobby
int GetNumLobbyMembers( CSteamID steamIDLobby ) int GetNumLobbyMembers( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("GetNumLobbyMembers %llu\n", steamIDLobby.ConvertToUint64()); PRINT_DEBUG("Steam_MatchMaking::GetNumLobbyMembers %llu\n", steamIDLobby.ConvertToUint64());
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
int ret = 0; int ret = 0;
if (lobby) ret = lobby->members().size(); if (lobby) ret = lobby->members().size();
PRINT_DEBUG("Number: %i\n", ret); PRINT_DEBUG("Steam_MatchMaking::GetNumLobbyMembers Number: %i\n", ret);
return ret; return ret;
} }
@ -888,12 +888,12 @@ int GetNumLobbyMembers( CSteamID steamIDLobby )
// note that the current user must be in a lobby to retrieve CSteamIDs of other users in that lobby // note that the current user must be in a lobby to retrieve CSteamIDs of other users in that lobby
CSteamID GetLobbyMemberByIndex( CSteamID steamIDLobby, int iMember ) CSteamID GetLobbyMemberByIndex( CSteamID steamIDLobby, int iMember )
{ {
PRINT_DEBUG("GetLobbyMemberByIndex %llu %i\n", steamIDLobby.ConvertToUint64(), iMember); PRINT_DEBUG("Steam_MatchMaking::GetLobbyMemberByIndex %llu %i\n", steamIDLobby.ConvertToUint64(), iMember);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
CSteamID id = k_steamIDNil; CSteamID id = k_steamIDNil;
if (lobby && !lobby->deleted() && lobby->members().size() > iMember && iMember >= 0) id = (uint64)lobby->members(iMember).id(); if (lobby && !lobby->deleted() && lobby->members().size() > iMember && iMember >= 0) id = (uint64)lobby->members(iMember).id();
PRINT_DEBUG("Member: %llu\n", id.ConvertToUint64()); PRINT_DEBUG("Steam_MatchMaking::GetLobbyMemberByIndex Member: %llu\n", id.ConvertToUint64());
return id; return id;
} }
@ -903,7 +903,7 @@ CSteamID GetLobbyMemberByIndex( CSteamID steamIDLobby, int iMember )
// "" will be returned if no value is set, or if steamIDLobby is invalid // "" will be returned if no value is set, or if steamIDLobby is invalid
const char *GetLobbyData( CSteamID steamIDLobby, const char *pchKey ) const char *GetLobbyData( CSteamID steamIDLobby, const char *pchKey )
{ {
PRINT_DEBUG("GetLobbyData %llu %s\n", steamIDLobby.ConvertToUint64(), pchKey); PRINT_DEBUG("Steam_MatchMaking::GetLobbyData %llu %s\n", steamIDLobby.ConvertToUint64(), pchKey);
if (!pchKey) return ""; if (!pchKey) return "";
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
@ -913,7 +913,7 @@ const char *GetLobbyData( CSteamID steamIDLobby, const char *pchKey )
if (result != lobby->values().end()) ret = result->second.c_str(); if (result != lobby->values().end()) ret = result->second.c_str();
} }
PRINT_DEBUG("returned %s\n", ret); PRINT_DEBUG("Steam_MatchMaking::GetLobbyData returned %s\n", ret);
return ret; return ret;
} }
@ -924,7 +924,7 @@ const char *GetLobbyData( CSteamID steamIDLobby, const char *pchKey )
// other users in the lobby will receive notification of the lobby data change via a LobbyDataUpdate_t callback // other users in the lobby will receive notification of the lobby data change via a LobbyDataUpdate_t callback
bool SetLobbyData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue ) bool SetLobbyData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue )
{ {
PRINT_DEBUG("SetLobbyData %llu %s %s\n", steamIDLobby.ConvertToUint64(), pchKey, pchValue); PRINT_DEBUG("Steam_MatchMaking::SetLobbyData %llu %s %s\n", steamIDLobby.ConvertToUint64(), pchKey, pchValue);
if (!pchKey) return false; if (!pchKey) return false;
char empty_string[] = ""; char empty_string[] = "";
if (!pchValue) pchValue = empty_string; if (!pchValue) pchValue = empty_string;
@ -957,7 +957,7 @@ bool SetLobbyData( CSteamID steamIDLobby, const char *pchKey, const char *pchVal
// returns the number of metadata keys set on the specified lobby // returns the number of metadata keys set on the specified lobby
int GetLobbyDataCount( CSteamID steamIDLobby ) int GetLobbyDataCount( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("GetLobbyDataCount\n"); PRINT_DEBUG("Steam_MatchMaking::GetLobbyDataCount\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
int size = 0; int size = 0;
@ -971,7 +971,7 @@ int GetLobbyDataCount( CSteamID steamIDLobby )
// returns a lobby metadata key/values pair by index, of range [0, GetLobbyDataCount()) // returns a lobby metadata key/values pair by index, of range [0, GetLobbyDataCount())
bool GetLobbyDataByIndex( CSteamID steamIDLobby, int iLobbyData, char *pchKey, int cchKeyBufferSize, char *pchValue, int cchValueBufferSize ) bool GetLobbyDataByIndex( CSteamID steamIDLobby, int iLobbyData, char *pchKey, int cchKeyBufferSize, char *pchValue, int cchValueBufferSize )
{ {
PRINT_DEBUG("GetLobbyDataByIndex\n"); PRINT_DEBUG("Steam_MatchMaking::GetLobbyDataByIndex\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
bool ret = false; bool ret = false;
@ -985,7 +985,7 @@ bool GetLobbyDataByIndex( CSteamID steamIDLobby, int iLobbyData, char *pchKey, i
if (cchValueBufferSize) strncpy(pchValue, lobby_data->second.c_str(), cchValueBufferSize - 1); if (cchValueBufferSize) strncpy(pchValue, lobby_data->second.c_str(), cchValueBufferSize - 1);
pchValue[cchValueBufferSize - 1] = 0; pchValue[cchValueBufferSize - 1] = 0;
PRINT_DEBUG("GetLobbyDataByIndex ret %s %s\n", pchKey, pchValue); PRINT_DEBUG("Steam_MatchMaking::GetLobbyDataByIndex ret %s %s\n", pchKey, pchValue);
ret = true; ret = true;
} }
@ -997,7 +997,7 @@ bool GetLobbyDataByIndex( CSteamID steamIDLobby, int iLobbyData, char *pchKey, i
// removes a metadata key from the lobby // removes a metadata key from the lobby
bool DeleteLobbyData( CSteamID steamIDLobby, const char *pchKey ) bool DeleteLobbyData( CSteamID steamIDLobby, const char *pchKey )
{ {
PRINT_DEBUG("DeleteLobbyData\n"); PRINT_DEBUG("Steam_MatchMaking::DeleteLobbyData\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) { if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) {
@ -1014,7 +1014,7 @@ bool DeleteLobbyData( CSteamID steamIDLobby, const char *pchKey )
// Gets per-user metadata for someone in this lobby // Gets per-user metadata for someone in this lobby
const char *GetLobbyMemberData( CSteamID steamIDLobby, CSteamID steamIDUser, const char *pchKey ) const char *GetLobbyMemberData( CSteamID steamIDLobby, CSteamID steamIDUser, const char *pchKey )
{ {
PRINT_DEBUG("GetLobbyMemberData %s %llu %llu\n", pchKey, steamIDLobby.ConvertToUint64(), steamIDUser.ConvertToUint64()); PRINT_DEBUG("Steam_MatchMaking::GetLobbyMemberData %s %llu %llu\n", pchKey, steamIDLobby.ConvertToUint64(), steamIDUser.ConvertToUint64());
if (!pchKey) return ""; if (!pchKey) return "";
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Lobby_Member *member = get_lobby_member(get_lobby(steamIDLobby), steamIDUser); struct Lobby_Member *member = get_lobby_member(get_lobby(steamIDLobby), steamIDUser);
@ -1035,14 +1035,14 @@ const char *GetLobbyMemberData( CSteamID steamIDLobby, CSteamID steamIDUser, con
} }
} }
PRINT_DEBUG("GetLobbyMemberData res %s\n", ret); PRINT_DEBUG("Steam_MatchMaking::GetLobbyMemberData res %s\n", ret);
return ret; return ret;
} }
// Sets per-user metadata (for the local user implicitly) // Sets per-user metadata (for the local user implicitly)
void SetLobbyMemberData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue ) void SetLobbyMemberData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue )
{ {
PRINT_DEBUG("SetLobbyMemberData %s %s\n", pchKey, pchValue); PRINT_DEBUG("Steam_MatchMaking::SetLobbyMemberData %s %s\n", pchKey, pchValue);
if (!pchKey) return; if (!pchKey) return;
char empty_string[] = ""; char empty_string[] = "";
if (!pchValue) pchValue = empty_string; if (!pchValue) pchValue = empty_string;
@ -1092,7 +1092,7 @@ void SetLobbyMemberData( CSteamID steamIDLobby, const char *pchKey, const char *
// if pvMsgBody is text, cubMsgBody should be strlen( text ) + 1, to include the null terminator // if pvMsgBody is text, cubMsgBody should be strlen( text ) + 1, to include the null terminator
bool SendLobbyChatMsg( CSteamID steamIDLobby, const void *pvMsgBody, int cubMsgBody ) bool SendLobbyChatMsg( CSteamID steamIDLobby, const void *pvMsgBody, int cubMsgBody )
{ {
PRINT_DEBUG("SendLobbyChatMsg %i\n", cubMsgBody); PRINT_DEBUG("Steam_MatchMaking::SendLobbyChatMsg %i\n", cubMsgBody);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby || lobby->deleted()) return false; if (!lobby || lobby->deleted()) return false;
@ -1110,7 +1110,7 @@ bool SendLobbyChatMsg( CSteamID steamIDLobby, const void *pvMsgBody, int cubMsgB
// return value is the number of bytes written into the buffer // return value is the number of bytes written into the buffer
int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, STEAM_OUT_STRUCT() CSteamID *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType ) int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, STEAM_OUT_STRUCT() CSteamID *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType )
{ {
PRINT_DEBUG("GetLobbyChatEntry %llu %i %p %p %i %p\n", steamIDLobby.ConvertToUint64(), iChatID, pSteamIDUser, pvData, cubData, peChatEntryType); PRINT_DEBUG("Steam_MatchMaking::GetLobbyChatEntry %llu %i %p %p %i %p\n", steamIDLobby.ConvertToUint64(), iChatID, pSteamIDUser, pvData, cubData, peChatEntryType);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (iChatID >= chat_entries.size() || iChatID < 0 || cubData < 0) return 0; if (iChatID >= chat_entries.size() || iChatID < 0 || cubData < 0) return 0;
if (chat_entries[iChatID].lobby_id != steamIDLobby) return 0; if (chat_entries[iChatID].lobby_id != steamIDLobby) return 0;
@ -1120,7 +1120,7 @@ int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, STEAM_OUT_STRUCT() CS
if (chat_entries[iChatID].message.size() <= cubData) { if (chat_entries[iChatID].message.size() <= cubData) {
cubData = chat_entries[iChatID].message.size(); cubData = chat_entries[iChatID].message.size();
memcpy(pvData, chat_entries[iChatID].message.data(), cubData); memcpy(pvData, chat_entries[iChatID].message.data(), cubData);
PRINT_DEBUG("Returned chat of len: %i\n", cubData); PRINT_DEBUG(" Returned chat of len: %i\n", cubData);
return cubData; return cubData;
} }
} }
@ -1138,7 +1138,7 @@ int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, STEAM_OUT_STRUCT() CS
// if the specified lobby doesn't exist, LobbyDataUpdate_t::m_bSuccess will be set to false // if the specified lobby doesn't exist, LobbyDataUpdate_t::m_bSuccess will be set to false
bool RequestLobbyData( CSteamID steamIDLobby ) bool RequestLobbyData( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("RequestLobbyData\n"); PRINT_DEBUG("Steam_MatchMaking::RequestLobbyData\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
struct Data_Requested requested; struct Data_Requested requested;
requested.lobby_id = steamIDLobby; requested.lobby_id = steamIDLobby;
@ -1152,7 +1152,7 @@ bool RequestLobbyData( CSteamID steamIDLobby )
// either the IP/Port or the steamID of the game server has to be valid, depending on how you want the clients to be able to connect // either the IP/Port or the steamID of the game server has to be valid, depending on how you want the clients to be able to connect
void SetLobbyGameServer( CSteamID steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, CSteamID steamIDGameServer ) void SetLobbyGameServer( CSteamID steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, CSteamID steamIDGameServer )
{ {
PRINT_DEBUG("SetLobbyGameServer %llu %llu %hhu.%hhu.%hhu.%hhu:%hu\n", steamIDLobby.ConvertToUint64(), steamIDGameServer.ConvertToUint64(), ((unsigned char *)&unGameServerIP)[3], ((unsigned char *)&unGameServerIP)[2], ((unsigned char *)&unGameServerIP)[1], ((unsigned char *)&unGameServerIP)[0], unGameServerPort); PRINT_DEBUG("Steam_MatchMaking::SetLobbyGameServer %llu %llu %hhu.%hhu.%hhu.%hhu:%hu\n", steamIDLobby.ConvertToUint64(), steamIDGameServer.ConvertToUint64(), ((unsigned char *)&unGameServerIP)[3], ((unsigned char *)&unGameServerIP)[2], ((unsigned char *)&unGameServerIP)[1], ((unsigned char *)&unGameServerIP)[0], unGameServerPort);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (lobby) { if (lobby) {
@ -1173,7 +1173,7 @@ void SetLobbyGameServer( CSteamID steamIDLobby, uint32 unGameServerIP, uint16 un
// returns the details of a game server set in a lobby - returns false if there is no game server set, or that lobby doesn't exist // returns the details of a game server set in a lobby - returns false if there is no game server set, or that lobby doesn't exist
bool GetLobbyGameServer( CSteamID steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, STEAM_OUT_STRUCT() CSteamID *psteamIDGameServer ) bool GetLobbyGameServer( CSteamID steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, STEAM_OUT_STRUCT() CSteamID *psteamIDGameServer )
{ {
PRINT_DEBUG("GetLobbyGameServer\n"); PRINT_DEBUG("Steam_MatchMaking::GetLobbyGameServer\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby) { if (!lobby) {
@ -1198,7 +1198,7 @@ bool GetLobbyGameServer( CSteamID steamIDLobby, uint32 *punGameServerIP, uint16
// set the limit on the # of users who can join the lobby // set the limit on the # of users who can join the lobby
bool SetLobbyMemberLimit( CSteamID steamIDLobby, int cMaxMembers ) bool SetLobbyMemberLimit( CSteamID steamIDLobby, int cMaxMembers )
{ {
PRINT_DEBUG("SetLobbyMemberLimit\n"); PRINT_DEBUG("Steam_MatchMaking::SetLobbyMemberLimit\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) { if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) {
@ -1215,26 +1215,26 @@ bool SetLobbyMemberLimit( CSteamID steamIDLobby, int cMaxMembers )
// returns the current limit on the # of users who can join the lobby; returns 0 if no limit is defined // returns the current limit on the # of users who can join the lobby; returns 0 if no limit is defined
int GetLobbyMemberLimit( CSteamID steamIDLobby ) int GetLobbyMemberLimit( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("GetLobbyMemberLimit\n"); PRINT_DEBUG("Steam_MatchMaking::GetLobbyMemberLimit\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
int limit = 0; int limit = 0;
if (lobby) limit = lobby->member_limit(); if (lobby) limit = lobby->member_limit();
PRINT_DEBUG("limit %i\n", limit); PRINT_DEBUG(" limit %i\n", limit);
return limit; return limit;
} }
void SetLobbyVoiceEnabled( CSteamID steamIDLobby, bool bVoiceEnabled ) void SetLobbyVoiceEnabled( CSteamID steamIDLobby, bool bVoiceEnabled )
{ {
PRINT_DEBUG("SetLobbyVoiceEnabled\n"); PRINT_DEBUG("Steam_MatchMaking::SetLobbyVoiceEnabled\n");
} }
// updates which type of lobby it is // updates which type of lobby it is
// only lobbies that are k_ELobbyTypePublic or k_ELobbyTypeInvisible, and are set to joinable, will be returned by RequestLobbyList() calls // only lobbies that are k_ELobbyTypePublic or k_ELobbyTypeInvisible, and are set to joinable, will be returned by RequestLobbyList() calls
bool SetLobbyType( CSteamID steamIDLobby, ELobbyType eLobbyType ) bool SetLobbyType( CSteamID steamIDLobby, ELobbyType eLobbyType )
{ {
PRINT_DEBUG("SetLobbyType %i\n", eLobbyType); PRINT_DEBUG("Steam_MatchMaking::SetLobbyType %i\n", eLobbyType);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) { if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) {
@ -1258,7 +1258,7 @@ bool SetLobbyType( CSteamID steamIDLobby, ELobbyType eLobbyType )
// if set to false, no user can join, even if they are a friend or have been invited // if set to false, no user can join, even if they are a friend or have been invited
bool SetLobbyJoinable( CSteamID steamIDLobby, bool bLobbyJoinable ) bool SetLobbyJoinable( CSteamID steamIDLobby, bool bLobbyJoinable )
{ {
PRINT_DEBUG("SetLobbyJoinable %u\n", bLobbyJoinable); PRINT_DEBUG("Steam_MatchMaking::SetLobbyJoinable %u\n", bLobbyJoinable);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) { if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) {
@ -1280,7 +1280,7 @@ bool SetLobbyJoinable( CSteamID steamIDLobby, bool bLobbyJoinable )
// it is possible (bur rare) to join a lobby just as the owner is leaving, thus entering a lobby with self as the owner // it is possible (bur rare) to join a lobby just as the owner is leaving, thus entering a lobby with self as the owner
CSteamID GetLobbyOwner( CSteamID steamIDLobby ) CSteamID GetLobbyOwner( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("GetLobbyOwner %llu\n", steamIDLobby.ConvertToUint64()); PRINT_DEBUG("Steam_MatchMaking::GetLobbyOwner %llu\n", steamIDLobby.ConvertToUint64());
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby || lobby->deleted()) return k_steamIDNil; if (!lobby || lobby->deleted()) return k_steamIDNil;
@ -1295,7 +1295,7 @@ CSteamID GetLobbyOwner( CSteamID steamIDLobby )
// filters don't apply to lobbies (currently) // filters don't apply to lobbies (currently)
bool RequestFriendsLobbies() bool RequestFriendsLobbies()
{ {
PRINT_DEBUG("RequestFriendsLobbies\n"); PRINT_DEBUG("Steam_MatchMaking::RequestFriendsLobbies\n");
RequestFriendsLobbiesResponse_t data = {}; RequestFriendsLobbiesResponse_t data = {};
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data)); callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
return true; return true;
@ -1303,7 +1303,7 @@ bool RequestFriendsLobbies()
float GetLobbyDistance( CSteamID steamIDLobby ) float GetLobbyDistance( CSteamID steamIDLobby )
{ {
PRINT_DEBUG("GetLobbyDistance %llu\n", steamIDLobby.ConvertToUint64()); PRINT_DEBUG("Steam_MatchMaking::GetLobbyDistance %llu\n", steamIDLobby.ConvertToUint64());
return 0.0; return 0.0;
} }
@ -1312,7 +1312,7 @@ float GetLobbyDistance( CSteamID steamIDLobby )
// after completion, the local user will no longer be the owner // after completion, the local user will no longer be the owner
bool SetLobbyOwner( CSteamID steamIDLobby, CSteamID steamIDNewOwner ) bool SetLobbyOwner( CSteamID steamIDLobby, CSteamID steamIDNewOwner )
{ {
PRINT_DEBUG("SetLobbyOwner\n"); PRINT_DEBUG("Steam_MatchMaking::SetLobbyOwner\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Lobby *lobby = get_lobby(steamIDLobby); Lobby *lobby = get_lobby(steamIDLobby);
if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) return false; if (!lobby || lobby->owner() != settings->get_local_steam_id().ConvertToUint64() || lobby->deleted()) return false;
@ -1333,7 +1333,7 @@ bool SetLobbyOwner( CSteamID steamIDLobby, CSteamID steamIDNewOwner )
// you must be the lobby owner of both lobbies // you must be the lobby owner of both lobbies
bool SetLinkedLobby( CSteamID steamIDLobby, CSteamID steamIDLobbyDependent ) bool SetLinkedLobby( CSteamID steamIDLobby, CSteamID steamIDLobbyDependent )
{ {
PRINT_DEBUG("SetLinkedLobby\n"); PRINT_DEBUG("Steam_MatchMaking::SetLinkedLobby\n");
return false; return false;
} }
@ -1353,41 +1353,41 @@ void RunCallbacks()
RunBackground(); RunBackground();
if (searching) { if (searching) {
PRINT_DEBUG("Searching for lobbies %zu\n", lobbies.size()); PRINT_DEBUG("Steam_MatchMaking::Searching for lobbies %zu\n", lobbies.size());
for(auto & l: lobbies) { for(auto & l: lobbies) {
bool use = l.joinable() && (l.type() == k_ELobbyTypePublic || l.type() == k_ELobbyTypeInvisible || l.type() == k_ELobbyTypeFriendsOnly) && !l.deleted(); bool use = l.joinable() && (l.type() == k_ELobbyTypePublic || l.type() == k_ELobbyTypeInvisible || l.type() == k_ELobbyTypeFriendsOnly) && !l.deleted();
PRINT_DEBUG("use lobby: %u, filters: %zu, joinable: %u, type: %u, deleted: %u\n", use, filter_values_copy.size(), l.joinable(), l.type(), l.deleted()); PRINT_DEBUG("Steam_MatchMaking use lobby: %u, filters: %zu, joinable: %u, type: %u, deleted: %u\n", use, filter_values_copy.size(), l.joinable(), l.type(), l.deleted());
for (auto & f : filter_values_copy) { for (auto & f : filter_values_copy) {
PRINT_DEBUG("%s:%s/%i %u %i\n", f.key.c_str(), f.value_string.c_str(), f.value_int, f.is_int, f.eComparisonType); PRINT_DEBUG("Steam_MatchMaking %s:%s/%i %u %i\n", f.key.c_str(), f.value_string.c_str(), f.value_int, f.is_int, f.eComparisonType);
auto value = caseinsensitive_find(l.values(), f.key); auto value = caseinsensitive_find(l.values(), f.key);
if (value != l.values().end()) { if (value != l.values().end()) {
//TODO: eComparisonType //TODO: eComparisonType
if (!f.is_int) { if (!f.is_int) {
PRINT_DEBUG("Compare Values %s %s\n", value->second.c_str(), f.value_string.c_str()); PRINT_DEBUG("Steam_MatchMaking Compare Values %s %s\n", value->second.c_str(), f.value_string.c_str());
if (f.eComparisonType == k_ELobbyComparisonEqual) { if (f.eComparisonType == k_ELobbyComparisonEqual) {
if (value->second == f.value_string) { if (value->second == f.value_string) {
PRINT_DEBUG("Equal\n"); PRINT_DEBUG("Steam_MatchMaking Equal\n");
//use = use; //use = use;
} else { } else {
PRINT_DEBUG("Not Equal\n"); PRINT_DEBUG("Steam_MatchMaking Not Equal\n");
use = false; use = false;
} }
} }
} else { } else {
try { try {
PRINT_DEBUG("%s\n", value->second.c_str()); PRINT_DEBUG("Steam_MatchMaking %s\n", value->second.c_str());
int compare_to = 0; int compare_to = 0;
//TODO: check if this is how real steam behaves //TODO: check if this is how real steam behaves
if (value->second.size()) { if (value->second.size()) {
compare_to = std::stoll(value->second, 0, 0); compare_to = std::stoll(value->second, 0, 0);
} }
PRINT_DEBUG("Compare Values %i %i\n", compare_to, f.value_int); PRINT_DEBUG("Steam_MatchMaking Compare Values %i %i\n", compare_to, f.value_int);
if (f.eComparisonType == k_ELobbyComparisonEqual) { if (f.eComparisonType == k_ELobbyComparisonEqual) {
if (compare_to == f.value_int) { if (compare_to == f.value_int) {
PRINT_DEBUG("Equal\n"); PRINT_DEBUG("Steam_MatchMaking Equal\n");
//use = use; //use = use;
} else { } else {
PRINT_DEBUG("Not Equal\n"); PRINT_DEBUG("Steam_MatchMaking Not Equal\n");
use = false; use = false;
} }
} }
@ -1398,7 +1398,7 @@ void RunCallbacks()
//TODO: add more comparisons //TODO: add more comparisons
} }
} else { } else {
PRINT_DEBUG("Compare Key not in lobby\n"); PRINT_DEBUG("Steam_MatchMaking Compare Key not in lobby\n");
if (f.eComparisonType == k_ELobbyComparisonEqual) { if (f.eComparisonType == k_ELobbyComparisonEqual) {
//If the key is not in the lobby do we take it into account? //If the key is not in the lobby do we take it into account?
use = false; use = false;
@ -1406,7 +1406,7 @@ void RunCallbacks()
} }
} }
PRINT_DEBUG("Lobby " "%" PRIu64 " use %u\n", l.room_id(), use); PRINT_DEBUG("Steam_MatchMaking Lobby " "%" PRIu64 " use %u\n", l.room_id(), use);
if (use) PUSH_BACK_IF_NOT_IN(filtered_lobbies, (uint64)l.room_id()); if (use) PUSH_BACK_IF_NOT_IN(filtered_lobbies, (uint64)l.room_id());
if (filtered_lobbies.size() >= filter_max_results_copy) { if (filtered_lobbies.size() >= filter_max_results_copy) {
searching = false; searching = false;
@ -1420,7 +1420,7 @@ void RunCallbacks()
} }
if (searching && check_timedout(lobby_last_search, LOBBY_SEARCH_TIMEOUT)) { if (searching && check_timedout(lobby_last_search, LOBBY_SEARCH_TIMEOUT)) {
PRINT_DEBUG("LOBBY_SEARCH_TIMEOUT %zu\n", filtered_lobbies.size()); PRINT_DEBUG("Steam_MatchMaking LOBBY_SEARCH_TIMEOUT %zu\n", filtered_lobbies.size());
LobbyMatchList_t data; LobbyMatchList_t data;
data.m_nLobbiesMatching = filtered_lobbies.size(); data.m_nLobbiesMatching = filtered_lobbies.size();
callback_results->addCallResult(search_call_api_id, data.k_iCallback, &data, sizeof(data)); callback_results->addCallResult(search_call_api_id, data.k_iCallback, &data, sizeof(data));
@ -1432,7 +1432,7 @@ void RunCallbacks()
auto g = std::begin(pending_joins); auto g = std::begin(pending_joins);
while (g != std::end(pending_joins)) { while (g != std::end(pending_joins)) {
if (!g->message_sent) { if (!g->message_sent) {
PRINT_DEBUG("Resend join lobby\n"); PRINT_DEBUG("Steam_MatchMaking Resend join lobby\n");
Lobby_Messages *message = new Lobby_Messages(); Lobby_Messages *message = new Lobby_Messages();
message->set_type(Lobby_Messages::JOIN); message->set_type(Lobby_Messages::JOIN);
g->message_sent = send_owner_packet(g->lobby_id, message); g->message_sent = send_owner_packet(g->lobby_id, message);
@ -1471,7 +1471,7 @@ void RunCallbacks()
callback_results->addCallResult(g->api_id, data.k_iCallback, &data, sizeof(data)); callback_results->addCallResult(g->api_id, data.k_iCallback, &data, sizeof(data));
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data)); callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
g = pending_joins.erase(g); g = pending_joins.erase(g);
PRINT_DEBUG("PENDING_JOIN_TIMEOUT\n"); PRINT_DEBUG("Steam_MatchMaking PENDING_JOIN_TIMEOUT\n");
} else { } else {
++g; ++g;
} }
@ -1501,7 +1501,7 @@ void RunCallbacks()
void Callback(Common_Message *msg) void Callback(Common_Message *msg)
{ {
if (msg->has_lobby()) { if (msg->has_lobby()) {
PRINT_DEBUG("GOT A LOBBY appid: %u\n", msg->lobby().appid()); PRINT_DEBUG("Steam_MatchMaking GOT A LOBBY appid: %u\n", msg->lobby().appid());
if (msg->lobby().owner() != settings->get_local_steam_id().ConvertToUint64() && msg->lobby().appid() == settings->get_local_game_id().AppID()) { if (msg->lobby().owner() != settings->get_local_steam_id().ConvertToUint64() && msg->lobby().appid() == settings->get_local_game_id().AppID()) {
Lobby *lobby = get_lobby((uint64)msg->lobby().room_id()); Lobby *lobby = get_lobby((uint64)msg->lobby().room_id());
if (!lobby) { if (!lobby) {
@ -1588,24 +1588,24 @@ void Callback(Common_Message *msg)
if (msg->has_lobby_messages()) { if (msg->has_lobby_messages()) {
PRINT_DEBUG("LOBBY MESSAGE %u " "%" PRIu64 "\n", msg->lobby_messages().type(), msg->lobby_messages().id()); PRINT_DEBUG("Steam_MatchMaking LOBBY MESSAGE %u " "%" PRIu64 "\n", msg->lobby_messages().type(), msg->lobby_messages().id());
Lobby *lobby = get_lobby((uint64)msg->lobby_messages().id()); Lobby *lobby = get_lobby((uint64)msg->lobby_messages().id());
if (lobby && !lobby->deleted()) { if (lobby && !lobby->deleted()) {
bool we_are_in_lobby = !!get_lobby_member(lobby, settings->get_local_steam_id()); bool we_are_in_lobby = !!get_lobby_member(lobby, settings->get_local_steam_id());
if (lobby->owner() == settings->get_local_steam_id().ConvertToUint64()) { if (lobby->owner() == settings->get_local_steam_id().ConvertToUint64()) {
if (msg->lobby_messages().type() == Lobby_Messages::JOIN) { if (msg->lobby_messages().type() == Lobby_Messages::JOIN) {
PRINT_DEBUG("LOBBY MESSAGE: JOIN\n"); PRINT_DEBUG("Steam_MatchMaking LOBBY MESSAGE: JOIN\n");
if (enter_lobby(lobby, (uint64)msg->source_id())) { if (enter_lobby(lobby, (uint64)msg->source_id())) {
trigger_lobby_member_join_leave((uint64)lobby->room_id(), (uint64)msg->source_id(), false, true, 0.01); trigger_lobby_member_join_leave((uint64)lobby->room_id(), (uint64)msg->source_id(), false, true, 0.01);
} }
} }
if (msg->lobby_messages().type() == Lobby_Messages::MEMBER_DATA) { if (msg->lobby_messages().type() == Lobby_Messages::MEMBER_DATA) {
PRINT_DEBUG("LOBBY MESSAGE: MEMBER_DATA\n"); PRINT_DEBUG("Steam_MatchMaking LOBBY MESSAGE: MEMBER_DATA\n");
Lobby_Member *member = get_lobby_member(lobby, (uint64)msg->source_id()); Lobby_Member *member = get_lobby_member(lobby, (uint64)msg->source_id());
if (member) { if (member) {
for (auto const &p : msg->lobby_messages().map()) { for (auto const &p : msg->lobby_messages().map()) {
PRINT_DEBUG("member data %s:%s\n", p.first.c_str(), p.second.c_str()); PRINT_DEBUG("Steam_MatchMaking member data %s:%s\n", p.first.c_str(), p.second.c_str());
auto result = caseinsensitive_find(member->values(), p.first); auto result = caseinsensitive_find(member->values(), p.first);
if (result == member->values().end()) { if (result == member->values().end()) {
(*member->mutable_values())[p.first] = p.second; (*member->mutable_values())[p.first] = p.second;
@ -1620,19 +1620,19 @@ void Callback(Common_Message *msg)
} }
if (msg->lobby_messages().type() == Lobby_Messages::LEAVE) { if (msg->lobby_messages().type() == Lobby_Messages::LEAVE) {
PRINT_DEBUG("LOBBY MESSAGE: LEAVE " "%" PRIu64 "\n", msg->source_id()); PRINT_DEBUG("Steam_MatchMaking LOBBY MESSAGE: LEAVE " "%" PRIu64 "\n", msg->source_id());
leave_lobby(lobby, (uint64)msg->source_id()); leave_lobby(lobby, (uint64)msg->source_id());
if (we_are_in_lobby) trigger_lobby_member_join_leave((uint64)lobby->room_id(), (uint64)msg->source_id(), true, true, 0.2); if (we_are_in_lobby) trigger_lobby_member_join_leave((uint64)lobby->room_id(), (uint64)msg->source_id(), true, true, 0.2);
} }
if (msg->lobby_messages().type() == Lobby_Messages::CHANGE_OWNER) { if (msg->lobby_messages().type() == Lobby_Messages::CHANGE_OWNER) {
PRINT_DEBUG("LOBBY MESSAGE: CHANGE OWNER\n"); PRINT_DEBUG("Steam_MatchMaking LOBBY MESSAGE: CHANGE OWNER\n");
lobby->set_owner(msg->lobby_messages().idata()); lobby->set_owner(msg->lobby_messages().idata());
if (we_are_in_lobby) trigger_lobby_dataupdate((uint64)lobby->room_id(), (uint64)lobby->room_id(), true); if (we_are_in_lobby) trigger_lobby_dataupdate((uint64)lobby->room_id(), (uint64)lobby->room_id(), true);
} }
if (msg->lobby_messages().type() == Lobby_Messages::CHAT_MESSAGE) { if (msg->lobby_messages().type() == Lobby_Messages::CHAT_MESSAGE) {
PRINT_DEBUG("LOBBY MESSAGE: CHAT MESSAGE\n"); PRINT_DEBUG("Steam_MatchMaking LOBBY MESSAGE: CHAT MESSAGE\n");
if (we_are_in_lobby) { if (we_are_in_lobby) {
struct Chat_Entry entry; struct Chat_Entry entry;
entry.type = k_EChatEntryTypeChatMsg; entry.type = k_EChatEntryTypeChatMsg;

16
dll/dll/steam_tv.h
View File

@ -31,7 +31,7 @@ public ISteamTV
public: public:
static void steam_callback(void *object, Common_Message *msg) static void steam_callback(void *object, Common_Message *msg)
{ {
PRINT_DEBUG("steam_tv_callback\n"); PRINT_DEBUG("TODO Steam_TV::steam_tv_callback\n");
Steam_TV *steam_parties = (Steam_TV *)object; Steam_TV *steam_parties = (Steam_TV *)object;
steam_parties->Callback(msg); steam_parties->Callback(msg);
@ -65,39 +65,39 @@ Steam_TV(class Settings *settings, class Networking *network, class SteamCallRes
bool IsBroadcasting(int *pnNumViewers) bool IsBroadcasting(int *pnNumViewers)
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_TV::%s\n", __FUNCTION__);
return false; return false;
} }
void AddBroadcastGameData(const char * pchKey, const char * pchValue) void AddBroadcastGameData(const char * pchKey, const char * pchValue)
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_TV::%s\n", __FUNCTION__);
} }
void RemoveBroadcastGameData(const char * pchKey) void RemoveBroadcastGameData(const char * pchKey)
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_TV::%s\n", __FUNCTION__);
} }
void AddTimelineMarker(const char * pchTemplateName, bool bPersistent, uint8 nColorR, uint8 nColorG, uint8 nColorB) void AddTimelineMarker(const char * pchTemplateName, bool bPersistent, uint8 nColorR, uint8 nColorG, uint8 nColorB)
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_TV::%s\n", __FUNCTION__);
} }
void RemoveTimelineMarker() void RemoveTimelineMarker()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_TV::%s\n", __FUNCTION__);
} }
uint32 AddRegion(const char * pchElementName, const char * pchTimelineDataSection, const SteamTVRegion_t * pSteamTVRegion, ESteamTVRegionBehavior eSteamTVRegionBehavior) uint32 AddRegion(const char * pchElementName, const char * pchTimelineDataSection, const SteamTVRegion_t * pSteamTVRegion, ESteamTVRegionBehavior eSteamTVRegionBehavior)
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_TV::%s\n", __FUNCTION__);
return 0; return 0;
} }
void RemoveRegion(uint32 unRegionHandle) void RemoveRegion(uint32 unRegionHandle)
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_TV::%s\n", __FUNCTION__);
} }
void RunCallbacks() void RunCallbacks()

48
dll/dll/steam_user.h
View File

@ -68,7 +68,7 @@ Steam_User(Settings *settings, Local_Storage *local_storage, class Networking *n
// this is only used internally by the API, and by a few select interfaces that support multi-user // this is only used internally by the API, and by a few select interfaces that support multi-user
HSteamUser GetHSteamUser() HSteamUser GetHSteamUser()
{ {
PRINT_DEBUG("GetHSteamUser\n"); PRINT_DEBUG("Steam_User::GetHSteamUser\n");
return CLIENT_HSTEAMUSER; return CLIENT_HSTEAMUSER;
} }
@ -112,7 +112,7 @@ CSteamID GetSteamID()
int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ) int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure )
{ {
PRINT_DEBUG("InitiateGameConnection %i %llu %u %u %u %p\n", cbMaxAuthBlob, steamIDGameServer.ConvertToUint64(), unIPServer, usPortServer, bSecure, pAuthBlob); PRINT_DEBUG("Steam_User::InitiateGameConnection %i %llu %u %u %u %p\n", cbMaxAuthBlob, steamIDGameServer.ConvertToUint64(), unIPServer, usPortServer, bSecure, pAuthBlob);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (cbMaxAuthBlob < INITIATE_GAME_CONNECTION_TICKET_SIZE) return 0; if (cbMaxAuthBlob < INITIATE_GAME_CONNECTION_TICKET_SIZE) return 0;
if (!pAuthBlob) return 0; if (!pAuthBlob) return 0;
@ -131,7 +131,7 @@ int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamID
// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call // needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer )
{ {
PRINT_DEBUG("TerminateGameConnection\n"); PRINT_DEBUG("Steam_User::TerminateGameConnection\n");
} }
// Legacy functions // Legacy functions
@ -139,7 +139,7 @@ void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer )
// used by only a few games to track usage events // used by only a few games to track usage events
void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo) void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo)
{ {
PRINT_DEBUG("TrackAppUsageEvent\n"); PRINT_DEBUG("Steam_User::TrackAppUsageEvent\n");
} }
void RefreshSteam2Login() void RefreshSteam2Login()
@ -151,7 +151,7 @@ void RefreshSteam2Login()
// this will usually be something like "C:\Progam Files\Steam\userdata\<SteamID>\<AppID>\local" // this will usually be something like "C:\Progam Files\Steam\userdata\<SteamID>\<AppID>\local"
bool GetUserDataFolder( char *pchBuffer, int cubBuffer ) bool GetUserDataFolder( char *pchBuffer, int cubBuffer )
{ {
PRINT_DEBUG("GetUserDataFolder\n"); PRINT_DEBUG("Steam_User::GetUserDataFolder\n");
if (!cubBuffer) return false; if (!cubBuffer) return false;
std::string user_data = local_storage->get_path(Local_Storage::user_data_storage); std::string user_data = local_storage->get_path(Local_Storage::user_data_storage);
@ -163,7 +163,7 @@ bool GetUserDataFolder( char *pchBuffer, int cubBuffer )
// Starts voice recording. Once started, use GetVoice() to get the data // Starts voice recording. Once started, use GetVoice() to get the data
void StartVoiceRecording( ) void StartVoiceRecording( )
{ {
PRINT_DEBUG("StartVoiceRecording\n"); PRINT_DEBUG("Steam_User::StartVoiceRecording\n");
last_get_voice = std::chrono::high_resolution_clock::now(); last_get_voice = std::chrono::high_resolution_clock::now();
recording = true; recording = true;
//TODO:fix //TODO:fix
@ -175,7 +175,7 @@ void StartVoiceRecording( )
// k_eVoiceResultNotRecording // k_eVoiceResultNotRecording
void StopVoiceRecording( ) void StopVoiceRecording( )
{ {
PRINT_DEBUG("StopVoiceRecording\n"); PRINT_DEBUG("Steam_User::StopVoiceRecording\n");
recording = false; recording = false;
} }
@ -185,7 +185,7 @@ void StopVoiceRecording( )
// below for further explanation of "uncompressed" data. // below for further explanation of "uncompressed" data.
EVoiceResult GetAvailableVoice( uint32 *pcbCompressed, uint32 *pcbUncompressed_Deprecated, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated ) EVoiceResult GetAvailableVoice( uint32 *pcbCompressed, uint32 *pcbUncompressed_Deprecated, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated )
{ {
PRINT_DEBUG("GetAvailableVoice\n"); PRINT_DEBUG("Steam_User::GetAvailableVoice\n");
if (pcbCompressed) *pcbCompressed = 0; if (pcbCompressed) *pcbCompressed = 0;
if (pcbUncompressed_Deprecated) *pcbUncompressed_Deprecated = 0; if (pcbUncompressed_Deprecated) *pcbUncompressed_Deprecated = 0;
if (!recording) return k_EVoiceResultNotRecording; if (!recording) return k_EVoiceResultNotRecording;
@ -225,7 +225,7 @@ EVoiceResult GetAvailableVoice(uint32 *pcbCompressed, uint32 *pcbUncompressed)
// using the DecompressVoice function below. // using the DecompressVoice function below.
EVoiceResult GetVoice( bool bWantCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, bool bWantUncompressed_Deprecated, void *pUncompressedDestBuffer_Deprecated , uint32 cbUncompressedDestBufferSize_Deprecated , uint32 *nUncompressBytesWritten_Deprecated , uint32 nUncompressedVoiceDesiredSampleRate_Deprecated ) EVoiceResult GetVoice( bool bWantCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, bool bWantUncompressed_Deprecated, void *pUncompressedDestBuffer_Deprecated , uint32 cbUncompressedDestBufferSize_Deprecated , uint32 *nUncompressBytesWritten_Deprecated , uint32 nUncompressedVoiceDesiredSampleRate_Deprecated )
{ {
PRINT_DEBUG("GetVoice\n"); PRINT_DEBUG("Steam_User::GetVoice\n");
if (!recording) return k_EVoiceResultNotRecording; if (!recording) return k_EVoiceResultNotRecording;
double seconds = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::high_resolution_clock::now() - last_get_voice).count(); double seconds = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::high_resolution_clock::now() - last_get_voice).count();
if (bWantCompressed) { if (bWantCompressed) {
@ -236,7 +236,7 @@ EVoiceResult GetVoice( bool bWantCompressed, void *pDestBuffer, uint32 cbDestBuf
} }
if (bWantUncompressed_Deprecated) { if (bWantUncompressed_Deprecated) {
PRINT_DEBUG("Wanted Uncompressed\n"); PRINT_DEBUG("Steam_User::GetVoice Wanted Uncompressed\n");
} }
last_get_voice = std::chrono::high_resolution_clock::now(); last_get_voice = std::chrono::high_resolution_clock::now();
@ -263,7 +263,7 @@ EVoiceResult GetCompressedVoice( void *pDestBuffer, uint32 cbDestBufferSize, uin
// It is suggested to start with a 20kb buffer and reallocate as necessary. // It is suggested to start with a 20kb buffer and reallocate as necessary.
EVoiceResult DecompressVoice( const void *pCompressed, uint32 cbCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, uint32 nDesiredSampleRate ) EVoiceResult DecompressVoice( const void *pCompressed, uint32 cbCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, uint32 nDesiredSampleRate )
{ {
PRINT_DEBUG("DecompressVoice\n"); PRINT_DEBUG("Steam_User::DecompressVoice\n");
if (!recording) return k_EVoiceResultNotRecording; if (!recording) return k_EVoiceResultNotRecording;
uint32 uncompressed = (double)cbCompressed * ((double)nDesiredSampleRate / 8192.0); uint32 uncompressed = (double)cbCompressed * ((double)nDesiredSampleRate / 8192.0);
if(nBytesWritten) *nBytesWritten = uncompressed; if(nBytesWritten) *nBytesWritten = uncompressed;
@ -294,7 +294,7 @@ EVoiceResult DecompressVoice( void *pCompressed, uint32 cbCompressed, void *pDes
// which is usually 48000 or 44100. // which is usually 48000 or 44100.
uint32 GetVoiceOptimalSampleRate() uint32 GetVoiceOptimalSampleRate()
{ {
PRINT_DEBUG("GetVoiceOptimalSampleRate\n"); PRINT_DEBUG("Steam_User::GetVoiceOptimalSampleRate\n");
return 48000; return 48000;
} }
@ -368,7 +368,7 @@ EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appI
// (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT. // (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT.
bool BIsBehindNAT() bool BIsBehindNAT()
{ {
PRINT_DEBUG("BIsBehindNAT\n"); PRINT_DEBUG("Steam_User::BIsBehindNAT\n");
return false; return false;
} }
@ -377,7 +377,7 @@ bool BIsBehindNAT()
// uint32 unIPServer, uint16 usPortServer - the IP address of the game server // uint32 unIPServer, uint16 usPortServer - the IP address of the game server
void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer ) void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer )
{ {
PRINT_DEBUG("AdvertiseGame\n"); PRINT_DEBUG("Steam_User::AdvertiseGame\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Gameserver *server = new Gameserver(); Gameserver *server = new Gameserver();
server->set_id(steamIDGameServer.ConvertToUint64()); server->set_id(steamIDGameServer.ConvertToUint64());
@ -468,14 +468,14 @@ bool GetEncryptedAppTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket )
// the user has can have two different badges for a series; the regular (max level 5) and the foil (max level 1) // the user has can have two different badges for a series; the regular (max level 5) and the foil (max level 1)
int GetGameBadgeLevel( int nSeries, bool bFoil ) int GetGameBadgeLevel( int nSeries, bool bFoil )
{ {
PRINT_DEBUG("GetGameBadgeLevel\n"); PRINT_DEBUG("Steam_User::GetGameBadgeLevel\n");
return 0; return 0;
} }
// gets the Steam Level of the user, as shown on their profile // gets the Steam Level of the user, as shown on their profile
int GetPlayerSteamLevel() int GetPlayerSteamLevel()
{ {
PRINT_DEBUG("GetPlayerSteamLevel\n"); PRINT_DEBUG("Steam_User::GetPlayerSteamLevel\n");
return 100; return 100;
} }
@ -492,42 +492,42 @@ int GetPlayerSteamLevel()
STEAM_CALL_RESULT( StoreAuthURLResponse_t ) STEAM_CALL_RESULT( StoreAuthURLResponse_t )
SteamAPICall_t RequestStoreAuthURL( const char *pchRedirectURL ) SteamAPICall_t RequestStoreAuthURL( const char *pchRedirectURL )
{ {
PRINT_DEBUG("RequestStoreAuthURL\n"); PRINT_DEBUG("Steam_User::RequestStoreAuthURL\n");
return 0; return 0;
} }
// gets whether the users phone number is verified // gets whether the users phone number is verified
bool BIsPhoneVerified() bool BIsPhoneVerified()
{ {
PRINT_DEBUG("BIsPhoneVerified\n"); PRINT_DEBUG("Steam_User::BIsPhoneVerified\n");
return true; return true;
} }
// gets whether the user has two factor enabled on their account // gets whether the user has two factor enabled on their account
bool BIsTwoFactorEnabled() bool BIsTwoFactorEnabled()
{ {
PRINT_DEBUG("BIsTwoFactorEnabled\n"); PRINT_DEBUG("Steam_User::BIsTwoFactorEnabled\n");
return true; return true;
} }
// gets whether the users phone number is identifying // gets whether the users phone number is identifying
bool BIsPhoneIdentifying() bool BIsPhoneIdentifying()
{ {
PRINT_DEBUG("BIsPhoneIdentifying\n"); PRINT_DEBUG("Steam_User::BIsPhoneIdentifying\n");
return false; return false;
} }
// gets whether the users phone number is awaiting (re)verification // gets whether the users phone number is awaiting (re)verification
bool BIsPhoneRequiringVerification() bool BIsPhoneRequiringVerification()
{ {
PRINT_DEBUG("BIsPhoneRequiringVerification\n"); PRINT_DEBUG("Steam_User::BIsPhoneRequiringVerification\n");
return false; return false;
} }
STEAM_CALL_RESULT( MarketEligibilityResponse_t ) STEAM_CALL_RESULT( MarketEligibilityResponse_t )
SteamAPICall_t GetMarketEligibility() SteamAPICall_t GetMarketEligibility()
{ {
PRINT_DEBUG("GetMarketEligibility\n"); PRINT_DEBUG("Steam_User::GetMarketEligibility\n");
return 0; return 0;
} }
@ -535,7 +535,7 @@ SteamAPICall_t GetMarketEligibility()
STEAM_CALL_RESULT( DurationControl_t ) STEAM_CALL_RESULT( DurationControl_t )
SteamAPICall_t GetDurationControl() SteamAPICall_t GetDurationControl()
{ {
PRINT_DEBUG("GetDurationControl\n"); PRINT_DEBUG("Steam_User::GetDurationControl\n");
return 0; return 0;
} }
@ -544,7 +544,7 @@ SteamAPICall_t GetDurationControl()
// playtime limits. // playtime limits.
bool BSetDurationControlOnlineState( EDurationControlOnlineState eNewState ) bool BSetDurationControlOnlineState( EDurationControlOnlineState eNewState )
{ {
PRINT_DEBUG("BSetDurationControlOnlineState\n"); PRINT_DEBUG("Steam_User::BSetDurationControlOnlineState\n");
return false; return false;
} }

88
dll/dll/steam_user_stats.h
View File

@ -176,7 +176,7 @@ std::vector<Steam_Leaderboard_Score> load_leaderboard_scores(std::string name)
i += 1; i += 1;
} }
PRINT_DEBUG("loaded leaderboard score %llu %u\n", score.steam_id.ConvertToUint64(), score.score); PRINT_DEBUG("Steam_User_Stats::loaded leaderboard score %llu %u\n", score.steam_id.ConvertToUint64(), score.score);
out.push_back(score); out.push_back(score);
} }
@ -295,7 +295,7 @@ bool RequestCurrentStats()
// Data accessors // Data accessors
bool GetStat( const char *pchName, int32 *pData ) bool GetStat( const char *pchName, int32 *pData )
{ {
PRINT_DEBUG("GetStat int32 %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::GetStat int32 %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!pchName || !pData) return false; if (!pchName || !pData) return false;
@ -332,7 +332,7 @@ bool GetStat( const char *pchName, int32 *pData )
bool GetStat( const char *pchName, float *pData ) bool GetStat( const char *pchName, float *pData )
{ {
PRINT_DEBUG("GetStat float %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::GetStat float %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!pchName || !pData) return false; if (!pchName || !pData) return false;
@ -371,7 +371,7 @@ bool GetStat( const char *pchName, float *pData )
// Set / update data // Set / update data
bool SetStat( const char *pchName, int32 nData ) bool SetStat( const char *pchName, int32 nData )
{ {
PRINT_DEBUG("SetStat int32 %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::SetStat int32 %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!pchName) return false; if (!pchName) return false;
@ -401,7 +401,7 @@ bool SetStat( const char *pchName, int32 nData )
bool SetStat( const char *pchName, float fData ) bool SetStat( const char *pchName, float fData )
{ {
PRINT_DEBUG("SetStat float %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::SetStat float %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!pchName) return false; if (!pchName) return false;
@ -431,7 +431,7 @@ bool SetStat( const char *pchName, float fData )
bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength ) bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength )
{ {
PRINT_DEBUG("UpdateAvgRateStat %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::UpdateAvgRateStat %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!pchName) return false; if (!pchName) return false;
@ -466,7 +466,7 @@ bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dS
// Achievement flag accessors // Achievement flag accessors
bool GetAchievement( const char *pchName, bool *pbAchieved ) bool GetAchievement( const char *pchName, bool *pbAchieved )
{ {
PRINT_DEBUG("GetAchievement %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::GetAchievement %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -490,7 +490,7 @@ bool GetAchievement( const char *pchName, bool *pbAchieved )
bool SetAchievement( const char *pchName ) bool SetAchievement( const char *pchName )
{ {
PRINT_DEBUG("SetAchievement %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::SetAchievement %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -521,7 +521,7 @@ bool SetAchievement( const char *pchName )
bool ClearAchievement( const char *pchName ) bool ClearAchievement( const char *pchName )
{ {
PRINT_DEBUG("ClearAchievement %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::ClearAchievement %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -548,7 +548,7 @@ bool ClearAchievement( const char *pchName )
// began tracking achievement unlock times (December 2009). Time is seconds since January 1, 1970. // began tracking achievement unlock times (December 2009). Time is seconds since January 1, 1970.
bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32 *punUnlockTime )
{ {
PRINT_DEBUG("GetAchievementAndUnlockTime\n"); PRINT_DEBUG("Steam_User_Stats::GetAchievementAndUnlockTime\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -581,7 +581,7 @@ bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32
// The stats should be re-iterated to keep in sync. // The stats should be re-iterated to keep in sync.
bool StoreStats() bool StoreStats()
{ {
PRINT_DEBUG("StoreStats\n"); PRINT_DEBUG("Steam_User_Stats::StoreStats\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
UserStatsStored_t data; UserStatsStored_t data;
@ -600,7 +600,7 @@ bool StoreStats()
// specified achievement. // specified achievement.
int GetAchievementIcon( const char *pchName ) int GetAchievementIcon( const char *pchName )
{ {
PRINT_DEBUG("GetAchievementIcon\n"); PRINT_DEBUG("Steam_User_Stats::GetAchievementIcon\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return 0; if (pchName == nullptr) return 0;
@ -629,7 +629,7 @@ std::string get_achievement_icon_name( const char *pchName, bool pbAchieved )
// - "hidden" for retrieving if an achievement is hidden (returns "0" when not hidden, "1" when hidden) // - "hidden" for retrieving if an achievement is hidden (returns "0" when not hidden, "1" when hidden)
const char * GetAchievementDisplayAttribute( const char *pchName, const char *pchKey ) const char * GetAchievementDisplayAttribute( const char *pchName, const char *pchKey )
{ {
PRINT_DEBUG("GetAchievementDisplayAttribute %s %s\n", pchName, pchKey); PRINT_DEBUG("Steam_User_Stats::GetAchievementDisplayAttribute %s %s\n", pchName, pchKey);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return ""; if (pchName == nullptr) return "";
@ -671,7 +671,7 @@ const char * GetAchievementDisplayAttribute( const char *pchName, const char *pc
// Calling this w/ N out of N progress will NOT set the achievement, the game must still do that. // Calling this w/ N out of N progress will NOT set the achievement, the game must still do that.
bool IndicateAchievementProgress( const char *pchName, uint32 nCurProgress, uint32 nMaxProgress ) bool IndicateAchievementProgress( const char *pchName, uint32 nCurProgress, uint32 nMaxProgress )
{ {
PRINT_DEBUG("IndicateAchievementProgress %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::IndicateAchievementProgress %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -718,7 +718,7 @@ bool IndicateAchievementProgress( const char *pchName, uint32 nCurProgress, uint
// list of existing achievements compiled into them // list of existing achievements compiled into them
uint32 GetNumAchievements() uint32 GetNumAchievements()
{ {
PRINT_DEBUG("GetNumAchievements\n"); PRINT_DEBUG("Steam_User_Stats::GetNumAchievements\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return defined_achievements.size(); return defined_achievements.size();
} }
@ -726,7 +726,7 @@ uint32 GetNumAchievements()
// Get achievement name iAchievement in [0,GetNumAchievements) // Get achievement name iAchievement in [0,GetNumAchievements)
const char * GetAchievementName( uint32 iAchievement ) const char * GetAchievementName( uint32 iAchievement )
{ {
PRINT_DEBUG("GetAchievementName\n"); PRINT_DEBUG("Steam_User_Stats::GetAchievementName\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (iAchievement >= sorted_achievement_names.size()) { if (iAchievement >= sorted_achievement_names.size()) {
return ""; return "";
@ -765,7 +765,7 @@ SteamAPICall_t RequestUserStats( CSteamID steamIDUser )
// requests stat information for a user, usable after a successful call to RequestUserStats() // requests stat information for a user, usable after a successful call to RequestUserStats()
bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData )
{ {
PRINT_DEBUG("GetUserStat %s %llu\n", pchName, steamIDUser.ConvertToUint64()); PRINT_DEBUG("Steam_User_Stats::GetUserStat %s %llu\n", pchName, steamIDUser.ConvertToUint64());
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -781,7 +781,7 @@ bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData )
bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData )
{ {
PRINT_DEBUG("GetUserStat %s %llu\n", pchName, steamIDUser.ConvertToUint64()); PRINT_DEBUG("Steam_User_Stats::GetUserStat %s %llu\n", pchName, steamIDUser.ConvertToUint64());
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -797,7 +797,7 @@ bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData )
bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved )
{ {
PRINT_DEBUG("GetUserAchievement %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::GetUserAchievement %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -812,7 +812,7 @@ bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchi
// See notes for GetAchievementAndUnlockTime above // See notes for GetAchievementAndUnlockTime above
bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime )
{ {
PRINT_DEBUG("GetUserAchievementAndUnlockTime %s\n", pchName); PRINT_DEBUG("Steam_User_Stats::GetUserAchievementAndUnlockTime %s\n", pchName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName == nullptr) return false; if (pchName == nullptr) return false;
@ -827,7 +827,7 @@ bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName,
// Reset stats // Reset stats
bool ResetAllStats( bool bAchievementsToo ) bool ResetAllStats( bool bAchievementsToo )
{ {
PRINT_DEBUG("ResetAllStats\n"); PRINT_DEBUG("Steam_User_Stats::ResetAllStats\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
//TODO //TODO
if (bAchievementsToo) { if (bAchievementsToo) {
@ -848,7 +848,7 @@ bool ResetAllStats( bool bAchievementsToo )
STEAM_CALL_RESULT(LeaderboardFindResult_t) STEAM_CALL_RESULT(LeaderboardFindResult_t)
SteamAPICall_t FindOrCreateLeaderboard( const char *pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) SteamAPICall_t FindOrCreateLeaderboard( const char *pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType )
{ {
PRINT_DEBUG("FindOrCreateLeaderboard %s\n", pchLeaderboardName); PRINT_DEBUG("Steam_User_Stats::FindOrCreateLeaderboard %s\n", pchLeaderboardName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!pchLeaderboardName) { if (!pchLeaderboardName) {
LeaderboardFindResult_t data; LeaderboardFindResult_t data;
@ -888,7 +888,7 @@ SteamAPICall_t FindOrCreateLeaderboard( const char *pchLeaderboardName, ELeaderb
STEAM_CALL_RESULT( LeaderboardFindResult_t ) STEAM_CALL_RESULT( LeaderboardFindResult_t )
SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName ) SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName )
{ {
PRINT_DEBUG("FindLeaderboard %s\n", pchLeaderboardName); PRINT_DEBUG("Steam_User_Stats::FindLeaderboard %s\n", pchLeaderboardName);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!pchLeaderboardName) { if (!pchLeaderboardName) {
LeaderboardFindResult_t data; LeaderboardFindResult_t data;
@ -915,7 +915,7 @@ SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName )
// returns the name of a leaderboard // returns the name of a leaderboard
const char * GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) const char * GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard )
{ {
PRINT_DEBUG("GetLeaderboardName\n"); PRINT_DEBUG("Steam_User_Stats::GetLeaderboardName\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return ""; if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return "";
@ -926,7 +926,7 @@ const char * GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard )
// returns the total number of entries in a leaderboard, as of the last request // returns the total number of entries in a leaderboard, as of the last request
int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard )
{ {
PRINT_DEBUG("GetLeaderboardEntryCount\n"); PRINT_DEBUG("Steam_User_Stats::GetLeaderboardEntryCount\n");
return 0; return 0;
} }
@ -934,7 +934,7 @@ int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard )
// returns the sort method of the leaderboard // returns the sort method of the leaderboard
ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard )
{ {
PRINT_DEBUG("GetLeaderboardSortMethod\n"); PRINT_DEBUG("Steam_User_Stats::GetLeaderboardSortMethod\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_ELeaderboardSortMethodNone; if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_ELeaderboardSortMethodNone;
return leaderboards[hSteamLeaderboard - 1].sort_method; return leaderboards[hSteamLeaderboard - 1].sort_method;
@ -944,7 +944,7 @@ ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeader
// returns the display type of the leaderboard // returns the display type of the leaderboard
ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard )
{ {
PRINT_DEBUG("GetLeaderboardDisplayType\n"); PRINT_DEBUG("Steam_User_Stats::GetLeaderboardDisplayType\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_ELeaderboardDisplayTypeNone; if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_ELeaderboardDisplayTypeNone;
return leaderboards[hSteamLeaderboard - 1].display_type; return leaderboards[hSteamLeaderboard - 1].display_type;
@ -962,7 +962,7 @@ ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLead
STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t ) STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
SteamAPICall_t DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) SteamAPICall_t DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd )
{ {
PRINT_DEBUG("DownloadLeaderboardEntries %llu %i %i %i\n", hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd); PRINT_DEBUG("Steam_User_Stats::DownloadLeaderboardEntries %llu %i %i %i\n", hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_uAPICallInvalid; //might return callresult even if hSteamLeaderboard is invalid if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_uAPICallInvalid; //might return callresult even if hSteamLeaderboard is invalid
@ -981,7 +981,7 @@ STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard,
STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers ) STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers )
{ {
PRINT_DEBUG("DownloadLeaderboardEntriesForUsers %i %llu\n", cUsers, cUsers > 0 ? prgUsers[0].ConvertToUint64() : 0); PRINT_DEBUG("Steam_User_Stats::DownloadLeaderboardEntriesForUsers %i %llu\n", cUsers, cUsers > 0 ? prgUsers[0].ConvertToUint64() : 0);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_uAPICallInvalid; //might return callresult even if hSteamLeaderboard is invalid if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_uAPICallInvalid; //might return callresult even if hSteamLeaderboard is invalid
@ -1016,7 +1016,7 @@ SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLead
// once you've accessed all the entries, the data will be free'd, and the SteamLeaderboardEntries_t handle will become invalid // once you've accessed all the entries, the data will be free'd, and the SteamLeaderboardEntries_t handle will become invalid
bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax )
{ {
PRINT_DEBUG("GetDownloadedLeaderboardEntry\n"); PRINT_DEBUG("Steam_User_Stats::GetDownloadedLeaderboardEntry\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (hSteamLeaderboardEntries > leaderboards.size() || hSteamLeaderboardEntries <= 0) return false; if (hSteamLeaderboardEntries > leaderboards.size() || hSteamLeaderboardEntries <= 0) return false;
if (index > 0) return false; if (index > 0) return false;
@ -1041,7 +1041,7 @@ bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardE
STEAM_CALL_RESULT( LeaderboardScoreUploaded_t ) STEAM_CALL_RESULT( LeaderboardScoreUploaded_t )
SteamAPICall_t UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 *pScoreDetails, int cScoreDetailsCount ) SteamAPICall_t UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 *pScoreDetails, int cScoreDetailsCount )
{ {
PRINT_DEBUG("UploadLeaderboardScore %i\n", nScore); PRINT_DEBUG("Steam_User_Stats::UploadLeaderboardScore %i\n", nScore);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_uAPICallInvalid; //TODO: might return callresult even if hSteamLeaderboard is invalid if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) return k_uAPICallInvalid; //TODO: might return callresult even if hSteamLeaderboard is invalid
@ -1093,7 +1093,7 @@ SteamAPICall_t UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, int
STEAM_CALL_RESULT( LeaderboardUGCSet_t ) STEAM_CALL_RESULT( LeaderboardUGCSet_t )
SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC )
{ {
PRINT_DEBUG("AttachLeaderboardUGC\n"); PRINT_DEBUG("Steam_User_Stats::AttachLeaderboardUGC\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
LeaderboardUGCSet_t data = {}; LeaderboardUGCSet_t data = {};
if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) { if (hSteamLeaderboard > leaderboards.size() || hSteamLeaderboard <= 0) {
@ -1112,7 +1112,7 @@ SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHa
STEAM_CALL_RESULT( NumberOfCurrentPlayers_t ) STEAM_CALL_RESULT( NumberOfCurrentPlayers_t )
SteamAPICall_t GetNumberOfCurrentPlayers() SteamAPICall_t GetNumberOfCurrentPlayers()
{ {
PRINT_DEBUG("GetNumberOfCurrentPlayers\n"); PRINT_DEBUG("Steam_User_Stats::GetNumberOfCurrentPlayers\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
NumberOfCurrentPlayers_t data; NumberOfCurrentPlayers_t data;
data.m_bSuccess = 1; data.m_bSuccess = 1;
@ -1127,7 +1127,7 @@ SteamAPICall_t GetNumberOfCurrentPlayers()
STEAM_CALL_RESULT( GlobalAchievementPercentagesReady_t ) STEAM_CALL_RESULT( GlobalAchievementPercentagesReady_t )
SteamAPICall_t RequestGlobalAchievementPercentages() SteamAPICall_t RequestGlobalAchievementPercentages()
{ {
PRINT_DEBUG("RequestGlobalAchievementPercentages\n"); PRINT_DEBUG("Steam_User_Stats::RequestGlobalAchievementPercentages\n");
return 0; return 0;
} }
@ -1137,7 +1137,7 @@ SteamAPICall_t RequestGlobalAchievementPercentages()
// percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback). // percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback).
int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved )
{ {
PRINT_DEBUG("GetMostAchievedAchievementInfo\n"); PRINT_DEBUG("Steam_User_Stats::GetMostAchievedAchievementInfo\n");
return -1; return -1;
} }
@ -1147,7 +1147,7 @@ int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *p
// achievement has been iterated. // achievement has been iterated.
int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved )
{ {
PRINT_DEBUG("GetNextMostAchievedAchievementInfo\n"); PRINT_DEBUG("Steam_User_Stats::GetNextMostAchievedAchievementInfo\n");
return -1; return -1;
} }
@ -1155,7 +1155,7 @@ int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, ui
// Returns the percentage of users who have achieved the specified achievement. // Returns the percentage of users who have achieved the specified achievement.
bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent ) bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent )
{ {
PRINT_DEBUG("GetAchievementAchievedPercent\n"); PRINT_DEBUG("Steam_User_Stats::GetAchievementAchievedPercent\n");
return false; return false;
} }
@ -1167,7 +1167,7 @@ bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent )
STEAM_CALL_RESULT( GlobalStatsReceived_t ) STEAM_CALL_RESULT( GlobalStatsReceived_t )
SteamAPICall_t RequestGlobalStats( int nHistoryDays ) SteamAPICall_t RequestGlobalStats( int nHistoryDays )
{ {
PRINT_DEBUG("RequestGlobalStats %i\n", nHistoryDays); PRINT_DEBUG("Steam_User_Stats::RequestGlobalStats %i\n", nHistoryDays);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
GlobalStatsReceived_t data; GlobalStatsReceived_t data;
data.m_nGameID = settings->get_local_game_id().ToUint64(); data.m_nGameID = settings->get_local_game_id().ToUint64();
@ -1179,13 +1179,13 @@ SteamAPICall_t RequestGlobalStats( int nHistoryDays )
// Gets the lifetime totals for an aggregated stat // Gets the lifetime totals for an aggregated stat
bool GetGlobalStat( const char *pchStatName, int64 *pData ) bool GetGlobalStat( const char *pchStatName, int64 *pData )
{ {
PRINT_DEBUG("GetGlobalStat %s\n", pchStatName); PRINT_DEBUG("Steam_User_Stats::GetGlobalStat %s\n", pchStatName);
return false; return false;
} }
bool GetGlobalStat( const char *pchStatName, double *pData ) bool GetGlobalStat( const char *pchStatName, double *pData )
{ {
PRINT_DEBUG("GetGlobalStat %s\n", pchStatName); PRINT_DEBUG("Steam_User_Stats::GetGlobalStat %s\n", pchStatName);
return false; return false;
} }
@ -1196,13 +1196,13 @@ bool GetGlobalStat( const char *pchStatName, double *pData )
// elements actually set. // elements actually set.
int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) int64 *pData, uint32 cubData ) int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) int64 *pData, uint32 cubData )
{ {
PRINT_DEBUG("GetGlobalStatHistory int64 %s\n", pchStatName); PRINT_DEBUG("Steam_User_Stats::GetGlobalStatHistory int64 %s\n", pchStatName);
return 0; return 0;
} }
int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) double *pData, uint32 cubData ) int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData) double *pData, uint32 cubData )
{ {
PRINT_DEBUG("GetGlobalStatHistory double %s\n", pchStatName); PRINT_DEBUG("Steam_User_Stats::GetGlobalStatHistory double %s\n", pchStatName);
return 0; return 0;
} }
@ -1211,13 +1211,13 @@ int32 GetGlobalStatHistory( const char *pchStatName, STEAM_ARRAY_COUNT(cubData)
// have been made, to show a progress notification to the user. // have been made, to show a progress notification to the user.
bool GetAchievementProgressLimits( const char *pchName, int32 *pnMinProgress, int32 *pnMaxProgress ) bool GetAchievementProgressLimits( const char *pchName, int32 *pnMinProgress, int32 *pnMaxProgress )
{ {
PRINT_DEBUG("GetAchievementProgressLimits int\n"); PRINT_DEBUG("Steam_User_Stats::GetAchievementProgressLimits int\n");
return false; return false;
} }
bool GetAchievementProgressLimits( const char *pchName, float *pfMinProgress, float *pfMaxProgress ) bool GetAchievementProgressLimits( const char *pchName, float *pfMinProgress, float *pfMaxProgress )
{ {
PRINT_DEBUG("GetAchievementProgressLimits float\n"); PRINT_DEBUG("Steam_User_Stats::GetAchievementProgressLimits float\n");
return false; return false;
} }

101
dll/dll/steam_utils.h
View File

@ -19,8 +19,6 @@
#include "local_storage.h" #include "local_storage.h"
#include "overlay/steam_overlay.h" #include "overlay/steam_overlay.h"
static std::chrono::time_point<std::chrono::steady_clock> app_initialized_time = std::chrono::steady_clock::now();
class Steam_Utils : class Steam_Utils :
public ISteamUtils002, public ISteamUtils002,
@ -48,13 +46,15 @@ Steam_Utils(Settings *settings, class SteamCallResults *callback_results, Steam_
// return the number of seconds since the user // return the number of seconds since the user
uint32 GetSecondsSinceAppActive() uint32 GetSecondsSinceAppActive()
{ {
PRINT_DEBUG("GetSecondsSinceAppActive\n"); PRINT_DEBUG("Steam_Utils::GetSecondsSinceAppActive\n");
return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - app_initialized_time).count(); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - startup_time).count();
} }
uint32 GetSecondsSinceComputerActive() uint32 GetSecondsSinceComputerActive()
{ {
PRINT_DEBUG("GetSecondsSinceComputerActive\n"); PRINT_DEBUG("Steam_Utils::GetSecondsSinceComputerActive\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return GetSecondsSinceAppActive() + 2000; return GetSecondsSinceAppActive() + 2000;
} }
@ -62,7 +62,8 @@ uint32 GetSecondsSinceComputerActive()
// the universe this client is connecting to // the universe this client is connecting to
EUniverse GetConnectedUniverse() EUniverse GetConnectedUniverse()
{ {
PRINT_DEBUG("GetConnectedUniverse\n"); PRINT_DEBUG("Steam_Utils::GetConnectedUniverse\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return k_EUniversePublic; return k_EUniversePublic;
} }
@ -70,9 +71,9 @@ EUniverse GetConnectedUniverse()
// Steam server time. Number of seconds since January 1, 1970, GMT (i.e unix time) // Steam server time. Number of seconds since January 1, 1970, GMT (i.e unix time)
uint32 GetServerRealTime() uint32 GetServerRealTime()
{ {
PRINT_DEBUG("GetServerRealTime\n"); PRINT_DEBUG("Steam_Utils::GetServerRealTime\n");
uint32 server_time = std::chrono::duration_cast<std::chrono::duration<uint32>>(std::chrono::system_clock::now().time_since_epoch()).count(); uint32 server_time = std::chrono::duration_cast<std::chrono::duration<uint32>>(std::chrono::system_clock::now().time_since_epoch()).count();
PRINT_DEBUG("Time %u\n", server_time); PRINT_DEBUG("Steam_Utils::GetServerRealTime Time %u\n", server_time);
return server_time; return server_time;
} }
@ -81,14 +82,15 @@ uint32 GetServerRealTime()
// e.g "US" or "UK". // e.g "US" or "UK".
const char *GetIPCountry() const char *GetIPCountry()
{ {
PRINT_DEBUG("GetIPCountry\n"); PRINT_DEBUG("Steam_Utils::GetIPCountry\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return "US"; return "US";
} }
// returns true if the image exists, and valid sizes were filled out // returns true if the image exists, and valid sizes were filled out
bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight )
{ {
PRINT_DEBUG("GetImageSize %i\n", iImage); PRINT_DEBUG("Steam_Utils::GetImageSize %i\n", iImage);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!iImage || !pnWidth || !pnHeight) return false; if (!iImage || !pnWidth || !pnHeight) return false;
@ -106,7 +108,7 @@ bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight )
// the destination buffer size should be 4 * height * width * sizeof(char) // the destination buffer size should be 4 * height * width * sizeof(char)
bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize )
{ {
PRINT_DEBUG("GetImageRGBA %i\n", iImage); PRINT_DEBUG("Steam_Utils::GetImageRGBA %i\n", iImage);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!iImage || !pubDest || !nDestBufferSize) return false; if (!iImage || !pubDest || !nDestBufferSize) return false;
@ -123,7 +125,8 @@ bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize )
// returns the IP of the reporting server for valve - currently only used in Source engine games // returns the IP of the reporting server for valve - currently only used in Source engine games
bool GetCSERIPPort( uint32 *unIP, uint16 *usPort ) bool GetCSERIPPort( uint32 *unIP, uint16 *usPort )
{ {
PRINT_DEBUG("GetCSERIPPort\n"); PRINT_DEBUG("Steam_Utils::GetCSERIPPort\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -131,7 +134,8 @@ bool GetCSERIPPort( uint32 *unIP, uint16 *usPort )
// return the amount of battery power left in the current system in % [0..100], 255 for being on AC power // return the amount of battery power left in the current system in % [0..100], 255 for being on AC power
uint8 GetCurrentBatteryPower() uint8 GetCurrentBatteryPower()
{ {
PRINT_DEBUG("GetCurrentBatteryPower\n"); PRINT_DEBUG("Steam_Utils::GetCurrentBatteryPower\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return 255; return 255;
} }
@ -139,7 +143,7 @@ uint8 GetCurrentBatteryPower()
// returns the appID of the current process // returns the appID of the current process
uint32 GetAppID() uint32 GetAppID()
{ {
PRINT_DEBUG("GetAppID\n"); PRINT_DEBUG("Steam_Utils::GetAppID\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return settings->get_local_game_id().AppID(); return settings->get_local_game_id().AppID();
} }
@ -149,7 +153,7 @@ uint32 GetAppID()
// This position is per-game and if this function is called from outside of a game context it will do nothing. // This position is per-game and if this function is called from outside of a game context it will do nothing.
void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition ) void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition )
{ {
PRINT_DEBUG("SetOverlayNotificationPosition\n"); PRINT_DEBUG("Steam_Utils::SetOverlayNotificationPosition\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
overlay->SetNotificationPosition(eNotificationPosition); overlay->SetNotificationPosition(eNotificationPosition);
} }
@ -159,7 +163,7 @@ void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition
// can be used directly, but more commonly used via the callback dispatch API (see steam_api.h) // can be used directly, but more commonly used via the callback dispatch API (see steam_api.h)
bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, bool *pbFailed ) bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, bool *pbFailed )
{ {
PRINT_DEBUG("IsAPICallCompleted: %llu\n", hSteamAPICall); PRINT_DEBUG("Steam_Utils::IsAPICallCompleted: %llu\n", hSteamAPICall);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (hSteamAPICall == 1) { //bug ? soul calibur 6 calls this function with the return value 1 of Steam_User_Stats::RequestCurrentStats and expects this function to return true if (hSteamAPICall == 1) { //bug ? soul calibur 6 calls this function with the return value 1 of Steam_User_Stats::RequestCurrentStats and expects this function to return true
if (pbFailed) *pbFailed = true; if (pbFailed) *pbFailed = true;
@ -173,17 +177,18 @@ bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, bool *pbFailed )
ESteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall ) ESteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall )
{ {
PRINT_DEBUG("GetAPICallFailureReason\n"); PRINT_DEBUG("Steam_Utils::GetAPICallFailureReason\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return k_ESteamAPICallFailureNone; return k_ESteamAPICallFailureNone;
} }
bool GetAPICallResult( SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed ) bool GetAPICallResult( SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed )
{ {
PRINT_DEBUG("GetAPICallResult %llu %i %i %p\n", hSteamAPICall, cubCallback, iCallbackExpected, pbFailed); PRINT_DEBUG("Steam_Utils::GetAPICallResult %llu %i %i %p\n", hSteamAPICall, cubCallback, iCallbackExpected, pbFailed);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (callback_results->callback_result(hSteamAPICall, pCallback, cubCallback)) { if (callback_results->callback_result(hSteamAPICall, pCallback, cubCallback)) {
if (pbFailed) *pbFailed = false; if (pbFailed) *pbFailed = false;
PRINT_DEBUG("GetAPICallResult Succeeded\n"); PRINT_DEBUG("Steam_Utils::GetAPICallResult Succeeded\n");
return true; return true;
} else { } else {
return false; return false;
@ -204,7 +209,8 @@ STEAM_PRIVATE_API( void RunFrame()
// control how often you do them. // control how often you do them.
uint32 GetIPCCallCount() uint32 GetIPCCallCount()
{ {
PRINT_DEBUG("GetIPCCallCount\n"); PRINT_DEBUG("Steam_Utils::GetIPCCallCount\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
static int i = 0; static int i = 0;
i += 123; i += 123;
return i; //TODO return i; //TODO
@ -225,7 +231,7 @@ void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction )
// start & hook the game process, so this function will initially return false while the overlay is loading. // start & hook the game process, so this function will initially return false while the overlay is loading.
bool IsOverlayEnabled() bool IsOverlayEnabled()
{ {
PRINT_DEBUG("IsOverlayEnabled\n"); PRINT_DEBUG("Steam_Utils::IsOverlayEnabled\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return overlay->Ready(); return overlay->Ready();
} }
@ -242,7 +248,7 @@ bool IsOverlayEnabled()
// refresh the screen with Present or SwapBuffers to allow the overlay to do it's work. // refresh the screen with Present or SwapBuffers to allow the overlay to do it's work.
bool BOverlayNeedsPresent() bool BOverlayNeedsPresent()
{ {
PRINT_DEBUG("BOverlayNeedsPresent\n"); PRINT_DEBUG("Steam_Utils::BOverlayNeedsPresent\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return overlay->NeedPresent(); return overlay->NeedPresent();
} }
@ -259,7 +265,7 @@ bool BOverlayNeedsPresent()
STEAM_CALL_RESULT( CheckFileSignature_t ) STEAM_CALL_RESULT( CheckFileSignature_t )
SteamAPICall_t CheckFileSignature( const char *szFileName ) SteamAPICall_t CheckFileSignature( const char *szFileName )
{ {
PRINT_DEBUG("CheckFileSignature\n"); PRINT_DEBUG("Steam_Utils::CheckFileSignature\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
CheckFileSignature_t data; CheckFileSignature_t data;
data.m_eCheckFileSignature = k_ECheckFileSignatureValidSignature; data.m_eCheckFileSignature = k_ECheckFileSignatureValidSignature;
@ -270,7 +276,8 @@ SteamAPICall_t CheckFileSignature( const char *szFileName )
// Activates the Big Picture text input dialog which only supports gamepad input // Activates the Big Picture text input dialog which only supports gamepad input
bool ShowGamepadTextInput( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32 unCharMax, const char *pchExistingText ) bool ShowGamepadTextInput( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32 unCharMax, const char *pchExistingText )
{ {
PRINT_DEBUG("ShowGamepadTextInput\n"); PRINT_DEBUG("Steam_Utils::ShowGamepadTextInput\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -284,13 +291,15 @@ bool ShowGamepadTextInput( EGamepadTextInputMode eInputMode, EGamepadTextInputLi
// Returns previously entered text & length // Returns previously entered text & length
uint32 GetEnteredGamepadTextLength() uint32 GetEnteredGamepadTextLength()
{ {
PRINT_DEBUG("GetEnteredGamepadTextLength\n"); PRINT_DEBUG("Steam_Utils::GetEnteredGamepadTextLength\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return 0; return 0;
} }
bool GetEnteredGamepadTextInput( char *pchText, uint32 cchText ) bool GetEnteredGamepadTextInput( char *pchText, uint32 cchText )
{ {
PRINT_DEBUG("GetEnteredGamepadTextInput\n"); PRINT_DEBUG("Steam_Utils::GetEnteredGamepadTextInput\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -298,7 +307,7 @@ bool GetEnteredGamepadTextInput( char *pchText, uint32 cchText )
// returns the language the steam client is running in, you probably want ISteamApps::GetCurrentGameLanguage instead, this is for very special usage cases // returns the language the steam client is running in, you probably want ISteamApps::GetCurrentGameLanguage instead, this is for very special usage cases
const char *GetSteamUILanguage() const char *GetSteamUILanguage()
{ {
PRINT_DEBUG("GetSteamUILanguage\n"); PRINT_DEBUG("Steam_Utils::GetSteamUILanguage\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return settings->get_language(); return settings->get_language();
} }
@ -307,7 +316,7 @@ const char *GetSteamUILanguage()
// returns true if Steam itself is running in VR mode // returns true if Steam itself is running in VR mode
bool IsSteamRunningInVR() bool IsSteamRunningInVR()
{ {
PRINT_DEBUG("IsSteamRunningInVR\n"); PRINT_DEBUG("Steam_Utils::IsSteamRunningInVR\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -316,7 +325,7 @@ bool IsSteamRunningInVR()
// Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition. // Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition.
void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset ) void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset )
{ {
PRINT_DEBUG("SetOverlayNotificationInset\n"); PRINT_DEBUG("Steam_Utils::SetOverlayNotificationInset\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
overlay->SetNotificationInset(nHorizontalInset, nVerticalInset); overlay->SetNotificationInset(nHorizontalInset, nVerticalInset);
} }
@ -327,7 +336,7 @@ void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset )
// a game can be added as a non-steam game to the developers library to test this feature // a game can be added as a non-steam game to the developers library to test this feature
bool IsSteamInBigPictureMode() bool IsSteamInBigPictureMode()
{ {
PRINT_DEBUG("IsSteamInBigPictureMode\n"); PRINT_DEBUG("Steam_Utils::IsSteamInBigPictureMode\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -336,14 +345,15 @@ bool IsSteamInBigPictureMode()
// ask SteamUI to create and render its OpenVR dashboard // ask SteamUI to create and render its OpenVR dashboard
void StartVRDashboard() void StartVRDashboard()
{ {
PRINT_DEBUG("StartVRDashboard\n"); PRINT_DEBUG("Steam_Utils::StartVRDashboard\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
} }
// Returns true if the HMD content will be streamed via Steam In-Home Streaming // Returns true if the HMD content will be streamed via Steam In-Home Streaming
bool IsVRHeadsetStreamingEnabled() bool IsVRHeadsetStreamingEnabled()
{ {
PRINT_DEBUG("IsVRHeadsetStreamingEnabled\n"); PRINT_DEBUG("Steam_Utils::IsVRHeadsetStreamingEnabled\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -356,13 +366,14 @@ bool IsVRHeadsetStreamingEnabled()
// (this is useful for games that have asymmetric multiplayer gameplay) // (this is useful for games that have asymmetric multiplayer gameplay)
void SetVRHeadsetStreamingEnabled( bool bEnabled ) void SetVRHeadsetStreamingEnabled( bool bEnabled )
{ {
PRINT_DEBUG("SetVRHeadsetStreamingEnabled\n"); PRINT_DEBUG("Steam_Utils::SetVRHeadsetStreamingEnabled\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex);
} }
// Returns whether this steam client is a Steam China specific client, vs the global client. // Returns whether this steam client is a Steam China specific client, vs the global client.
bool IsSteamChinaLauncher() bool IsSteamChinaLauncher()
{ {
PRINT_DEBUG("IsSteamChinaLauncher\n"); PRINT_DEBUG("Steam_Utils::IsSteamChinaLauncher\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -371,7 +382,7 @@ bool IsSteamChinaLauncher()
// Returns false if filtering is unavailable for the language the user is currently running in. // Returns false if filtering is unavailable for the language the user is currently running in.
bool InitFilterText() bool InitFilterText()
{ {
PRINT_DEBUG("InitFilterText old\n"); PRINT_DEBUG("Steam_Utils::InitFilterText old\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -381,7 +392,7 @@ bool InitFilterText()
// Returns false if filtering is unavailable for the language the user is currently running in. // Returns false if filtering is unavailable for the language the user is currently running in.
bool InitFilterText( uint32 unFilterOptions ) bool InitFilterText( uint32 unFilterOptions )
{ {
PRINT_DEBUG("InitFilterText\n"); PRINT_DEBUG("Steam_Utils::InitFilterText\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -394,7 +405,7 @@ bool InitFilterText( uint32 unFilterOptions )
// Returns the number of characters (not bytes) filtered. // Returns the number of characters (not bytes) filtered.
int FilterText( char* pchOutFilteredText, uint32 nByteSizeOutFilteredText, const char * pchInputMessage, bool bLegalOnly ) int FilterText( char* pchOutFilteredText, uint32 nByteSizeOutFilteredText, const char * pchInputMessage, bool bLegalOnly )
{ {
PRINT_DEBUG("FilterText old\n"); PRINT_DEBUG("Steam_Utils::FilterText old\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return FilterText(k_ETextFilteringContextUnknown, CSteamID(), pchInputMessage, pchOutFilteredText, nByteSizeOutFilteredText ); return FilterText(k_ETextFilteringContextUnknown, CSteamID(), pchInputMessage, pchOutFilteredText, nByteSizeOutFilteredText );
} }
@ -408,7 +419,7 @@ int FilterText( char* pchOutFilteredText, uint32 nByteSizeOutFilteredText, const
// Returns the number of characters (not bytes) filtered // Returns the number of characters (not bytes) filtered
int FilterText( ETextFilteringContext eContext, CSteamID sourceSteamID, const char *pchInputMessage, char *pchOutFilteredText, uint32 nByteSizeOutFilteredText ) int FilterText( ETextFilteringContext eContext, CSteamID sourceSteamID, const char *pchInputMessage, char *pchOutFilteredText, uint32 nByteSizeOutFilteredText )
{ {
PRINT_DEBUG("FilterText\n"); PRINT_DEBUG("Steam_Utils::FilterText\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!nByteSizeOutFilteredText) return 0; if (!nByteSizeOutFilteredText) return 0;
unsigned len = strlen(pchInputMessage); unsigned len = strlen(pchInputMessage);
@ -427,7 +438,7 @@ int FilterText( ETextFilteringContext eContext, CSteamID sourceSteamID, const ch
// This does NOT tell you if the Steam client is currently connected to Steam via ipv6. // This does NOT tell you if the Steam client is currently connected to Steam via ipv6.
ESteamIPv6ConnectivityState GetIPv6ConnectivityState( ESteamIPv6ConnectivityProtocol eProtocol ) ESteamIPv6ConnectivityState GetIPv6ConnectivityState( ESteamIPv6ConnectivityProtocol eProtocol )
{ {
PRINT_DEBUG("GetIPv6ConnectivityState\n"); PRINT_DEBUG("Steam_Utils::GetIPv6ConnectivityState\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return k_ESteamIPv6ConnectivityState_Unknown; return k_ESteamIPv6ConnectivityState_Unknown;
} }
@ -435,7 +446,8 @@ ESteamIPv6ConnectivityState GetIPv6ConnectivityState( ESteamIPv6ConnectivityProt
// returns true if currently running on the Steam Deck device // returns true if currently running on the Steam Deck device
bool IsSteamRunningOnSteamDeck() bool IsSteamRunningOnSteamDeck()
{ {
PRINT_DEBUG("%s %i\n", __FUNCTION__, (int)settings->steam_deck); PRINT_DEBUG("Steam_Utils::%s %i\n", __FUNCTION__, (int)settings->steam_deck);
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return settings->steam_deck; return settings->steam_deck;
} }
@ -443,19 +455,22 @@ bool IsSteamRunningOnSteamDeck()
// The text field position is specified in pixels relative the origin of the game window and is used to position the floating keyboard in a way that doesn't cover the text field // The text field position is specified in pixels relative the origin of the game window and is used to position the floating keyboard in a way that doesn't cover the text field
bool ShowFloatingGamepadTextInput( EFloatingGamepadTextInputMode eKeyboardMode, int nTextFieldXPosition, int nTextFieldYPosition, int nTextFieldWidth, int nTextFieldHeight ) bool ShowFloatingGamepadTextInput( EFloatingGamepadTextInputMode eKeyboardMode, int nTextFieldXPosition, int nTextFieldYPosition, int nTextFieldWidth, int nTextFieldHeight )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("Steam_Utils::%s\n", __FUNCTION__);
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
// In game launchers that don't have controller support you can call this to have Steam Input translate the controller input into mouse/kb to navigate the launcher // In game launchers that don't have controller support you can call this to have Steam Input translate the controller input into mouse/kb to navigate the launcher
void SetGameLauncherMode( bool bLauncherMode ) void SetGameLauncherMode( bool bLauncherMode )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("Steam_Utils::%s\n", __FUNCTION__);
std::lock_guard<std::recursive_mutex> lock(global_mutex);
} }
bool DismissFloatingGamepadTextInput() bool DismissFloatingGamepadTextInput()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("Steam_Utils::%s\n", __FUNCTION__);
std::lock_guard<std::recursive_mutex> lock(global_mutex);
return true; return true;
} }

68
dll/steam_apps.cpp
View File

@ -30,43 +30,43 @@ Steam_Apps::Steam_Apps(Settings *settings, class SteamCallResults *callback_resu
int Steam_Apps::GetAppData( AppId_t nAppID, const char *pchKey, char *pchValue, int cchValueMax ) int Steam_Apps::GetAppData( AppId_t nAppID, const char *pchKey, char *pchValue, int cchValueMax )
{ {
//TODO //TODO
PRINT_DEBUG("GetAppData %u %s\n", nAppID, pchKey); PRINT_DEBUG("Steam_Apps::GetAppData %u %s\n", nAppID, pchKey);
return 0; return 0;
} }
bool Steam_Apps::BIsSubscribed() bool Steam_Apps::BIsSubscribed()
{ {
PRINT_DEBUG("BIsSubscribed\n"); PRINT_DEBUG("Steam_Apps::BIsSubscribed\n");
return true; return true;
} }
bool Steam_Apps::BIsLowViolence() bool Steam_Apps::BIsLowViolence()
{ {
PRINT_DEBUG("BIsLowViolence\n"); PRINT_DEBUG("Steam_Apps::BIsLowViolence\n");
return false; return false;
} }
bool Steam_Apps::BIsCybercafe() bool Steam_Apps::BIsCybercafe()
{ {
PRINT_DEBUG("BIsCybercafe\n"); PRINT_DEBUG("Steam_Apps::BIsCybercafe\n");
return false; return false;
} }
bool Steam_Apps::BIsVACBanned() bool Steam_Apps::BIsVACBanned()
{ {
PRINT_DEBUG("BIsVACBanned\n"); PRINT_DEBUG("Steam_Apps::BIsVACBanned\n");
return false; return false;
} }
const char *Steam_Apps::GetCurrentGameLanguage() const char *Steam_Apps::GetCurrentGameLanguage()
{ {
PRINT_DEBUG("GetCurrentGameLanguage\n"); PRINT_DEBUG("Steam_Apps::GetCurrentGameLanguage\n");
return settings->get_language(); return settings->get_language();
} }
const char *Steam_Apps::GetAvailableGameLanguages() const char *Steam_Apps::GetAvailableGameLanguages()
{ {
PRINT_DEBUG("GetAvailableGameLanguages\n"); PRINT_DEBUG("Steam_Apps::GetAvailableGameLanguages\n");
//TODO? //TODO?
return settings->get_language(); return settings->get_language();
} }
@ -75,7 +75,7 @@ const char *Steam_Apps::GetAvailableGameLanguages()
// only use this member if you need to check ownership of another game related to yours, a demo for example // only use this member if you need to check ownership of another game related to yours, a demo for example
bool Steam_Apps::BIsSubscribedApp( AppId_t appID ) bool Steam_Apps::BIsSubscribedApp( AppId_t appID )
{ {
PRINT_DEBUG("BIsSubscribedApp %u\n", appID); PRINT_DEBUG("Steam_Apps::BIsSubscribedApp %u\n", appID);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (appID == 0) return true; //I think appid 0 is always owned if (appID == 0) return true; //I think appid 0 is always owned
if (appID == UINT32_MAX) return false; // check Steam_Apps::BIsAppInstalled() if (appID == UINT32_MAX) return false; // check Steam_Apps::BIsAppInstalled()
@ -87,7 +87,7 @@ bool Steam_Apps::BIsSubscribedApp( AppId_t appID )
// Takes AppID of DLC and checks if the user owns the DLC & if the DLC is installed // Takes AppID of DLC and checks if the user owns the DLC & if the DLC is installed
bool Steam_Apps::BIsDlcInstalled( AppId_t appID ) bool Steam_Apps::BIsDlcInstalled( AppId_t appID )
{ {
PRINT_DEBUG("BIsDlcInstalled %u\n", appID); PRINT_DEBUG("Steam_Apps::BIsDlcInstalled %u\n", appID);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (appID == 0) return true; if (appID == 0) return true;
if (appID == UINT32_MAX) return false; // check Steam_Apps::BIsAppInstalled() if (appID == UINT32_MAX) return false; // check Steam_Apps::BIsAppInstalled()
@ -99,7 +99,7 @@ bool Steam_Apps::BIsDlcInstalled( AppId_t appID )
// returns the Unix time of the purchase of the app // returns the Unix time of the purchase of the app
uint32 Steam_Apps::GetEarliestPurchaseUnixTime( AppId_t nAppID ) uint32 Steam_Apps::GetEarliestPurchaseUnixTime( AppId_t nAppID )
{ {
PRINT_DEBUG("GetEarliestPurchaseUnixTime\n"); PRINT_DEBUG("Steam_Apps::GetEarliestPurchaseUnixTime\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (nAppID == 0) return 0; //TODO is this correct? if (nAppID == 0) return 0; //TODO is this correct?
if (nAppID == UINT32_MAX) return 0; // check Steam_Apps::BIsAppInstalled() TODO is this correct? if (nAppID == UINT32_MAX) return 0; // check Steam_Apps::BIsAppInstalled() TODO is this correct?
@ -122,7 +122,7 @@ uint32 Steam_Apps::GetEarliestPurchaseUnixTime( AppId_t nAppID )
// Before using, please ask your Valve technical contact how to package and secure your free weekened // Before using, please ask your Valve technical contact how to package and secure your free weekened
bool Steam_Apps::BIsSubscribedFromFreeWeekend() bool Steam_Apps::BIsSubscribedFromFreeWeekend()
{ {
PRINT_DEBUG("BIsSubscribedFromFreeWeekend\n"); PRINT_DEBUG("Steam_Apps::BIsSubscribedFromFreeWeekend\n");
return false; return false;
} }
@ -130,7 +130,7 @@ bool Steam_Apps::BIsSubscribedFromFreeWeekend()
// Returns the number of DLC pieces for the running app // Returns the number of DLC pieces for the running app
int Steam_Apps::GetDLCCount() int Steam_Apps::GetDLCCount()
{ {
PRINT_DEBUG("GetDLCCount\n"); PRINT_DEBUG("Steam_Apps::GetDLCCount\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return settings->DLCCount(); return settings->DLCCount();
} }
@ -139,7 +139,7 @@ int Steam_Apps::GetDLCCount()
// Returns metadata for DLC by index, of range [0, GetDLCCount()] // Returns metadata for DLC by index, of range [0, GetDLCCount()]
bool Steam_Apps::BGetDLCDataByIndex( int iDLC, AppId_t *pAppID, bool *pbAvailable, char *pchName, int cchNameBufferSize ) bool Steam_Apps::BGetDLCDataByIndex( int iDLC, AppId_t *pAppID, bool *pbAvailable, char *pchName, int cchNameBufferSize )
{ {
PRINT_DEBUG("BGetDLCDataByIndex\n"); PRINT_DEBUG("Steam_Apps::BGetDLCDataByIndex\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
AppId_t appid; AppId_t appid;
bool available; bool available;
@ -165,14 +165,14 @@ bool Steam_Apps::BGetDLCDataByIndex( int iDLC, AppId_t *pAppID, bool *pbAvailabl
// Install/Uninstall control for optional DLC // Install/Uninstall control for optional DLC
void Steam_Apps::InstallDLC( AppId_t nAppID ) void Steam_Apps::InstallDLC( AppId_t nAppID )
{ {
PRINT_DEBUG("InstallDLC\n"); PRINT_DEBUG("Steam_Apps::InstallDLC\n");
// we lock here because the API is supposed to modify the DLC list // we lock here because the API is supposed to modify the DLC list
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
} }
void Steam_Apps::UninstallDLC( AppId_t nAppID ) void Steam_Apps::UninstallDLC( AppId_t nAppID )
{ {
PRINT_DEBUG("UninstallDLC\n"); PRINT_DEBUG("Steam_Apps::UninstallDLC\n");
// we lock here because the API is supposed to modify the DLC list // we lock here because the API is supposed to modify the DLC list
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
} }
@ -207,7 +207,7 @@ static void FillProofOfPurchaseKey( AppProofOfPurchaseKeyResponse_t& data, AppId
// the key is available (which may be immediately). // the key is available (which may be immediately).
void Steam_Apps::RequestAppProofOfPurchaseKey( AppId_t nAppID ) void Steam_Apps::RequestAppProofOfPurchaseKey( AppId_t nAppID )
{ {
PRINT_DEBUG("TODO RequestAppProofOfPurchaseKey\n"); PRINT_DEBUG("Steam_Apps::TODO RequestAppProofOfPurchaseKey\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
AppProofOfPurchaseKeyResponse_t data{}; AppProofOfPurchaseKeyResponse_t data{};
@ -231,7 +231,7 @@ void Steam_Apps::RequestAppProofOfPurchaseKey( AppId_t nAppID )
// https://partner.steamgames.com/doc/api/ISteamApps // https://partner.steamgames.com/doc/api/ISteamApps
bool Steam_Apps::GetCurrentBetaName( char *pchName, int cchNameBufferSize ) bool Steam_Apps::GetCurrentBetaName( char *pchName, int cchNameBufferSize )
{ {
PRINT_DEBUG("GetCurrentBetaName %i\n", cchNameBufferSize); PRINT_DEBUG("Steam_Apps::GetCurrentBetaName %i\n", cchNameBufferSize);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (pchName && cchNameBufferSize > settings->current_branch_name.size()) { if (pchName && cchNameBufferSize > settings->current_branch_name.size()) {
memcpy(pchName, settings->current_branch_name.c_str(), settings->current_branch_name.size()); memcpy(pchName, settings->current_branch_name.c_str(), settings->current_branch_name.size());
@ -243,7 +243,7 @@ bool Steam_Apps::GetCurrentBetaName( char *pchName, int cchNameBufferSize )
// signal Steam that game files seems corrupt or missing // signal Steam that game files seems corrupt or missing
bool Steam_Apps::MarkContentCorrupt( bool bMissingFilesOnly ) bool Steam_Apps::MarkContentCorrupt( bool bMissingFilesOnly )
{ {
PRINT_DEBUG("MarkContentCorrupt\n"); PRINT_DEBUG("Steam_Apps::MarkContentCorrupt\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
//TODO: warn user //TODO: warn user
return true; return true;
@ -252,7 +252,7 @@ bool Steam_Apps::MarkContentCorrupt( bool bMissingFilesOnly )
// return installed depots in mount order // return installed depots in mount order
uint32 Steam_Apps::GetInstalledDepots( AppId_t appID, DepotId_t *pvecDepots, uint32 cMaxDepots ) uint32 Steam_Apps::GetInstalledDepots( AppId_t appID, DepotId_t *pvecDepots, uint32 cMaxDepots )
{ {
PRINT_DEBUG("GetInstalledDepots %u, %u\n", appID, cMaxDepots); PRINT_DEBUG("Steam_Apps::GetInstalledDepots %u, %u\n", appID, cMaxDepots);
//TODO not sure about the behavior of this function, I didn't actually test this. //TODO not sure about the behavior of this function, I didn't actually test this.
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!pvecDepots) return 0; if (!pvecDepots) return 0;
@ -264,14 +264,14 @@ uint32 Steam_Apps::GetInstalledDepots( AppId_t appID, DepotId_t *pvecDepots, uin
uint32 Steam_Apps::GetInstalledDepots( DepotId_t *pvecDepots, uint32 cMaxDepots ) uint32 Steam_Apps::GetInstalledDepots( DepotId_t *pvecDepots, uint32 cMaxDepots )
{ {
PRINT_DEBUG("GetInstalledDepots old\n"); PRINT_DEBUG("Steam_Apps::GetInstalledDepots old\n");
return GetInstalledDepots( settings->get_local_game_id().AppID(), pvecDepots, cMaxDepots ); return GetInstalledDepots( settings->get_local_game_id().AppID(), pvecDepots, cMaxDepots );
} }
// returns current app install folder for AppID, returns folder name length // returns current app install folder for AppID, returns folder name length
uint32 Steam_Apps::GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize ) uint32 Steam_Apps::GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize )
{ {
PRINT_DEBUG("GetAppInstallDir %u %p %u\n", appID, pchFolder, cchFolderBufferSize); PRINT_DEBUG("Steam_Apps::GetAppInstallDir %u %p %u\n", appID, pchFolder, cchFolderBufferSize);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
//TODO return real path instead of dll path //TODO return real path instead of dll path
std::string installed_path = settings->getAppInstallPath(appID); std::string installed_path = settings->getAppInstallPath(appID);
@ -279,7 +279,7 @@ uint32 Steam_Apps::GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchF
if (installed_path.size() == 0) { if (installed_path.size() == 0) {
std::string dll_path = get_full_program_path(); std::string dll_path = get_full_program_path();
std::string current_path = get_current_path(); std::string current_path = get_current_path();
PRINT_DEBUG("paths %s %s\n", dll_path.c_str(), current_path.c_str()); PRINT_DEBUG("Steam_Apps::paths %s %s\n", dll_path.c_str(), current_path.c_str());
//Just pick the smallest path, it has the most chances of being the good one //Just pick the smallest path, it has the most chances of being the good one
if (dll_path.size() > current_path.size() && current_path.size()) { if (dll_path.size() > current_path.size() && current_path.size()) {
@ -289,7 +289,7 @@ uint32 Steam_Apps::GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchF
} }
} }
PRINT_DEBUG("path %s\n", installed_path.c_str()); PRINT_DEBUG("Steam_Apps::path %s\n", installed_path.c_str());
if (cchFolderBufferSize && pchFolder) { if (cchFolderBufferSize && pchFolder) {
snprintf(pchFolder, cchFolderBufferSize, "%s", installed_path.c_str()); snprintf(pchFolder, cchFolderBufferSize, "%s", installed_path.c_str());
} }
@ -302,7 +302,7 @@ uint32 Steam_Apps::GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchF
// https://partner.steamgames.com/doc/api/ISteamApps // https://partner.steamgames.com/doc/api/ISteamApps
bool Steam_Apps::BIsAppInstalled( AppId_t appID ) bool Steam_Apps::BIsAppInstalled( AppId_t appID )
{ {
PRINT_DEBUG("BIsAppInstalled %u\n", appID); PRINT_DEBUG("Steam_Apps::BIsAppInstalled %u\n", appID);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
// "0 Base Goldsource Shared Binaries" // "0 Base Goldsource Shared Binaries"
@ -324,7 +324,7 @@ bool Steam_Apps::BIsAppInstalled( AppId_t appID )
// returns the SteamID of the original owner. If different from current user, it's borrowed // returns the SteamID of the original owner. If different from current user, it's borrowed
CSteamID Steam_Apps::GetAppOwner() CSteamID Steam_Apps::GetAppOwner()
{ {
PRINT_DEBUG("GetAppOwner\n"); PRINT_DEBUG("Steam_Apps::GetAppOwner\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return settings->get_local_steam_id(); return settings->get_local_steam_id();
} }
@ -335,7 +335,7 @@ CSteamID Steam_Apps::GetAppOwner()
// but it is advised that you not param names beginning with an underscore for your own features. // but it is advised that you not param names beginning with an underscore for your own features.
const char *Steam_Apps::GetLaunchQueryParam( const char *pchKey ) const char *Steam_Apps::GetLaunchQueryParam( const char *pchKey )
{ {
PRINT_DEBUG("GetLaunchQueryParam\n"); PRINT_DEBUG("Steam_Apps::GetLaunchQueryParam\n");
return ""; return "";
} }
@ -343,7 +343,7 @@ const char *Steam_Apps::GetLaunchQueryParam( const char *pchKey )
// get download progress for optional DLC // get download progress for optional DLC
bool Steam_Apps::GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) bool Steam_Apps::GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloaded, uint64 *punBytesTotal )
{ {
PRINT_DEBUG("GetDlcDownloadProgress\n"); PRINT_DEBUG("Steam_Apps::GetDlcDownloadProgress\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -352,7 +352,7 @@ bool Steam_Apps::GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloa
// return the buildid of this app, may change at any time based on backend updates to the game // return the buildid of this app, may change at any time based on backend updates to the game
int Steam_Apps::GetAppBuildId() int Steam_Apps::GetAppBuildId()
{ {
PRINT_DEBUG("GetAppBuildId\n"); PRINT_DEBUG("Steam_Apps::GetAppBuildId\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return this->settings->build_id; return this->settings->build_id;
} }
@ -364,7 +364,7 @@ int Steam_Apps::GetAppBuildId()
// member is k_uAppIdInvalid (zero). // member is k_uAppIdInvalid (zero).
void Steam_Apps::RequestAllProofOfPurchaseKeys() void Steam_Apps::RequestAllProofOfPurchaseKeys()
{ {
PRINT_DEBUG("TODO RequestAllProofOfPurchaseKeys\n"); PRINT_DEBUG("Steam_Apps::TODO RequestAllProofOfPurchaseKeys\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
// current app // current app
{ {
@ -399,7 +399,7 @@ void Steam_Apps::RequestAllProofOfPurchaseKeys()
STEAM_CALL_RESULT( FileDetailsResult_t ) STEAM_CALL_RESULT( FileDetailsResult_t )
SteamAPICall_t Steam_Apps::GetFileDetails( const char* pszFileName ) SteamAPICall_t Steam_Apps::GetFileDetails( const char* pszFileName )
{ {
PRINT_DEBUG("GetFileDetails %s\n", pszFileName); PRINT_DEBUG("Steam_Apps::GetFileDetails %s\n", pszFileName);
FileDetailsResult_t data = {}; FileDetailsResult_t data = {};
//TODO? this function should only return found if file is actually part of the steam depots //TODO? this function should only return found if file is actually part of the steam depots
if (file_exists_(pszFileName)) { if (file_exists_(pszFileName)) {
@ -428,14 +428,14 @@ SteamAPICall_t Steam_Apps::GetFileDetails( const char* pszFileName )
// If game was already running and launched again, the NewUrlLaunchParameters_t will be fired. // If game was already running and launched again, the NewUrlLaunchParameters_t will be fired.
int Steam_Apps::GetLaunchCommandLine( char *pszCommandLine, int cubCommandLine ) int Steam_Apps::GetLaunchCommandLine( char *pszCommandLine, int cubCommandLine )
{ {
PRINT_DEBUG("TODO GetLaunchCommandLine\n"); PRINT_DEBUG("Steam_Apps::TODO GetLaunchCommandLine\n");
return 0; return 0;
} }
// Check if user borrowed this game via Family Sharing, If true, call GetAppOwner() to get the lender SteamID // Check if user borrowed this game via Family Sharing, If true, call GetAppOwner() to get the lender SteamID
bool Steam_Apps::BIsSubscribedFromFamilySharing() bool Steam_Apps::BIsSubscribedFromFamilySharing()
{ {
PRINT_DEBUG("BIsSubscribedFromFamilySharing\n"); PRINT_DEBUG("Steam_Apps::BIsSubscribedFromFamilySharing\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -443,7 +443,7 @@ bool Steam_Apps::BIsSubscribedFromFamilySharing()
// check if game is a timed trial with limited playtime // check if game is a timed trial with limited playtime
bool Steam_Apps::BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPlayed ) bool Steam_Apps::BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPlayed )
{ {
PRINT_DEBUG("BIsTimedTrial\n"); PRINT_DEBUG("Steam_Apps::BIsTimedTrial\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -451,7 +451,7 @@ bool Steam_Apps::BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPla
// set current DLC AppID being played (or 0 if none). Allows Steam to track usage of major DLC extensions // set current DLC AppID being played (or 0 if none). Allows Steam to track usage of major DLC extensions
bool Steam_Apps::SetDlcContext( AppId_t nAppID ) bool Steam_Apps::SetDlcContext( AppId_t nAppID )
{ {
PRINT_DEBUG("SetDlcContext %u\n", nAppID); PRINT_DEBUG("Steam_Apps::SetDlcContext %u\n", nAppID);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return true; return true;
} }

102
dll/steam_gameserver.cpp
View File

@ -47,7 +47,7 @@ std::vector<std::pair<CSteamID, Gameserver_Player_Info_t>>* Steam_GameServer::ge
/// This is called by SteamGameServer_Init, and you will usually not need to call it directly /// This is called by SteamGameServer_Init, and you will usually not need to call it directly
bool Steam_GameServer::InitGameServer( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char *pchVersionString ) bool Steam_GameServer::InitGameServer( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char *pchVersionString )
{ {
PRINT_DEBUG("InitGameServer\n"); PRINT_DEBUG("Steam_GameServer::InitGameServer\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (logged_in) return false; // may not be changed after logged in. if (logged_in) return false; // may not be changed after logged in.
@ -59,7 +59,7 @@ bool Steam_GameServer::InitGameServer( uint32 unIP, uint16 usGamePort, uint16 us
try { try {
server_data.set_version(std::stoi(version)); server_data.set_version(std::stoi(version));
} catch (...) { } catch (...) {
PRINT_DEBUG("InitGameServer: not a number: %s\n", pchVersionString); PRINT_DEBUG("Steam_GameServer::InitGameServer: not a number: %s\n", pchVersionString);
server_data.set_version(0); server_data.set_version(0);
} }
@ -86,7 +86,7 @@ bool Steam_GameServer::InitGameServer( uint32 unIP, uint16 usGamePort, uint16 us
/// It's a required field, but will eventually will go away, and the AppID will be used for this purpose. /// It's a required field, but will eventually will go away, and the AppID will be used for this purpose.
void Steam_GameServer::SetProduct( const char *pszProduct ) void Steam_GameServer::SetProduct( const char *pszProduct )
{ {
PRINT_DEBUG("SetProduct\n"); PRINT_DEBUG("Steam_GameServer::SetProduct\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
// pszGameDescription should be used instead of pszProduct for accurate information // pszGameDescription should be used instead of pszProduct for accurate information
// Example: 'Counter-Strike: Source' instead of 'cstrike' // Example: 'Counter-Strike: Source' instead of 'cstrike'
@ -98,7 +98,7 @@ void Steam_GameServer::SetProduct( const char *pszProduct )
/// This is a required field, but it will go away eventually, as the data should be determined from the AppID. /// This is a required field, but it will go away eventually, as the data should be determined from the AppID.
void Steam_GameServer::SetGameDescription( const char *pszGameDescription ) void Steam_GameServer::SetGameDescription( const char *pszGameDescription )
{ {
PRINT_DEBUG("SetGameDescription\n"); PRINT_DEBUG("Steam_GameServer::SetGameDescription\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_game_description(pszGameDescription); server_data.set_game_description(pszGameDescription);
//server_data.set_product(pszGameDescription); //server_data.set_product(pszGameDescription);
@ -111,7 +111,7 @@ void Steam_GameServer::SetGameDescription( const char *pszGameDescription )
/// @see k_cbMaxGameServerGameDir /// @see k_cbMaxGameServerGameDir
void Steam_GameServer::SetModDir( const char *pszModDir ) void Steam_GameServer::SetModDir( const char *pszModDir )
{ {
PRINT_DEBUG("SetModDir\n"); PRINT_DEBUG("Steam_GameServer::SetModDir\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_mod_dir(pszModDir); server_data.set_mod_dir(pszModDir);
} }
@ -120,7 +120,7 @@ void Steam_GameServer::SetModDir( const char *pszModDir )
/// Is this is a dedicated server? The default value is false. /// Is this is a dedicated server? The default value is false.
void Steam_GameServer::SetDedicatedServer( bool bDedicated ) void Steam_GameServer::SetDedicatedServer( bool bDedicated )
{ {
PRINT_DEBUG("SetDedicatedServer\n"); PRINT_DEBUG("Steam_GameServer::SetDedicatedServer\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_dedicated_server(bDedicated); server_data.set_dedicated_server(bDedicated);
} }
@ -138,7 +138,7 @@ void Steam_GameServer::SetDedicatedServer( bool bDedicated )
/// @see SteamServersDisconnected_t /// @see SteamServersDisconnected_t
void Steam_GameServer::LogOn( const char *pszToken ) void Steam_GameServer::LogOn( const char *pszToken )
{ {
PRINT_DEBUG("LogOn %s\n", pszToken); PRINT_DEBUG("Steam_GameServer::LogOn %s\n", pszToken);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
call_servers_connected = true; call_servers_connected = true;
logged_in = true; logged_in = true;
@ -149,7 +149,7 @@ void Steam_GameServer::LogOn(
const char *pszPassword const char *pszPassword
) )
{ {
PRINT_DEBUG("LogOn %s %s\n", pszAccountName, pszPassword); PRINT_DEBUG("Steam_GameServer::LogOn %s %s\n", pszAccountName, pszPassword);
LogOn(pszAccountName); LogOn(pszAccountName);
} }
@ -159,7 +159,7 @@ void Steam_GameServer::LogOn(
/// but this is no longer the case. /// but this is no longer the case.
void Steam_GameServer::LogOnAnonymous() void Steam_GameServer::LogOnAnonymous()
{ {
PRINT_DEBUG("LogOnAnonymous\n"); PRINT_DEBUG("Steam_GameServer::LogOnAnonymous\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
call_servers_connected = true; call_servers_connected = true;
logged_in = true; logged_in = true;
@ -167,14 +167,14 @@ void Steam_GameServer::LogOnAnonymous()
void Steam_GameServer::LogOn() void Steam_GameServer::LogOn()
{ {
PRINT_DEBUG("LogOn\n"); PRINT_DEBUG("Steam_GameServer::LogOn\n");
LogOnAnonymous(); LogOnAnonymous();
} }
/// Begin process of logging game server out of steam /// Begin process of logging game server out of steam
void Steam_GameServer::LogOff() void Steam_GameServer::LogOff()
{ {
PRINT_DEBUG("LogOff\n"); PRINT_DEBUG("Steam_GameServer::LogOff\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (logged_in) { if (logged_in) {
call_servers_disconnected = true; call_servers_disconnected = true;
@ -194,7 +194,7 @@ bool Steam_GameServer::BLoggedOn()
bool Steam_GameServer::BSecure() bool Steam_GameServer::BSecure()
{ {
PRINT_DEBUG("BSecure\n"); PRINT_DEBUG("Steam_GameServer::BSecure\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (!policy_response_called) { if (!policy_response_called) {
server_data.set_secure(0); server_data.set_secure(0);
@ -218,7 +218,7 @@ CSteamID Steam_GameServer::GetSteamID()
/// Only returns true once per request. /// Only returns true once per request.
bool Steam_GameServer::WasRestartRequested() bool Steam_GameServer::WasRestartRequested()
{ {
PRINT_DEBUG("WasRestartRequested\n"); PRINT_DEBUG("Steam_GameServer::WasRestartRequested\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -231,7 +231,7 @@ bool Steam_GameServer::WasRestartRequested()
/// Max player count that will be reported to server browser and client queries /// Max player count that will be reported to server browser and client queries
void Steam_GameServer::SetMaxPlayerCount( int cPlayersMax ) void Steam_GameServer::SetMaxPlayerCount( int cPlayersMax )
{ {
PRINT_DEBUG("SetMaxPlayerCount\n"); PRINT_DEBUG("Steam_GameServer::SetMaxPlayerCount\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_max_player_count(cPlayersMax); server_data.set_max_player_count(cPlayersMax);
} }
@ -240,7 +240,7 @@ void Steam_GameServer::SetMaxPlayerCount( int cPlayersMax )
/// Number of bots. Default value is zero /// Number of bots. Default value is zero
void Steam_GameServer::SetBotPlayerCount( int cBotplayers ) void Steam_GameServer::SetBotPlayerCount( int cBotplayers )
{ {
PRINT_DEBUG("SetBotPlayerCount\n"); PRINT_DEBUG("Steam_GameServer::SetBotPlayerCount\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_bot_player_count(cBotplayers); server_data.set_bot_player_count(cBotplayers);
} }
@ -251,7 +251,7 @@ void Steam_GameServer::SetBotPlayerCount( int cBotplayers )
/// @see k_cbMaxGameServerName /// @see k_cbMaxGameServerName
void Steam_GameServer::SetServerName( const char *pszServerName ) void Steam_GameServer::SetServerName( const char *pszServerName )
{ {
PRINT_DEBUG("SetServerName\n"); PRINT_DEBUG("Steam_GameServer::SetServerName\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_server_name(pszServerName); server_data.set_server_name(pszServerName);
} }
@ -262,7 +262,7 @@ void Steam_GameServer::SetServerName( const char *pszServerName )
/// @see k_cbMaxGameServerName /// @see k_cbMaxGameServerName
void Steam_GameServer::SetMapName( const char *pszMapName ) void Steam_GameServer::SetMapName( const char *pszMapName )
{ {
PRINT_DEBUG("SetMapName\n"); PRINT_DEBUG("Steam_GameServer::SetMapName\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_map_name(pszMapName); server_data.set_map_name(pszMapName);
} }
@ -271,7 +271,7 @@ void Steam_GameServer::SetMapName( const char *pszMapName )
/// Let people know if your server will require a password /// Let people know if your server will require a password
void Steam_GameServer::SetPasswordProtected( bool bPasswordProtected ) void Steam_GameServer::SetPasswordProtected( bool bPasswordProtected )
{ {
PRINT_DEBUG("SetPasswordProtected\n"); PRINT_DEBUG("Steam_GameServer::SetPasswordProtected\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_password_protected(bPasswordProtected); server_data.set_password_protected(bPasswordProtected);
} }
@ -281,7 +281,7 @@ void Steam_GameServer::SetPasswordProtected( bool bPasswordProtected )
/// is not used. /// is not used.
void Steam_GameServer::SetSpectatorPort( uint16 unSpectatorPort ) void Steam_GameServer::SetSpectatorPort( uint16 unSpectatorPort )
{ {
PRINT_DEBUG("SetSpectatorPort\n"); PRINT_DEBUG("Steam_GameServer::SetSpectatorPort\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_spectator_port(unSpectatorPort); server_data.set_spectator_port(unSpectatorPort);
} }
@ -292,7 +292,7 @@ void Steam_GameServer::SetSpectatorPort( uint16 unSpectatorPort )
/// @see k_cbMaxGameServerMapName /// @see k_cbMaxGameServerMapName
void Steam_GameServer::SetSpectatorServerName( const char *pszSpectatorServerName ) void Steam_GameServer::SetSpectatorServerName( const char *pszSpectatorServerName )
{ {
PRINT_DEBUG("SetSpectatorServerName\n"); PRINT_DEBUG("Steam_GameServer::SetSpectatorServerName\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_spectator_server_name(pszSpectatorServerName); server_data.set_spectator_server_name(pszSpectatorServerName);
} }
@ -301,7 +301,7 @@ void Steam_GameServer::SetSpectatorServerName( const char *pszSpectatorServerNam
/// Call this to clear the whole list of key/values that are sent in rules queries. /// Call this to clear the whole list of key/values that are sent in rules queries.
void Steam_GameServer::ClearAllKeyValues() void Steam_GameServer::ClearAllKeyValues()
{ {
PRINT_DEBUG("ClearAllKeyValues\n"); PRINT_DEBUG("Steam_GameServer::ClearAllKeyValues\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.clear_values(); server_data.clear_values();
} }
@ -310,7 +310,7 @@ void Steam_GameServer::ClearAllKeyValues()
/// Call this to add/update a key/value pair. /// Call this to add/update a key/value pair.
void Steam_GameServer::SetKeyValue( const char *pKey, const char *pValue ) void Steam_GameServer::SetKeyValue( const char *pKey, const char *pValue )
{ {
PRINT_DEBUG("SetKeyValue %s %s\n", pKey, pValue); PRINT_DEBUG("Steam_GameServer::SetKeyValue %s %s\n", pKey, pValue);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
(*server_data.mutable_values())[std::string(pKey)] = std::string(pValue); (*server_data.mutable_values())[std::string(pKey)] = std::string(pValue);
} }
@ -322,7 +322,7 @@ void Steam_GameServer::SetKeyValue( const char *pKey, const char *pValue )
/// @see k_cbMaxGameServerTags /// @see k_cbMaxGameServerTags
void Steam_GameServer::SetGameTags( const char *pchGameTags ) void Steam_GameServer::SetGameTags( const char *pchGameTags )
{ {
PRINT_DEBUG("SetGameTags\n"); PRINT_DEBUG("Steam_GameServer::SetGameTags\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_tags(pchGameTags); server_data.set_tags(pchGameTags);
} }
@ -336,7 +336,7 @@ void Steam_GameServer::SetGameTags( const char *pchGameTags )
/// @see k_cbMaxGameServerGameData /// @see k_cbMaxGameServerGameData
void Steam_GameServer::SetGameData( const char *pchGameData ) void Steam_GameServer::SetGameData( const char *pchGameData )
{ {
PRINT_DEBUG("SetGameData\n"); PRINT_DEBUG("Steam_GameServer::SetGameData\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_gamedata(pchGameData); server_data.set_gamedata(pchGameData);
} }
@ -345,7 +345,7 @@ void Steam_GameServer::SetGameData( const char *pchGameData )
/// Region identifier. This is an optional field, the default value is empty, meaning the "world" region /// Region identifier. This is an optional field, the default value is empty, meaning the "world" region
void Steam_GameServer::SetRegion( const char *pszRegion ) void Steam_GameServer::SetRegion( const char *pszRegion )
{ {
PRINT_DEBUG("SetRegion\n"); PRINT_DEBUG("Steam_GameServer::SetRegion\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_region(pszRegion); server_data.set_region(pszRegion);
} }
@ -366,7 +366,7 @@ void Steam_GameServer::SetRegion( const char *pszRegion )
// for the user has succeeded or failed (the steamid in the callback will match the one returned by this call) // for the user has succeeded or failed (the steamid in the callback will match the one returned by this call)
bool Steam_GameServer::SendUserConnectAndAuthenticate( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) bool Steam_GameServer::SendUserConnectAndAuthenticate( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser )
{ {
PRINT_DEBUG("SendUserConnectAndAuthenticate %u %u\n", unIPClient, cubAuthBlobSize); PRINT_DEBUG("Steam_GameServer::SendUserConnectAndAuthenticate %u %u\n", unIPClient, cubAuthBlobSize);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
bool res = auth_manager->SendUserConnectAndAuthenticate(unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser); bool res = auth_manager->SendUserConnectAndAuthenticate(unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser);
@ -394,7 +394,7 @@ void Steam_GameServer::SendUserConnectAndAuthenticate( CSteamID steamIDUser, uin
// when this user leaves the server just like you would for a real user. // when this user leaves the server just like you would for a real user.
CSteamID Steam_GameServer::CreateUnauthenticatedUserConnection() CSteamID Steam_GameServer::CreateUnauthenticatedUserConnection()
{ {
PRINT_DEBUG("CreateUnauthenticatedUserConnection\n"); PRINT_DEBUG("Steam_GameServer::CreateUnauthenticatedUserConnection\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
CSteamID bot_id = auth_manager->fakeUser(); CSteamID bot_id = auth_manager->fakeUser();
@ -414,7 +414,7 @@ CSteamID Steam_GameServer::CreateUnauthenticatedUserConnection()
// account being logged into multiple servers, showing who is currently on a server, etc. // account being logged into multiple servers, showing who is currently on a server, etc.
void Steam_GameServer::SendUserDisconnect( CSteamID steamIDUser ) void Steam_GameServer::SendUserDisconnect( CSteamID steamIDUser )
{ {
PRINT_DEBUG("SendUserDisconnect\n"); PRINT_DEBUG("Steam_GameServer::SendUserDisconnect\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto player_it = std::find_if(players.begin(), players.end(), [&steamIDUser](std::pair<CSteamID, Gameserver_Player_Info_t>& player) auto player_it = std::find_if(players.begin(), players.end(), [&steamIDUser](std::pair<CSteamID, Gameserver_Player_Info_t>& player)
@ -438,7 +438,7 @@ void Steam_GameServer::SendUserDisconnect( CSteamID steamIDUser )
// Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player) // Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player)
bool Steam_GameServer::BUpdateUserData( CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore ) bool Steam_GameServer::BUpdateUserData( CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore )
{ {
PRINT_DEBUG("BUpdateUserData %llu %s %u\n", steamIDUser.ConvertToUint64(), pchPlayerName, uScore); PRINT_DEBUG("Steam_GameServer::BUpdateUserData %llu %s %u\n", steamIDUser.ConvertToUint64(), pchPlayerName, uScore);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto player_it = std::find_if(players.begin(), players.end(), [&steamIDUser](std::pair<CSteamID, Gameserver_Player_Info_t>& player) auto player_it = std::find_if(players.begin(), players.end(), [&steamIDUser](std::pair<CSteamID, Gameserver_Player_Info_t>& player)
@ -476,7 +476,7 @@ bool Steam_GameServer::BUpdateUserData( CSteamID steamIDUser, const char *pchPla
bool Steam_GameServer::BSetServerType( uint32 unServerFlags, uint32 unGameIP, uint16 unGamePort, bool Steam_GameServer::BSetServerType( uint32 unServerFlags, uint32 unGameIP, uint16 unGamePort,
uint16 unSpectatorPort, uint16 usQueryPort, const char *pchGameDir, const char *pchVersion, bool bLANMode ) uint16 unSpectatorPort, uint16 usQueryPort, const char *pchGameDir, const char *pchVersion, bool bLANMode )
{ {
PRINT_DEBUG("BSetServerType\n"); PRINT_DEBUG("Steam_GameServer::BSetServerType\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_ip(unGameIP); server_data.set_ip(unGameIP);
server_data.set_port(unGamePort); server_data.set_port(unGamePort);
@ -504,7 +504,7 @@ void Steam_GameServer::UpdateServerStatus( int cPlayers, int cPlayersMax, int cB
const char *pchServerName, const char *pSpectatorServerName, const char *pchServerName, const char *pSpectatorServerName,
const char *pchMapName ) const char *pchMapName )
{ {
PRINT_DEBUG("UpdateServerStatus\n"); PRINT_DEBUG("Steam_GameServer::UpdateServerStatus\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_num_players(cPlayers); server_data.set_num_players(cPlayers);
server_data.set_max_player_count(cPlayersMax); server_data.set_max_player_count(cPlayersMax);
@ -517,7 +517,7 @@ void Steam_GameServer::UpdateServerStatus( int cPlayers, int cPlayersMax, int cB
// This can be called if spectator goes away or comes back (passing 0 means there is no spectator server now). // This can be called if spectator goes away or comes back (passing 0 means there is no spectator server now).
void Steam_GameServer::UpdateSpectatorPort( uint16 unSpectatorPort ) void Steam_GameServer::UpdateSpectatorPort( uint16 unSpectatorPort )
{ {
PRINT_DEBUG("UpdateSpectatorPort\n"); PRINT_DEBUG("Steam_GameServer::UpdateSpectatorPort\n");
SetSpectatorPort(unSpectatorPort); SetSpectatorPort(unSpectatorPort);
} }
@ -525,14 +525,14 @@ void Steam_GameServer::UpdateSpectatorPort( uint16 unSpectatorPort )
// it allows users to filter in the matchmaking/server-browser interfaces based on the value // it allows users to filter in the matchmaking/server-browser interfaces based on the value
void Steam_GameServer::SetGameType( const char *pchGameType ) void Steam_GameServer::SetGameType( const char *pchGameType )
{ {
PRINT_DEBUG("SetGameType\n"); PRINT_DEBUG("Steam_GameServer::SetGameType\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
} }
// Ask if a user has a specific achievement for this game, will get a callback on reply // Ask if a user has a specific achievement for this game, will get a callback on reply
bool Steam_GameServer::BGetUserAchievementStatus( CSteamID steamID, const char *pchAchievementName ) bool Steam_GameServer::BGetUserAchievementStatus( CSteamID steamID, const char *pchAchievementName )
{ {
PRINT_DEBUG("BGetUserAchievementStatus\n"); PRINT_DEBUG("Steam_GameServer::BGetUserAchievementStatus\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return false; return false;
} }
@ -622,7 +622,7 @@ EUserHasLicenseForAppResult Steam_GameServer::UserHasLicenseForApp( CSteamID ste
// returns false if we're not connected to the steam servers and thus cannot ask // returns false if we're not connected to the steam servers and thus cannot ask
bool Steam_GameServer::RequestUserGroupStatus( CSteamID steamIDUser, CSteamID steamIDGroup ) bool Steam_GameServer::RequestUserGroupStatus( CSteamID steamIDUser, CSteamID steamIDGroup )
{ {
PRINT_DEBUG("RequestUserGroupStatus\n"); PRINT_DEBUG("Steam_GameServer::RequestUserGroupStatus\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return true; return true;
} }
@ -633,14 +633,14 @@ bool Steam_GameServer::RequestUserGroupStatus( CSteamID steamIDUser, CSteamID st
// they will be removed in a future version of the SDK // they will be removed in a future version of the SDK
void Steam_GameServer::GetGameplayStats( ) void Steam_GameServer::GetGameplayStats( )
{ {
PRINT_DEBUG("GetGameplayStats\n"); PRINT_DEBUG("Steam_GameServer::GetGameplayStats\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
} }
STEAM_CALL_RESULT( GSReputation_t ) STEAM_CALL_RESULT( GSReputation_t )
SteamAPICall_t Steam_GameServer::GetServerReputation() SteamAPICall_t Steam_GameServer::GetServerReputation()
{ {
PRINT_DEBUG("GetServerReputation\n"); PRINT_DEBUG("Steam_GameServer::GetServerReputation\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return 0; return 0;
} }
@ -651,16 +651,16 @@ SteamAPICall_t Steam_GameServer::GetServerReputation()
// connect to // connect to
uint32 Steam_GameServer::GetPublicIP_old() uint32 Steam_GameServer::GetPublicIP_old()
{ {
PRINT_DEBUG("GetPublicIP_old\n"); PRINT_DEBUG("Steam_GameServer::GetPublicIP_old\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
uint32 ip = network->getOwnIP(); uint32 ip = network->getOwnIP();
PRINT_DEBUG("%X\n", ip); PRINT_DEBUG(" %X\n", ip);
return ip; return ip;
} }
SteamIPAddress_t Steam_GameServer::GetPublicIP() SteamIPAddress_t Steam_GameServer::GetPublicIP()
{ {
PRINT_DEBUG("GetPublicIP\n"); PRINT_DEBUG("Steam_GameServer::GetPublicIP\n");
SteamIPAddress_t ip = SteamIPAddress_t::IPv4Any(); SteamIPAddress_t ip = SteamIPAddress_t::IPv4Any();
ip.m_unIPv4 = GetPublicIP_old(); ip.m_unIPv4 = GetPublicIP_old();
return ip; return ip;
@ -668,7 +668,7 @@ SteamIPAddress_t Steam_GameServer::GetPublicIP()
void Steam_GameServer::GetPublicIP_fix(SteamIPAddress_t *out) void Steam_GameServer::GetPublicIP_fix(SteamIPAddress_t *out)
{ {
PRINT_DEBUG("GetPublicIP_fix\n"); PRINT_DEBUG("Steam_GameServer::GetPublicIP_fix\n");
if (out) *out = GetPublicIP(); if (out) *out = GetPublicIP();
} }
@ -689,7 +689,7 @@ void Steam_GameServer::GetPublicIP_fix(SteamIPAddress_t *out)
// it's for us. // it's for us.
bool Steam_GameServer::HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort ) bool Steam_GameServer::HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort )
{ {
PRINT_DEBUG("HandleIncomingPacket %i %X %i\n", cbData, srcIP, srcPort); PRINT_DEBUG("Steam_GameServer::HandleIncomingPacket %i %X %i\n", cbData, srcIP, srcPort);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (settings->disable_source_query) return true; if (settings->disable_source_query) return true;
@ -713,7 +713,7 @@ bool Steam_GameServer::HandleIncomingPacket( const void *pData, int cbData, uint
// Call this each frame until it returns 0. // Call this each frame until it returns 0.
int Steam_GameServer::GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) int Steam_GameServer::GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort )
{ {
PRINT_DEBUG("GetNextOutgoingPacket\n"); PRINT_DEBUG("Steam_GameServer::GetNextOutgoingPacket\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (settings->disable_source_query) return 0; if (settings->disable_source_query) return 0;
if (outgoing_packets.size() == 0) return 0; if (outgoing_packets.size() == 0) return 0;
@ -735,7 +735,7 @@ int Steam_GameServer::GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *p
// you want it to be active (default: off). // you want it to be active (default: off).
void Steam_GameServer::EnableHeartbeats( bool bActive ) void Steam_GameServer::EnableHeartbeats( bool bActive )
{ {
PRINT_DEBUG("EnableHeartbeats\n"); PRINT_DEBUG("Steam_GameServer::EnableHeartbeats\n");
} }
/// Indicate whether you wish to be listed on the master server list /// Indicate whether you wish to be listed on the master server list
@ -748,7 +748,7 @@ void Steam_GameServer::EnableHeartbeats( bool bActive )
/// the old name was just confusing.) /// the old name was just confusing.)
void Steam_GameServer::SetAdvertiseServerActive( bool bActive ) void Steam_GameServer::SetAdvertiseServerActive( bool bActive )
{ {
PRINT_DEBUG("SetAdvertiseServerActive\n"); PRINT_DEBUG("Steam_GameServer::SetAdvertiseServerActive\n");
EnableHeartbeats(bActive); EnableHeartbeats(bActive);
} }
@ -757,24 +757,24 @@ void Steam_GameServer::SetAdvertiseServerActive( bool bActive )
// Some mods change this. // Some mods change this.
void Steam_GameServer::SetHeartbeatInterval( int iHeartbeatInterval ) void Steam_GameServer::SetHeartbeatInterval( int iHeartbeatInterval )
{ {
PRINT_DEBUG("SetHeartbeatInterval\n"); PRINT_DEBUG("Steam_GameServer::SetHeartbeatInterval\n");
} }
void Steam_GameServer::SetMasterServerHeartbeatInterval_DEPRECATED( int iHeartbeatInterval ) void Steam_GameServer::SetMasterServerHeartbeatInterval_DEPRECATED( int iHeartbeatInterval )
{ {
PRINT_DEBUG("SetMasterServerHeartbeatInterval_DEPRECATED\n"); PRINT_DEBUG("Steam_GameServer::SetMasterServerHeartbeatInterval_DEPRECATED\n");
} }
// Force a heartbeat to steam at the next opportunity // Force a heartbeat to steam at the next opportunity
void Steam_GameServer::ForceHeartbeat() void Steam_GameServer::ForceHeartbeat()
{ {
PRINT_DEBUG("ForceHeartbeat\n"); PRINT_DEBUG("Steam_GameServer::ForceHeartbeat\n");
} }
void Steam_GameServer::ForceMasterServerHeartbeat_DEPRECATED() void Steam_GameServer::ForceMasterServerHeartbeat_DEPRECATED()
{ {
PRINT_DEBUG("ForceMasterServerHeartbeat_DEPRECATED\n"); PRINT_DEBUG("Steam_GameServer::ForceMasterServerHeartbeat_DEPRECATED\n");
} }
@ -782,7 +782,7 @@ void Steam_GameServer::ForceMasterServerHeartbeat_DEPRECATED()
STEAM_CALL_RESULT( AssociateWithClanResult_t ) STEAM_CALL_RESULT( AssociateWithClanResult_t )
SteamAPICall_t Steam_GameServer::AssociateWithClan( CSteamID steamIDClan ) SteamAPICall_t Steam_GameServer::AssociateWithClan( CSteamID steamIDClan )
{ {
PRINT_DEBUG("AssociateWithClan\n"); PRINT_DEBUG("Steam_GameServer::AssociateWithClan\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return 0; return 0;
} }
@ -792,7 +792,7 @@ SteamAPICall_t Steam_GameServer::AssociateWithClan( CSteamID steamIDClan )
STEAM_CALL_RESULT( ComputeNewPlayerCompatibilityResult_t ) STEAM_CALL_RESULT( ComputeNewPlayerCompatibilityResult_t )
SteamAPICall_t Steam_GameServer::ComputeNewPlayerCompatibility( CSteamID steamIDNewPlayer ) SteamAPICall_t Steam_GameServer::ComputeNewPlayerCompatibility( CSteamID steamIDNewPlayer )
{ {
PRINT_DEBUG("ComputeNewPlayerCompatibility\n"); PRINT_DEBUG("Steam_GameServer::ComputeNewPlayerCompatibility\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
return 0; return 0;
} }

20
dll/steam_gameserverstats.cpp
View File

@ -33,7 +33,7 @@ Steam_GameServerStats::Steam_GameServerStats(class Settings *settings, class Net
STEAM_CALL_RESULT( GSStatsReceived_t ) STEAM_CALL_RESULT( GSStatsReceived_t )
SteamAPICall_t Steam_GameServerStats::RequestUserStats( CSteamID steamIDUser ) SteamAPICall_t Steam_GameServerStats::RequestUserStats( CSteamID steamIDUser )
{ {
PRINT_DEBUG("RequestUserStats\n"); PRINT_DEBUG("Steam_GameServerStats::RequestUserStats\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
GSStatsReceived_t data; GSStatsReceived_t data;
@ -46,19 +46,19 @@ SteamAPICall_t Steam_GameServerStats::RequestUserStats( CSteamID steamIDUser )
// requests stat information for a user, usable after a successful call to RequestUserStats() // requests stat information for a user, usable after a successful call to RequestUserStats()
bool Steam_GameServerStats::GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) bool Steam_GameServerStats::GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData )
{ {
PRINT_DEBUG("GetUserStat\n"); PRINT_DEBUG("Steam_GameServerStats::GetUserStat\n");
return false; return false;
} }
bool Steam_GameServerStats::GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) bool Steam_GameServerStats::GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData )
{ {
PRINT_DEBUG("GetUserStat\n"); PRINT_DEBUG("Steam_GameServerStats::GetUserStat\n");
return false; return false;
} }
bool Steam_GameServerStats::GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) bool Steam_GameServerStats::GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved )
{ {
PRINT_DEBUG("GetUserAchievement\n"); PRINT_DEBUG("Steam_GameServerStats::GetUserAchievement\n");
return false; return false;
} }
@ -69,32 +69,32 @@ bool Steam_GameServerStats::GetUserAchievement( CSteamID steamIDUser, const char
// Set the IP range of your official servers on the Steamworks page // Set the IP range of your official servers on the Steamworks page
bool Steam_GameServerStats::SetUserStat( CSteamID steamIDUser, const char *pchName, int32 nData ) bool Steam_GameServerStats::SetUserStat( CSteamID steamIDUser, const char *pchName, int32 nData )
{ {
PRINT_DEBUG("SetUserStat\n"); PRINT_DEBUG("Steam_GameServerStats::SetUserStat\n");
return false; return false;
} }
bool Steam_GameServerStats::SetUserStat( CSteamID steamIDUser, const char *pchName, float fData ) bool Steam_GameServerStats::SetUserStat( CSteamID steamIDUser, const char *pchName, float fData )
{ {
PRINT_DEBUG("SetUserStat\n"); PRINT_DEBUG("Steam_GameServerStats::SetUserStat\n");
return false; return false;
} }
bool Steam_GameServerStats::UpdateUserAvgRateStat( CSteamID steamIDUser, const char *pchName, float flCountThisSession, double dSessionLength ) bool Steam_GameServerStats::UpdateUserAvgRateStat( CSteamID steamIDUser, const char *pchName, float flCountThisSession, double dSessionLength )
{ {
PRINT_DEBUG("UpdateUserAvgRateStat\n"); PRINT_DEBUG("Steam_GameServerStats::UpdateUserAvgRateStat\n");
return false; return false;
} }
bool Steam_GameServerStats::SetUserAchievement( CSteamID steamIDUser, const char *pchName ) bool Steam_GameServerStats::SetUserAchievement( CSteamID steamIDUser, const char *pchName )
{ {
PRINT_DEBUG("SetUserAchievement\n"); PRINT_DEBUG("Steam_GameServerStats::SetUserAchievement\n");
return false; return false;
} }
bool Steam_GameServerStats::ClearUserAchievement( CSteamID steamIDUser, const char *pchName ) bool Steam_GameServerStats::ClearUserAchievement( CSteamID steamIDUser, const char *pchName )
{ {
PRINT_DEBUG("ClearUserAchievement\n"); PRINT_DEBUG("Steam_GameServerStats::ClearUserAchievement\n");
return false; return false;
} }
@ -108,7 +108,7 @@ bool Steam_GameServerStats::ClearUserAchievement( CSteamID steamIDUser, const ch
STEAM_CALL_RESULT( GSStatsStored_t ) STEAM_CALL_RESULT( GSStatsStored_t )
SteamAPICall_t Steam_GameServerStats::StoreUserStats( CSteamID steamIDUser ) SteamAPICall_t Steam_GameServerStats::StoreUserStats( CSteamID steamIDUser )
{ {
PRINT_DEBUG("StoreUserStats\n"); PRINT_DEBUG("Steam_GameServerStats::StoreUserStats\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
GSStatsStored_t data; GSStatsStored_t data;

50
dll/steam_http.cpp
View File

@ -38,7 +38,7 @@ Steam_Http_Request *Steam_HTTP::get_request(HTTPRequestHandle hRequest)
// or such. // or such.
HTTPRequestHandle Steam_HTTP::CreateHTTPRequest( EHTTPMethod eHTTPRequestMethod, const char *pchAbsoluteURL ) HTTPRequestHandle Steam_HTTP::CreateHTTPRequest( EHTTPMethod eHTTPRequestMethod, const char *pchAbsoluteURL )
{ {
PRINT_DEBUG("CreateHTTPRequest %i %s\n", eHTTPRequestMethod, pchAbsoluteURL); PRINT_DEBUG("Steam_HTTP::CreateHTTPRequest %i %s\n", eHTTPRequestMethod, pchAbsoluteURL);
if (!pchAbsoluteURL) return INVALID_HTTPREQUEST_HANDLE; if (!pchAbsoluteURL) return INVALID_HTTPREQUEST_HANDLE;
std::string url = pchAbsoluteURL; std::string url = pchAbsoluteURL;
unsigned url_index = 0; unsigned url_index = 0;
@ -111,7 +111,7 @@ HTTPRequestHandle Steam_HTTP::CreateHTTPRequest( EHTTPMethod eHTTPRequestMethod,
// sending the request. This is just so the caller can easily keep track of which callbacks go with which request data. // sending the request. This is just so the caller can easily keep track of which callbacks go with which request data.
bool Steam_HTTP::SetHTTPRequestContextValue( HTTPRequestHandle hRequest, uint64 ulContextValue ) bool Steam_HTTP::SetHTTPRequestContextValue( HTTPRequestHandle hRequest, uint64 ulContextValue )
{ {
PRINT_DEBUG("SetHTTPRequestContextValue\n"); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestContextValue\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -127,7 +127,7 @@ bool Steam_HTTP::SetHTTPRequestContextValue( HTTPRequestHandle hRequest, uint64
// has already been sent. // has already been sent.
bool Steam_HTTP::SetHTTPRequestNetworkActivityTimeout( HTTPRequestHandle hRequest, uint32 unTimeoutSeconds ) bool Steam_HTTP::SetHTTPRequestNetworkActivityTimeout( HTTPRequestHandle hRequest, uint32 unTimeoutSeconds )
{ {
PRINT_DEBUG("SetHTTPRequestNetworkActivityTimeout\n"); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestNetworkActivityTimeout\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -141,7 +141,7 @@ bool Steam_HTTP::SetHTTPRequestNetworkActivityTimeout( HTTPRequestHandle hReques
// return false if the handle is invalid or the request is already sent. // return false if the handle is invalid or the request is already sent.
bool Steam_HTTP::SetHTTPRequestHeaderValue( HTTPRequestHandle hRequest, const char *pchHeaderName, const char *pchHeaderValue ) bool Steam_HTTP::SetHTTPRequestHeaderValue( HTTPRequestHandle hRequest, const char *pchHeaderName, const char *pchHeaderValue )
{ {
PRINT_DEBUG("SetHTTPRequestHeaderValue %s %s\n", pchHeaderName, pchHeaderValue); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestHeaderValue %s %s\n", pchHeaderName, pchHeaderValue);
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -156,7 +156,7 @@ bool Steam_HTTP::SetHTTPRequestHeaderValue( HTTPRequestHandle hRequest, const ch
// handle is invalid or the request is already sent. // handle is invalid or the request is already sent.
bool Steam_HTTP::SetHTTPRequestGetOrPostParameter( HTTPRequestHandle hRequest, const char *pchParamName, const char *pchParamValue ) bool Steam_HTTP::SetHTTPRequestGetOrPostParameter( HTTPRequestHandle hRequest, const char *pchParamName, const char *pchParamValue )
{ {
PRINT_DEBUG("SetHTTPRequestGetOrPostParameter\n"); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestGetOrPostParameter\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -173,7 +173,7 @@ bool Steam_HTTP::SetHTTPRequestGetOrPostParameter( HTTPRequestHandle hRequest, c
// header and only do a local cache lookup rather than sending any actual remote request. // header and only do a local cache lookup rather than sending any actual remote request.
bool Steam_HTTP::SendHTTPRequest( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle ) bool Steam_HTTP::SendHTTPRequest( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle )
{ {
PRINT_DEBUG("SendHTTPRequest %u %p\n", hRequest, pCallHandle); PRINT_DEBUG("Steam_HTTP::SendHTTPRequest %u %p\n", hRequest, pCallHandle);
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -205,7 +205,7 @@ bool Steam_HTTP::SendHTTPRequest( HTTPRequestHandle hRequest, SteamAPICall_t *pC
// HTTPRequestDataReceived_t callbacks while streaming. // HTTPRequestDataReceived_t callbacks while streaming.
bool Steam_HTTP::SendHTTPRequestAndStreamResponse( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle ) bool Steam_HTTP::SendHTTPRequestAndStreamResponse( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle )
{ {
PRINT_DEBUG("SendHTTPRequestAndStreamResponse\n"); PRINT_DEBUG("Steam_HTTP::SendHTTPRequestAndStreamResponse\n");
return false; return false;
} }
@ -214,7 +214,7 @@ bool Steam_HTTP::SendHTTPRequestAndStreamResponse( HTTPRequestHandle hRequest, S
// the specified request to the tail of the queue. Returns false on invalid handle, or if the request is not yet sent. // the specified request to the tail of the queue. Returns false on invalid handle, or if the request is not yet sent.
bool Steam_HTTP::DeferHTTPRequest( HTTPRequestHandle hRequest ) bool Steam_HTTP::DeferHTTPRequest( HTTPRequestHandle hRequest )
{ {
PRINT_DEBUG("DeferHTTPRequest\n"); PRINT_DEBUG("Steam_HTTP::DeferHTTPRequest\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -228,7 +228,7 @@ bool Steam_HTTP::DeferHTTPRequest( HTTPRequestHandle hRequest )
// the specified request to the head of the queue. Returns false on invalid handle, or if the request is not yet sent. // the specified request to the head of the queue. Returns false on invalid handle, or if the request is not yet sent.
bool Steam_HTTP::PrioritizeHTTPRequest( HTTPRequestHandle hRequest ) bool Steam_HTTP::PrioritizeHTTPRequest( HTTPRequestHandle hRequest )
{ {
PRINT_DEBUG("PrioritizeHTTPRequest\n"); PRINT_DEBUG("Steam_HTTP::PrioritizeHTTPRequest\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -243,7 +243,7 @@ bool Steam_HTTP::PrioritizeHTTPRequest( HTTPRequestHandle hRequest )
// GetHTTPResponseHeaderValue. // GetHTTPResponseHeaderValue.
bool Steam_HTTP::GetHTTPResponseHeaderSize( HTTPRequestHandle hRequest, const char *pchHeaderName, uint32 *unResponseHeaderSize ) bool Steam_HTTP::GetHTTPResponseHeaderSize( HTTPRequestHandle hRequest, const char *pchHeaderName, uint32 *unResponseHeaderSize )
{ {
PRINT_DEBUG("GetHTTPResponseHeaderSize\n"); PRINT_DEBUG("Steam_HTTP::GetHTTPResponseHeaderSize\n");
return false; return false;
} }
@ -253,7 +253,7 @@ bool Steam_HTTP::GetHTTPResponseHeaderSize( HTTPRequestHandle hRequest, const ch
// BGetHTTPResponseHeaderSize to check for the presence of the header and to find out the size buffer needed. // BGetHTTPResponseHeaderSize to check for the presence of the header and to find out the size buffer needed.
bool Steam_HTTP::GetHTTPResponseHeaderValue( HTTPRequestHandle hRequest, const char *pchHeaderName, uint8 *pHeaderValueBuffer, uint32 unBufferSize ) bool Steam_HTTP::GetHTTPResponseHeaderValue( HTTPRequestHandle hRequest, const char *pchHeaderName, uint8 *pHeaderValueBuffer, uint32 unBufferSize )
{ {
PRINT_DEBUG("GetHTTPResponseHeaderValue\n"); PRINT_DEBUG("Steam_HTTP::GetHTTPResponseHeaderValue\n");
return false; return false;
} }
@ -262,7 +262,7 @@ bool Steam_HTTP::GetHTTPResponseHeaderValue( HTTPRequestHandle hRequest, const c
// handle is invalid. // handle is invalid.
bool Steam_HTTP::GetHTTPResponseBodySize( HTTPRequestHandle hRequest, uint32 *unBodySize ) bool Steam_HTTP::GetHTTPResponseBodySize( HTTPRequestHandle hRequest, uint32 *unBodySize )
{ {
PRINT_DEBUG("GetHTTPResponseBodySize\n"); PRINT_DEBUG("Steam_HTTP::GetHTTPResponseBodySize\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -278,7 +278,7 @@ bool Steam_HTTP::GetHTTPResponseBodySize( HTTPRequestHandle hRequest, uint32 *un
// the correct buffer size to use. // the correct buffer size to use.
bool Steam_HTTP::GetHTTPResponseBodyData( HTTPRequestHandle hRequest, uint8 *pBodyDataBuffer, uint32 unBufferSize ) bool Steam_HTTP::GetHTTPResponseBodyData( HTTPRequestHandle hRequest, uint8 *pBodyDataBuffer, uint32 unBufferSize )
{ {
PRINT_DEBUG("GetHTTPResponseBodyData\n"); PRINT_DEBUG("Steam_HTTP::GetHTTPResponseBodyData\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -298,7 +298,7 @@ bool Steam_HTTP::GetHTTPResponseBodyData( HTTPRequestHandle hRequest, uint8 *pBo
// do not match the size and offset sent in HTTPRequestDataReceived_t. // do not match the size and offset sent in HTTPRequestDataReceived_t.
bool Steam_HTTP::GetHTTPStreamingResponseBodyData( HTTPRequestHandle hRequest, uint32 cOffset, uint8 *pBodyDataBuffer, uint32 unBufferSize ) bool Steam_HTTP::GetHTTPStreamingResponseBodyData( HTTPRequestHandle hRequest, uint32 cOffset, uint8 *pBodyDataBuffer, uint32 unBufferSize )
{ {
PRINT_DEBUG("GetHTTPStreamingResponseBodyData\n"); PRINT_DEBUG("Steam_HTTP::GetHTTPStreamingResponseBodyData\n");
return false; return false;
} }
@ -307,7 +307,7 @@ bool Steam_HTTP::GetHTTPStreamingResponseBodyData( HTTPRequestHandle hRequest, u
// callback and finishing using the response. // callback and finishing using the response.
bool Steam_HTTP::ReleaseHTTPRequest( HTTPRequestHandle hRequest ) bool Steam_HTTP::ReleaseHTTPRequest( HTTPRequestHandle hRequest )
{ {
PRINT_DEBUG("ReleaseHTTPRequest\n"); PRINT_DEBUG("Steam_HTTP::ReleaseHTTPRequest\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto c = std::begin(requests); auto c = std::begin(requests);
@ -329,7 +329,7 @@ bool Steam_HTTP::ReleaseHTTPRequest( HTTPRequestHandle hRequest )
// zero for the duration of the request as the size is unknown until the connection closes. // zero for the duration of the request as the size is unknown until the connection closes.
bool Steam_HTTP::GetHTTPDownloadProgressPct( HTTPRequestHandle hRequest, float *pflPercentOut ) bool Steam_HTTP::GetHTTPDownloadProgressPct( HTTPRequestHandle hRequest, float *pflPercentOut )
{ {
PRINT_DEBUG("GetHTTPDownloadProgressPct\n"); PRINT_DEBUG("Steam_HTTP::GetHTTPDownloadProgressPct\n");
return false; return false;
} }
@ -339,7 +339,7 @@ bool Steam_HTTP::GetHTTPDownloadProgressPct( HTTPRequestHandle hRequest, float *
// parameter will set the content-type header for the request so the server may know how to interpret the body. // parameter will set the content-type header for the request so the server may know how to interpret the body.
bool Steam_HTTP::SetHTTPRequestRawPostBody( HTTPRequestHandle hRequest, const char *pchContentType, uint8 *pubBody, uint32 unBodyLen ) bool Steam_HTTP::SetHTTPRequestRawPostBody( HTTPRequestHandle hRequest, const char *pchContentType, uint8 *pubBody, uint32 unBodyLen )
{ {
PRINT_DEBUG("SetHTTPRequestRawPostBody %s\n", pchContentType); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestRawPostBody %s\n", pchContentType);
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -356,7 +356,7 @@ bool Steam_HTTP::SetHTTPRequestRawPostBody( HTTPRequestHandle hRequest, const ch
// repeat executions of your process. // repeat executions of your process.
HTTPCookieContainerHandle Steam_HTTP::CreateCookieContainer( bool bAllowResponsesToModify ) HTTPCookieContainerHandle Steam_HTTP::CreateCookieContainer( bool bAllowResponsesToModify )
{ {
PRINT_DEBUG("CreateCookieContainer\n"); PRINT_DEBUG("Steam_HTTP::CreateCookieContainer\n");
return false; return false;
} }
@ -364,7 +364,7 @@ HTTPCookieContainerHandle Steam_HTTP::CreateCookieContainer( bool bAllowResponse
// Release a cookie container you are finished using, freeing it's memory // Release a cookie container you are finished using, freeing it's memory
bool Steam_HTTP::ReleaseCookieContainer( HTTPCookieContainerHandle hCookieContainer ) bool Steam_HTTP::ReleaseCookieContainer( HTTPCookieContainerHandle hCookieContainer )
{ {
PRINT_DEBUG("ReleaseCookieContainer\n"); PRINT_DEBUG("Steam_HTTP::ReleaseCookieContainer\n");
return false; return false;
} }
@ -372,7 +372,7 @@ bool Steam_HTTP::ReleaseCookieContainer( HTTPCookieContainerHandle hCookieContai
// Adds a cookie to the specified cookie container that will be used with future requests. // Adds a cookie to the specified cookie container that will be used with future requests.
bool Steam_HTTP::SetCookie( HTTPCookieContainerHandle hCookieContainer, const char *pchHost, const char *pchUrl, const char *pchCookie ) bool Steam_HTTP::SetCookie( HTTPCookieContainerHandle hCookieContainer, const char *pchHost, const char *pchUrl, const char *pchCookie )
{ {
PRINT_DEBUG("SetCookie\n"); PRINT_DEBUG("Steam_HTTP::SetCookie\n");
return false; return false;
} }
@ -380,7 +380,7 @@ bool Steam_HTTP::SetCookie( HTTPCookieContainerHandle hCookieContainer, const ch
// Set the cookie container to use for a HTTP request // Set the cookie container to use for a HTTP request
bool Steam_HTTP::SetHTTPRequestCookieContainer( HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer ) bool Steam_HTTP::SetHTTPRequestCookieContainer( HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer )
{ {
PRINT_DEBUG("SetHTTPRequestCookieContainer\n"); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestCookieContainer\n");
return false; return false;
} }
@ -388,7 +388,7 @@ bool Steam_HTTP::SetHTTPRequestCookieContainer( HTTPRequestHandle hRequest, HTTP
// Set the extra user agent info for a request, this doesn't clobber the normal user agent, it just adds the extra info on the end // Set the extra user agent info for a request, this doesn't clobber the normal user agent, it just adds the extra info on the end
bool Steam_HTTP::SetHTTPRequestUserAgentInfo( HTTPRequestHandle hRequest, const char *pchUserAgentInfo ) bool Steam_HTTP::SetHTTPRequestUserAgentInfo( HTTPRequestHandle hRequest, const char *pchUserAgentInfo )
{ {
PRINT_DEBUG("SetHTTPRequestUserAgentInfo\n"); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestUserAgentInfo\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -401,7 +401,7 @@ bool Steam_HTTP::SetHTTPRequestUserAgentInfo( HTTPRequestHandle hRequest, const
// Set that https request should require verified SSL certificate via machines certificate trust store // Set that https request should require verified SSL certificate via machines certificate trust store
bool Steam_HTTP::SetHTTPRequestRequiresVerifiedCertificate( HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate ) bool Steam_HTTP::SetHTTPRequestRequiresVerifiedCertificate( HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate )
{ {
PRINT_DEBUG("SetHTTPRequestRequiresVerifiedCertificate\n"); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestRequiresVerifiedCertificate\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -415,7 +415,7 @@ bool Steam_HTTP::SetHTTPRequestRequiresVerifiedCertificate( HTTPRequestHandle hR
// which can bump everytime we get more data // which can bump everytime we get more data
bool Steam_HTTP::SetHTTPRequestAbsoluteTimeoutMS( HTTPRequestHandle hRequest, uint32 unMilliseconds ) bool Steam_HTTP::SetHTTPRequestAbsoluteTimeoutMS( HTTPRequestHandle hRequest, uint32 unMilliseconds )
{ {
PRINT_DEBUG("SetHTTPRequestAbsoluteTimeoutMS\n"); PRINT_DEBUG("Steam_HTTP::SetHTTPRequestAbsoluteTimeoutMS\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;
@ -428,7 +428,7 @@ bool Steam_HTTP::SetHTTPRequestAbsoluteTimeoutMS( HTTPRequestHandle hRequest, ui
// Check if the reason the request failed was because we timed it out (rather than some harder failure) // Check if the reason the request failed was because we timed it out (rather than some harder failure)
bool Steam_HTTP::GetHTTPRequestWasTimedOut( HTTPRequestHandle hRequest, bool *pbWasTimedOut ) bool Steam_HTTP::GetHTTPRequestWasTimedOut( HTTPRequestHandle hRequest, bool *pbWasTimedOut )
{ {
PRINT_DEBUG("GetHTTPRequestWasTimedOut\n"); PRINT_DEBUG("Steam_HTTP::GetHTTPRequestWasTimedOut\n");
Steam_Http_Request *request = get_request(hRequest); Steam_Http_Request *request = get_request(hRequest);
if (!request) { if (!request) {
return false; return false;

98
dll/steam_matchmaking_servers.cpp
View File

@ -37,8 +37,11 @@ static int server_list_request;
HServerListRequest Steam_Matchmaking_Servers::RequestServerList(AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse, EMatchMakingType type) HServerListRequest Steam_Matchmaking_Servers::RequestServerList(AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse, EMatchMakingType type)
{ {
PRINT_DEBUG("RequestServerList %u\n", iApp); PRINT_DEBUG("Steam_Matchmaking_Servers::RequestServerList %u %p, %i\n", iApp, pRequestServersResponse, (int)type);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
++server_list_request;
HServerListRequest id = (char *)0 + server_list_request; // (char *)0 silences the compiler warning
struct Steam_Matchmaking_Request request; struct Steam_Matchmaking_Request request;
request.appid = iApp; request.appid = iApp;
request.callbacks = pRequestServersResponse; request.callbacks = pRequestServersResponse;
@ -46,11 +49,9 @@ HServerListRequest Steam_Matchmaking_Servers::RequestServerList(AppId_t iApp, IS
request.cancelled = false; request.cancelled = false;
request.completed = false; request.completed = false;
request.type = type; request.type = type;
request.id = id;
requests.push_back(request); requests.push_back(request);
++server_list_request; PRINT_DEBUG("Steam_Matchmaking_Servers::request id: %p\n", id);
requests[requests.size() - 1].id = (char *)0 + server_list_request; // (char *)0 silences the compiler warning
HServerListRequest id = requests[requests.size() - 1].id;
PRINT_DEBUG("request id: %p\n", id);
if (type == eLANServer) return id; if (type == eLANServer) return id;
@ -68,7 +69,7 @@ HServerListRequest Steam_Matchmaking_Servers::RequestServerList(AppId_t iApp, IS
g2.server = server; g2.server = server;
g2.type = type; g2.type = type;
gameservers.push_back(g2); gameservers.push_back(g2);
PRINT_DEBUG("SERVER ADDED\n"); PRINT_DEBUG(" eFriendsServer SERVER ADDED\n");
} }
} }
return id; return id;
@ -87,6 +88,7 @@ HServerListRequest Steam_Matchmaking_Servers::RequestServerList(AppId_t iApp, IS
file_size = file_size_(file_path); file_size = file_size_(file_path);
} }
PRINT_DEBUG("Steam_Matchmaking_Servers::Server list file '%s' [%llu bytes]\n", file_path.c_str(), file_size);
std::string list; std::string list;
if (file_size) { if (file_size) {
list.resize(file_size); list.resize(file_size);
@ -129,7 +131,7 @@ HServerListRequest Steam_Matchmaking_Servers::RequestServerList(AppId_t iApp, IS
g.server = server; g.server = server;
g.type = type; g.type = type;
gameservers.push_back(g); gameservers.push_back(g);
PRINT_DEBUG("SERVER ADDED\n"); PRINT_DEBUG(" SERVER ADDED\n");
list_ip = ""; list_ip = "";
} }
@ -142,43 +144,43 @@ HServerListRequest Steam_Matchmaking_Servers::RequestServerList(AppId_t iApp, IS
// Request object must be released by calling ReleaseRequest( hServerListRequest ) // Request object must be released by calling ReleaseRequest( hServerListRequest )
HServerListRequest Steam_Matchmaking_Servers::RequestInternetServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) HServerListRequest Steam_Matchmaking_Servers::RequestInternetServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("RequestInternetServerList\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::RequestInternetServerList\n");
return RequestServerList(iApp, pRequestServersResponse, eInternetServer); return RequestServerList(iApp, pRequestServersResponse, eInternetServer);
} }
HServerListRequest Steam_Matchmaking_Servers::RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse ) HServerListRequest Steam_Matchmaking_Servers::RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("RequestLANServerList\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::RequestLANServerList\n");
return RequestServerList(iApp, pRequestServersResponse, eLANServer); return RequestServerList(iApp, pRequestServersResponse, eLANServer);
} }
HServerListRequest Steam_Matchmaking_Servers::RequestFriendsServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) HServerListRequest Steam_Matchmaking_Servers::RequestFriendsServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("RequestFriendsServerList\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::RequestFriendsServerList\n");
return RequestServerList(iApp, pRequestServersResponse, eFriendsServer); return RequestServerList(iApp, pRequestServersResponse, eFriendsServer);
} }
HServerListRequest Steam_Matchmaking_Servers::RequestFavoritesServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) HServerListRequest Steam_Matchmaking_Servers::RequestFavoritesServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("RequestFavoritesServerList\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::RequestFavoritesServerList\n");
return RequestServerList(iApp, pRequestServersResponse, eFavoritesServer); return RequestServerList(iApp, pRequestServersResponse, eFavoritesServer);
} }
HServerListRequest Steam_Matchmaking_Servers::RequestHistoryServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) HServerListRequest Steam_Matchmaking_Servers::RequestHistoryServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("RequestHistoryServerList\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::RequestHistoryServerList\n");
return RequestServerList(iApp, pRequestServersResponse, eHistoryServer); return RequestServerList(iApp, pRequestServersResponse, eHistoryServer);
} }
HServerListRequest Steam_Matchmaking_Servers::RequestSpectatorServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) HServerListRequest Steam_Matchmaking_Servers::RequestSpectatorServerList( AppId_t iApp, STEAM_ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("RequestSpectatorServerList\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::RequestSpectatorServerList\n");
return RequestServerList(iApp, pRequestServersResponse, eSpectatorServer); return RequestServerList(iApp, pRequestServersResponse, eSpectatorServer);
} }
void Steam_Matchmaking_Servers::RequestOldServerList(AppId_t iApp, ISteamMatchmakingServerListResponse001 *pRequestServersResponse, EMatchMakingType type) void Steam_Matchmaking_Servers::RequestOldServerList(AppId_t iApp, ISteamMatchmakingServerListResponse001 *pRequestServersResponse, EMatchMakingType type)
{ {
PRINT_DEBUG("RequestOldServerList %u\n", iApp); PRINT_DEBUG("Steam_Matchmaking_Servers::RequestOldServerList %u\n", iApp);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto g = std::begin(requests); auto g = std::begin(requests);
while (g != std::end(requests)) { while (g != std::end(requests)) {
@ -202,42 +204,42 @@ void Steam_Matchmaking_Servers::RequestOldServerList(AppId_t iApp, ISteamMatchma
void Steam_Matchmaking_Servers::RequestInternetServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse ) void Steam_Matchmaking_Servers::RequestInternetServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{ {
PRINT_DEBUG("%s old\n", __FUNCTION__); PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
//TODO //TODO
RequestOldServerList(iApp, pRequestServersResponse, eInternetServer); RequestOldServerList(iApp, pRequestServersResponse, eInternetServer);
} }
void Steam_Matchmaking_Servers::RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse001 *pRequestServersResponse ) void Steam_Matchmaking_Servers::RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{ {
PRINT_DEBUG("%s old\n", __FUNCTION__); PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
//TODO //TODO
RequestOldServerList(iApp, pRequestServersResponse, eLANServer); RequestOldServerList(iApp, pRequestServersResponse, eLANServer);
} }
void Steam_Matchmaking_Servers::RequestFriendsServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse ) void Steam_Matchmaking_Servers::RequestFriendsServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{ {
PRINT_DEBUG("%s old\n", __FUNCTION__); PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
//TODO //TODO
RequestOldServerList(iApp, pRequestServersResponse, eFriendsServer); RequestOldServerList(iApp, pRequestServersResponse, eFriendsServer);
} }
void Steam_Matchmaking_Servers::RequestFavoritesServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse ) void Steam_Matchmaking_Servers::RequestFavoritesServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{ {
PRINT_DEBUG("%s old\n", __FUNCTION__); PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
//TODO //TODO
RequestOldServerList(iApp, pRequestServersResponse, eFavoritesServer); RequestOldServerList(iApp, pRequestServersResponse, eFavoritesServer);
} }
void Steam_Matchmaking_Servers::RequestHistoryServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse ) void Steam_Matchmaking_Servers::RequestHistoryServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{ {
PRINT_DEBUG("%s old\n", __FUNCTION__); PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
//TODO //TODO
RequestOldServerList(iApp, pRequestServersResponse, eHistoryServer); RequestOldServerList(iApp, pRequestServersResponse, eHistoryServer);
} }
void Steam_Matchmaking_Servers::RequestSpectatorServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse ) void Steam_Matchmaking_Servers::RequestSpectatorServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse001 *pRequestServersResponse )
{ {
PRINT_DEBUG("%s old\n", __FUNCTION__); PRINT_DEBUG("Steam_Matchmaking_Servers::%s old\n", __FUNCTION__);
//TODO //TODO
RequestOldServerList(iApp, pRequestServersResponse, eSpectatorServer); RequestOldServerList(iApp, pRequestServersResponse, eSpectatorServer);
} }
@ -247,7 +249,7 @@ void Steam_Matchmaking_Servers::RequestSpectatorServerList( AppId_t iApp, MatchM
// RefreshComplete callback is not posted when request is released. // RefreshComplete callback is not posted when request is released.
void Steam_Matchmaking_Servers::ReleaseRequest( HServerListRequest hServerListRequest ) void Steam_Matchmaking_Servers::ReleaseRequest( HServerListRequest hServerListRequest )
{ {
PRINT_DEBUG("ReleaseRequest %p\n", hServerListRequest); PRINT_DEBUG("Steam_Matchmaking_Servers::ReleaseRequest %p\n", hServerListRequest);
auto g = std::begin(requests); auto g = std::begin(requests);
while (g != std::end(requests)) { while (g != std::end(requests)) {
if (g->id == hServerListRequest) { if (g->id == hServerListRequest) {
@ -420,7 +422,7 @@ void Steam_Matchmaking_Servers::server_details(Gameserver *g, gameserveritem_t *
server->m_nServerVersion = g->version(); server->m_nServerVersion = g->version();
server->SetName(g->server_name().c_str()); server->SetName(g->server_name().c_str());
server->m_steamID = CSteamID((uint64)g->id()); server->m_steamID = CSteamID((uint64)g->id());
PRINT_DEBUG("server_details " "%" PRIu64 "\n", g->id()); PRINT_DEBUG("Steam_Matchmaking_Servers::server_details " "%" PRIu64 "\n", g->id());
strncpy(server->m_szGameTags, g->tags().c_str(), k_cbMaxGameServerTags - 1); strncpy(server->m_szGameTags, g->tags().c_str(), k_cbMaxGameServerTags - 1);
server->m_szGameTags[k_cbMaxGameServerTags - 1] = 0; server->m_szGameTags[k_cbMaxGameServerTags - 1] = 0;
@ -457,7 +459,7 @@ void Steam_Matchmaking_Servers::server_details_players(Gameserver *g, Steam_Matc
if (ssq != NULL) ssq_server_free(ssq); if (ssq != NULL) ssq_server_free(ssq);
} }
PRINT_DEBUG("server_details_players " "%" PRIu64 "\n", g->id()); PRINT_DEBUG("Steam_Matchmaking_Servers::server_details_players " "%" PRIu64 "\n", g->id());
} }
void Steam_Matchmaking_Servers::server_details_rules(Gameserver *g, Steam_Matchmaking_Servers_Direct_IP_Request *r) void Steam_Matchmaking_Servers::server_details_rules(Gameserver *g, Steam_Matchmaking_Servers_Direct_IP_Request *r)
@ -491,7 +493,7 @@ void Steam_Matchmaking_Servers::server_details_rules(Gameserver *g, Steam_Matchm
if (ssq != NULL) ssq_server_free(ssq); if (ssq != NULL) ssq_server_free(ssq);
} }
PRINT_DEBUG("server_details_rules " "%" PRIu64 "\n", g->id()); PRINT_DEBUG("Steam_Matchmaking_Servers::server_details_rules " "%" PRIu64 "\n", g->id());
} }
// Get details on a given server in the list, you can get the valid range of index // Get details on a given server in the list, you can get the valid range of index
@ -499,16 +501,16 @@ void Steam_Matchmaking_Servers::server_details_rules(Gameserver *g, Steam_Matchm
// ISteamMatchmakingServerListResponse::ServerResponded() callbacks // ISteamMatchmakingServerListResponse::ServerResponded() callbacks
gameserveritem_t *Steam_Matchmaking_Servers::GetServerDetails( HServerListRequest hRequest, int iServer ) gameserveritem_t *Steam_Matchmaking_Servers::GetServerDetails( HServerListRequest hRequest, int iServer )
{ {
PRINT_DEBUG("GetServerDetails %p %i\n", hRequest, iServer); PRINT_DEBUG("Steam_Matchmaking_Servers::GetServerDetails %p %i\n", hRequest, iServer);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
std::vector <struct Steam_Matchmaking_Servers_Gameserver> gameservers_filtered; std::vector <struct Steam_Matchmaking_Servers_Gameserver> gameservers_filtered;
auto g = std::begin(requests); auto g = std::begin(requests);
while (g != std::end(requests)) { while (g != std::end(requests)) {
PRINT_DEBUG("equal? %p %p\n", hRequest, g->id); PRINT_DEBUG(" equal? %p %p\n", hRequest, g->id);
if (g->id == hRequest) { if (g->id == hRequest) {
gameservers_filtered = g->gameservers_filtered; gameservers_filtered = g->gameservers_filtered;
PRINT_DEBUG("found %zu\n", gameservers_filtered.size()); PRINT_DEBUG(" found %zu\n", gameservers_filtered.size());
break; break;
} }
@ -522,7 +524,7 @@ gameserveritem_t *Steam_Matchmaking_Servers::GetServerDetails( HServerListReques
Gameserver *gs = &gameservers_filtered[iServer].server; Gameserver *gs = &gameservers_filtered[iServer].server;
gameserveritem_t *server = new gameserveritem_t(); //TODO: is the new here ok? gameserveritem_t *server = new gameserveritem_t(); //TODO: is the new here ok?
server_details(gs, server); server_details(gs, server);
PRINT_DEBUG("Returned server details\n"); PRINT_DEBUG(" Returned server details\n");
return server; return server;
} }
@ -535,7 +537,7 @@ gameserveritem_t *Steam_Matchmaking_Servers::GetServerDetails( HServerListReques
// The request handle must be released using ReleaseRequest( hRequest ) // The request handle must be released using ReleaseRequest( hRequest )
void Steam_Matchmaking_Servers::CancelQuery( HServerListRequest hRequest ) void Steam_Matchmaking_Servers::CancelQuery( HServerListRequest hRequest )
{ {
PRINT_DEBUG("CancelQuery %p\n", hRequest); PRINT_DEBUG("Steam_Matchmaking_Servers::CancelQuery %p\n", hRequest);
auto g = std::begin(requests); auto g = std::begin(requests);
while (g != std::end(requests)) { while (g != std::end(requests)) {
if (g->id == hRequest) { if (g->id == hRequest) {
@ -554,14 +556,14 @@ void Steam_Matchmaking_Servers::CancelQuery( HServerListRequest hRequest )
// is released with ReleaseRequest( hRequest ) // is released with ReleaseRequest( hRequest )
void Steam_Matchmaking_Servers::RefreshQuery( HServerListRequest hRequest ) void Steam_Matchmaking_Servers::RefreshQuery( HServerListRequest hRequest )
{ {
PRINT_DEBUG("RefreshQuery %p\n", hRequest); PRINT_DEBUG("Steam_Matchmaking_Servers::RefreshQuery %p\n", hRequest);
} }
// Returns true if the list is currently refreshing its server list // Returns true if the list is currently refreshing its server list
bool Steam_Matchmaking_Servers::IsRefreshing( HServerListRequest hRequest ) bool Steam_Matchmaking_Servers::IsRefreshing( HServerListRequest hRequest )
{ {
PRINT_DEBUG("IsRefreshing %p\n", hRequest); PRINT_DEBUG("Steam_Matchmaking_Servers::IsRefreshing %p\n", hRequest);
return false; return false;
} }
@ -569,7 +571,7 @@ bool Steam_Matchmaking_Servers::IsRefreshing( HServerListRequest hRequest )
// How many servers in the given list, GetServerDetails above takes 0... GetServerCount() - 1 // How many servers in the given list, GetServerDetails above takes 0... GetServerCount() - 1
int Steam_Matchmaking_Servers::GetServerCount( HServerListRequest hRequest ) int Steam_Matchmaking_Servers::GetServerCount( HServerListRequest hRequest )
{ {
PRINT_DEBUG("GetServerCount %p\n", hRequest); PRINT_DEBUG("Steam_Matchmaking_Servers::GetServerCount %p\n", hRequest);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
int size = 0; int size = 0;
auto g = std::begin(requests); auto g = std::begin(requests);
@ -589,7 +591,7 @@ int Steam_Matchmaking_Servers::GetServerCount( HServerListRequest hRequest )
// Refresh a single server inside of a query (rather than all the servers ) // Refresh a single server inside of a query (rather than all the servers )
void Steam_Matchmaking_Servers::RefreshServer( HServerListRequest hRequest, int iServer ) void Steam_Matchmaking_Servers::RefreshServer( HServerListRequest hRequest, int iServer )
{ {
PRINT_DEBUG("RefreshServer %p\n", hRequest); PRINT_DEBUG("Steam_Matchmaking_Servers::RefreshServer %p\n", hRequest);
//TODO //TODO
} }
@ -608,7 +610,7 @@ static HServerQuery new_server_query()
// Request updated ping time and other details from a single server // Request updated ping time and other details from a single server
HServerQuery Steam_Matchmaking_Servers::PingServer( uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse ) HServerQuery Steam_Matchmaking_Servers::PingServer( uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("PingServer %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort); PRINT_DEBUG("Steam_Matchmaking_Servers::PingServer %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Steam_Matchmaking_Servers_Direct_IP_Request r; Steam_Matchmaking_Servers_Direct_IP_Request r;
r.id = new_server_query(); r.id = new_server_query();
@ -623,7 +625,7 @@ HServerQuery Steam_Matchmaking_Servers::PingServer( uint32 unIP, uint16 usPort,
// Request the list of players currently playing on a server // Request the list of players currently playing on a server
HServerQuery Steam_Matchmaking_Servers::PlayerDetails( uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse ) HServerQuery Steam_Matchmaking_Servers::PlayerDetails( uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("PlayerDetails %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort); PRINT_DEBUG("Steam_Matchmaking_Servers::PlayerDetails %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Steam_Matchmaking_Servers_Direct_IP_Request r; Steam_Matchmaking_Servers_Direct_IP_Request r;
r.id = new_server_query(); r.id = new_server_query();
@ -639,7 +641,7 @@ HServerQuery Steam_Matchmaking_Servers::PlayerDetails( uint32 unIP, uint16 usPor
// Request the list of rules that the server is running (See ISteamGameServer::SetKeyValue() to set the rules server side) // Request the list of rules that the server is running (See ISteamGameServer::SetKeyValue() to set the rules server side)
HServerQuery Steam_Matchmaking_Servers::ServerRules( uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse ) HServerQuery Steam_Matchmaking_Servers::ServerRules( uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse )
{ {
PRINT_DEBUG("ServerRules %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort); PRINT_DEBUG("Steam_Matchmaking_Servers::ServerRules %hhu.%hhu.%hhu.%hhu:%hu\n", ((unsigned char *)&unIP)[3], ((unsigned char *)&unIP)[2], ((unsigned char *)&unIP)[1], ((unsigned char *)&unIP)[0], usPort);
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
Steam_Matchmaking_Servers_Direct_IP_Request r; Steam_Matchmaking_Servers_Direct_IP_Request r;
r.id = new_server_query(); r.id = new_server_query();
@ -657,7 +659,7 @@ HServerQuery Steam_Matchmaking_Servers::ServerRules( uint32 unIP, uint16 usPort,
// to one of the above calls to avoid crashing when callbacks occur. // to one of the above calls to avoid crashing when callbacks occur.
void Steam_Matchmaking_Servers::CancelServerQuery( HServerQuery hServerQuery ) void Steam_Matchmaking_Servers::CancelServerQuery( HServerQuery hServerQuery )
{ {
PRINT_DEBUG("CancelServerQuery\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::CancelServerQuery\n");
std::lock_guard<std::recursive_mutex> lock(global_mutex); std::lock_guard<std::recursive_mutex> lock(global_mutex);
auto r = std::find_if(direct_ip_requests.begin(), direct_ip_requests.end(), [&hServerQuery](Steam_Matchmaking_Servers_Direct_IP_Request const& item) { return item.id == hServerQuery; }); auto r = std::find_if(direct_ip_requests.begin(), direct_ip_requests.end(), [&hServerQuery](Steam_Matchmaking_Servers_Direct_IP_Request const& item) { return item.id == hServerQuery; });
if (direct_ip_requests.end() == r) return; if (direct_ip_requests.end() == r) return;
@ -673,30 +675,30 @@ void Steam_Matchmaking_Servers::RunCallbacks()
while (g != std::end(gameservers)) { while (g != std::end(gameservers)) {
if (check_timedout(g->last_recv, SERVER_TIMEOUT)) { if (check_timedout(g->last_recv, SERVER_TIMEOUT)) {
g = gameservers.erase(g); g = gameservers.erase(g);
PRINT_DEBUG("SERVER TIMEOUT\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::SERVER TIMEOUT\n");
} else { } else {
++g; ++g;
} }
} }
} }
PRINT_DEBUG("REQUESTS %zu gs: %zu\n", requests.size(), gameservers.size()); PRINT_DEBUG("Steam_Matchmaking_Servers::REQUESTS %zu gs: %zu\n", requests.size(), gameservers.size());
for (auto &r : requests) { for (auto &r : requests) {
if (r.cancelled || r.completed) continue; if (r.cancelled || r.completed) continue;
r.gameservers_filtered.clear(); r.gameservers_filtered.clear();
for (auto &g : gameservers) { for (auto &g : gameservers) {
PRINT_DEBUG("game_server_check %u %u\n", g.server.appid(), r.appid); PRINT_DEBUG("Steam_Matchmaking_Servers::game_server_check %u %u\n", g.server.appid(), r.appid);
if ((g.server.appid() == r.appid) && (g.type == r.type)) { if ((g.server.appid() == r.appid) && (g.type == r.type)) {
PRINT_DEBUG("REQUESTS server found\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::REQUESTS server found\n");
r.gameservers_filtered.push_back(g); r.gameservers_filtered.push_back(g);
} }
} }
} }
std::vector <struct Steam_Matchmaking_Request> requests_temp(requests); std::vector <struct Steam_Matchmaking_Request> requests_temp(requests);
PRINT_DEBUG("REQUESTS_TEMP %zu\n", requests_temp.size()); PRINT_DEBUG("Steam_Matchmaking_Servers::REQUESTS_TEMP %zu\n", requests_temp.size());
for (auto &r : requests) { for (auto &r : requests) {
r.completed = true; r.completed = true;
} }
@ -707,7 +709,7 @@ void Steam_Matchmaking_Servers::RunCallbacks()
if (r.callbacks) { if (r.callbacks) {
for (auto &g : r.gameservers_filtered) { for (auto &g : r.gameservers_filtered) {
PRINT_DEBUG("REQUESTS server responded cb %p\n", r.id); PRINT_DEBUG("Steam_Matchmaking_Servers::REQUESTS server responded cb %p\n", r.id);
r.callbacks->ServerResponded(r.id, i); r.callbacks->ServerResponded(r.id, i);
++i; ++i;
} }
@ -721,7 +723,7 @@ void Steam_Matchmaking_Servers::RunCallbacks()
if (r.old_callbacks) { if (r.old_callbacks) {
for (auto &g : r.gameservers_filtered) { for (auto &g : r.gameservers_filtered) {
PRINT_DEBUG("old REQUESTS server responded cb %p\n", r.id); PRINT_DEBUG("Steam_Matchmaking_Servers::old REQUESTS server responded cb %p\n", r.id);
r.old_callbacks->ServerResponded(i); r.old_callbacks->ServerResponded(i);
++i; ++i;
} }
@ -746,9 +748,9 @@ void Steam_Matchmaking_Servers::RunCallbacks()
} }
for (auto &r : direct_ip_requests_temp) { for (auto &r : direct_ip_requests_temp) {
PRINT_DEBUG("dip request: %u:%hu\n", r.ip, r.port); PRINT_DEBUG("Steam_Matchmaking_Servers::dip request: %u:%hu\n", r.ip, r.port);
for (auto &g : gameservers) { for (auto &g : gameservers) {
PRINT_DEBUG("server: %u:%u\n", g.server.ip(), g.server.query_port()); PRINT_DEBUG("Steam_Matchmaking_Servers::server: %u:%u\n", g.server.ip(), g.server.query_port());
uint16 query_port = g.server.query_port(); uint16 query_port = g.server.query_port();
if (query_port == 0xFFFF) { if (query_port == 0xFFFF) {
query_port = g.server.port(); query_port = g.server.port();
@ -785,7 +787,7 @@ void Steam_Matchmaking_Servers::RunCallbacks()
void Steam_Matchmaking_Servers::Callback(Common_Message *msg) void Steam_Matchmaking_Servers::Callback(Common_Message *msg)
{ {
if (msg->has_gameserver() && msg->gameserver().type() != eFriendsServer) { if (msg->has_gameserver() && msg->gameserver().type() != eFriendsServer) {
PRINT_DEBUG("got SERVER " "%" PRIu64 ", offline:%u\n", msg->gameserver().id(), msg->gameserver().offline()); PRINT_DEBUG("Steam_Matchmaking_Servers::got SERVER " "%" PRIu64 ", offline:%u\n", msg->gameserver().id(), msg->gameserver().offline());
if (msg->gameserver().offline()) { if (msg->gameserver().offline()) {
for (auto &g : gameservers) { for (auto &g : gameservers) {
if (g.server.id() == msg->gameserver().id()) { if (g.server.id() == msg->gameserver().id()) {
@ -812,7 +814,7 @@ void Steam_Matchmaking_Servers::Callback(Common_Message *msg)
g.server.set_ip(msg->source_ip()); g.server.set_ip(msg->source_ip());
g.type = eLANServer; g.type = eLANServer;
gameservers.push_back(g); gameservers.push_back(g);
PRINT_DEBUG("SERVER ADDED\n"); PRINT_DEBUG("Steam_Matchmaking_Servers::SERVER ADDED\n");
} }
} }
} }

18
dll/steam_music.cpp
View File

@ -36,20 +36,20 @@ void Steam_Music::change_playstate(int new_playing)
bool Steam_Music::BIsEnabled() bool Steam_Music::BIsEnabled()
{ {
PRINT_DEBUG("Steam_Music::BIsEnabled\n"); PRINT_DEBUG("TODO Steam_Music::BIsEnabled\n");
return true; return true;
} }
bool Steam_Music::BIsPlaying() bool Steam_Music::BIsPlaying()
{ {
PRINT_DEBUG("Steam_Music::BIsPlaying\n"); PRINT_DEBUG("TODO Steam_Music::BIsPlaying\n");
return playing > 0; return playing > 0;
} }
AudioPlayback_Status Steam_Music::GetPlaybackStatus() AudioPlayback_Status Steam_Music::GetPlaybackStatus()
{ {
PRINT_DEBUG("Steam_Music::GetPlaybackStatus\n"); PRINT_DEBUG("TODO Steam_Music::GetPlaybackStatus\n");
if (playing == 0) { if (playing == 0) {
return AudioPlayback_Idle; return AudioPlayback_Idle;
} }
@ -67,25 +67,25 @@ AudioPlayback_Status Steam_Music::GetPlaybackStatus()
void Steam_Music::Play() void Steam_Music::Play()
{ {
PRINT_DEBUG("Steam_Music::Play\n"); PRINT_DEBUG("TODO Steam_Music::Play\n");
change_playstate(2); change_playstate(2);
} }
void Steam_Music::Pause() void Steam_Music::Pause()
{ {
PRINT_DEBUG("Steam_Music::Pause\n"); PRINT_DEBUG("TODO Steam_Music::Pause\n");
change_playstate(1); change_playstate(1);
} }
void Steam_Music::PlayPrevious() void Steam_Music::PlayPrevious()
{ {
PRINT_DEBUG("Steam_Music::PlayPrevious\n"); PRINT_DEBUG("TODO Steam_Music::PlayPrevious\n");
change_playstate(2); change_playstate(2);
} }
void Steam_Music::PlayNext() void Steam_Music::PlayNext()
{ {
PRINT_DEBUG("Steam_Music::PlayNext\n"); PRINT_DEBUG("TODO Steam_Music::PlayNext\n");
change_playstate(2); change_playstate(2);
} }
@ -93,7 +93,7 @@ void Steam_Music::PlayNext()
// volume is between 0.0 and 1.0 // volume is between 0.0 and 1.0
void Steam_Music::SetVolume( float flVolume ) void Steam_Music::SetVolume( float flVolume )
{ {
PRINT_DEBUG("Steam_Music::SetVolume\n"); PRINT_DEBUG("TODO Steam_Music::SetVolume\n");
if (flVolume > 1.0) if (flVolume > 1.0)
flVolume = 1.0; flVolume = 1.0;
@ -111,6 +111,6 @@ void Steam_Music::SetVolume( float flVolume )
float Steam_Music::GetVolume() float Steam_Music::GetVolume()
{ {
PRINT_DEBUG("Steam_Music::GetVolume\n"); PRINT_DEBUG("TODO Steam_Music::GetVolume\n");
return volume; return volume;
} }

64
dll/steam_musicremote.cpp
View File

@ -20,38 +20,38 @@
// Service Definition // Service Definition
bool Steam_MusicRemote::RegisterSteamMusicRemote( const char *pchName ) bool Steam_MusicRemote::RegisterSteamMusicRemote( const char *pchName )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::DeregisterSteamMusicRemote() bool Steam_MusicRemote::DeregisterSteamMusicRemote()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::BIsCurrentMusicRemote() bool Steam_MusicRemote::BIsCurrentMusicRemote()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::BActivationSuccess( bool bValue ) bool Steam_MusicRemote::BActivationSuccess( bool bValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::SetDisplayName( const char *pchDisplayName ) bool Steam_MusicRemote::SetDisplayName( const char *pchDisplayName )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::SetPNGIcon_64x64( void *pvBuffer, uint32 cbBufferLength ) bool Steam_MusicRemote::SetPNGIcon_64x64( void *pvBuffer, uint32 cbBufferLength )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
@ -59,37 +59,37 @@ bool Steam_MusicRemote::SetPNGIcon_64x64( void *pvBuffer, uint32 cbBufferLength
// Abilities for the user interface // Abilities for the user interface
bool Steam_MusicRemote::EnablePlayPrevious(bool bValue) bool Steam_MusicRemote::EnablePlayPrevious(bool bValue)
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::EnablePlayNext( bool bValue ) bool Steam_MusicRemote::EnablePlayNext( bool bValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::EnableShuffled( bool bValue ) bool Steam_MusicRemote::EnableShuffled( bool bValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::EnableLooped( bool bValue ) bool Steam_MusicRemote::EnableLooped( bool bValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::EnableQueue( bool bValue ) bool Steam_MusicRemote::EnableQueue( bool bValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::EnablePlaylists( bool bValue ) bool Steam_MusicRemote::EnablePlaylists( bool bValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
@ -97,25 +97,25 @@ bool Steam_MusicRemote::EnablePlaylists( bool bValue )
// Status // Status
bool Steam_MusicRemote::UpdatePlaybackStatus( AudioPlayback_Status nStatus ) bool Steam_MusicRemote::UpdatePlaybackStatus( AudioPlayback_Status nStatus )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::UpdateShuffled( bool bValue ) bool Steam_MusicRemote::UpdateShuffled( bool bValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::UpdateLooped( bool bValue ) bool Steam_MusicRemote::UpdateLooped( bool bValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::UpdateVolume( float flValue ) bool Steam_MusicRemote::UpdateVolume( float flValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
// volume is between 0.0 and 1.0 // volume is between 0.0 and 1.0
@ -123,37 +123,37 @@ bool Steam_MusicRemote::UpdateVolume( float flValue )
// Current Entry // Current Entry
bool Steam_MusicRemote::CurrentEntryWillChange() bool Steam_MusicRemote::CurrentEntryWillChange()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::CurrentEntryIsAvailable( bool bAvailable ) bool Steam_MusicRemote::CurrentEntryIsAvailable( bool bAvailable )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::UpdateCurrentEntryText( const char *pchText ) bool Steam_MusicRemote::UpdateCurrentEntryText( const char *pchText )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::UpdateCurrentEntryElapsedSeconds( int nValue ) bool Steam_MusicRemote::UpdateCurrentEntryElapsedSeconds( int nValue )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::UpdateCurrentEntryCoverArt( void *pvBuffer, uint32 cbBufferLength ) bool Steam_MusicRemote::UpdateCurrentEntryCoverArt( void *pvBuffer, uint32 cbBufferLength )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::CurrentEntryDidChange() bool Steam_MusicRemote::CurrentEntryDidChange()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
@ -161,31 +161,31 @@ bool Steam_MusicRemote::CurrentEntryDidChange()
// Queue // Queue
bool Steam_MusicRemote::QueueWillChange() bool Steam_MusicRemote::QueueWillChange()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::ResetQueueEntries() bool Steam_MusicRemote::ResetQueueEntries()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::SetQueueEntry( int nID, int nPosition, const char *pchEntryText ) bool Steam_MusicRemote::SetQueueEntry( int nID, int nPosition, const char *pchEntryText )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::SetCurrentQueueEntry( int nID ) bool Steam_MusicRemote::SetCurrentQueueEntry( int nID )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::QueueDidChange() bool Steam_MusicRemote::QueueDidChange()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
@ -193,30 +193,30 @@ bool Steam_MusicRemote::QueueDidChange()
// Playlist // Playlist
bool Steam_MusicRemote::PlaylistWillChange() bool Steam_MusicRemote::PlaylistWillChange()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::ResetPlaylistEntries() bool Steam_MusicRemote::ResetPlaylistEntries()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::SetPlaylistEntry( int nID, int nPosition, const char *pchEntryText ) bool Steam_MusicRemote::SetPlaylistEntry( int nID, int nPosition, const char *pchEntryText )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::SetCurrentPlaylistEntry( int nID ) bool Steam_MusicRemote::SetCurrentPlaylistEntry( int nID )
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }
bool Steam_MusicRemote::PlaylistDidChange() bool Steam_MusicRemote::PlaylistDidChange()
{ {
PRINT_DEBUG("%s\n", __FUNCTION__); PRINT_DEBUG("TODO Steam_MusicRemote::%s\n", __FUNCTION__);
return false; return false;
} }

12
dll/steam_parental.cpp
View File

@ -19,38 +19,38 @@
bool Steam_Parental::BIsParentalLockEnabled() bool Steam_Parental::BIsParentalLockEnabled()
{ {
PRINT_DEBUG("BIsParentalLockEnabled\n"); PRINT_DEBUG("TODO Steam_Parental::BIsParentalLockEnabled\n");
return false; return false;
} }
bool Steam_Parental::BIsParentalLockLocked() bool Steam_Parental::BIsParentalLockLocked()
{ {
PRINT_DEBUG("BIsParentalLockLocked\n"); PRINT_DEBUG("TODO Steam_Parental::BIsParentalLockLocked\n");
return false; return false;
} }
bool Steam_Parental::BIsAppBlocked( AppId_t nAppID ) bool Steam_Parental::BIsAppBlocked( AppId_t nAppID )
{ {
PRINT_DEBUG("BIsAppBlocked\n"); PRINT_DEBUG("TODO Steam_Parental::BIsAppBlocked\n");
return false; return false;
} }
bool Steam_Parental::BIsAppInBlockList( AppId_t nAppID ) bool Steam_Parental::BIsAppInBlockList( AppId_t nAppID )
{ {
PRINT_DEBUG("BIsAppInBlockList\n"); PRINT_DEBUG("TODO Steam_Parental::BIsAppInBlockList\n");
return false; return false;
} }
bool Steam_Parental::BIsFeatureBlocked( EParentalFeature eFeature ) bool Steam_Parental::BIsFeatureBlocked( EParentalFeature eFeature )
{ {
PRINT_DEBUG("BIsFeatureBlocked\n"); PRINT_DEBUG("TODO Steam_Parental::BIsFeatureBlocked\n");
return false; return false;
} }
bool Steam_Parental::BIsFeatureInBlockList( EParentalFeature eFeature ) bool Steam_Parental::BIsFeatureInBlockList( EParentalFeature eFeature )
{ {
PRINT_DEBUG("BIsFeatureInBlockList\n"); PRINT_DEBUG("TODO Steam_Parental::BIsFeatureInBlockList\n");
return false; return false;
} }

20
dll/steam_screenshots.cpp
View File

@ -33,7 +33,7 @@ ScreenshotHandle Steam_Screenshots::create_screenshot_handle()
// The return value is a handle that is valid for the duration of the game process and can be used to apply tags. // The return value is a handle that is valid for the duration of the game process and can be used to apply tags.
ScreenshotHandle Steam_Screenshots::WriteScreenshot( void *pubRGB, uint32 cubRGB, int nWidth, int nHeight ) ScreenshotHandle Steam_Screenshots::WriteScreenshot( void *pubRGB, uint32 cubRGB, int nWidth, int nHeight )
{ {
PRINT_DEBUG("WriteScreenshot\n"); PRINT_DEBUG("Steam_Screenshots::WriteScreenshot\n");
char buff[128]; char buff[128];
auto now = std::chrono::system_clock::now(); auto now = std::chrono::system_clock::now();
@ -60,7 +60,7 @@ ScreenshotHandle Steam_Screenshots::WriteScreenshot( void *pubRGB, uint32 cubRGB
// JPEG, TGA, and PNG formats are supported. // JPEG, TGA, and PNG formats are supported.
ScreenshotHandle Steam_Screenshots::AddScreenshotToLibrary( const char *pchFilename, const char *pchThumbnailFilename, int nWidth, int nHeight ) ScreenshotHandle Steam_Screenshots::AddScreenshotToLibrary( const char *pchFilename, const char *pchThumbnailFilename, int nWidth, int nHeight )
{ {
PRINT_DEBUG("AddScreenshotToLibrary\n"); PRINT_DEBUG("Steam_Screenshots::AddScreenshotToLibrary\n");
if (pchFilename == nullptr) if (pchFilename == nullptr)
return INVALID_SCREENSHOT_HANDLE; return INVALID_SCREENSHOT_HANDLE;
@ -91,7 +91,7 @@ ScreenshotHandle Steam_Screenshots::AddScreenshotToLibrary( const char *pchFilen
// Causes the Steam overlay to take a screenshot. If screenshots are being hooked by the game then a ScreenshotRequested_t callback is sent back to the game instead. // Causes the Steam overlay to take a screenshot. If screenshots are being hooked by the game then a ScreenshotRequested_t callback is sent back to the game instead.
void Steam_Screenshots::TriggerScreenshot() void Steam_Screenshots::TriggerScreenshot()
{ {
PRINT_DEBUG("TriggerScreenshot\n"); PRINT_DEBUG("Steam_Screenshots::TriggerScreenshot\n");
if (hooked) if (hooked)
{ {
@ -100,7 +100,7 @@ void Steam_Screenshots::TriggerScreenshot()
} }
else else
{ {
PRINT_DEBUG("TODO: Make the overlay take a screenshot"); PRINT_DEBUG(" TODO: Make the overlay take a screenshot");
} }
} }
@ -110,7 +110,7 @@ void Steam_Screenshots::TriggerScreenshot()
// in response. // in response.
void Steam_Screenshots::HookScreenshots( bool bHook ) void Steam_Screenshots::HookScreenshots( bool bHook )
{ {
PRINT_DEBUG("HookScreenshots\n"); PRINT_DEBUG("Steam_Screenshots::HookScreenshots\n");
hooked = bHook; hooked = bHook;
} }
@ -118,7 +118,7 @@ void Steam_Screenshots::HookScreenshots( bool bHook )
// Sets metadata about a screenshot's location (for example, the name of the map) // Sets metadata about a screenshot's location (for example, the name of the map)
bool Steam_Screenshots::SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) bool Steam_Screenshots::SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation )
{ {
PRINT_DEBUG("SetLocation\n"); PRINT_DEBUG("Steam_Screenshots::SetLocation\n");
auto it = _screenshots.find(hScreenshot); auto it = _screenshots.find(hScreenshot);
if (it == _screenshots.end()) if (it == _screenshots.end())
@ -134,7 +134,7 @@ bool Steam_Screenshots::SetLocation( ScreenshotHandle hScreenshot, const char *p
// Tags a user as being visible in the screenshot // Tags a user as being visible in the screenshot
bool Steam_Screenshots::TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) bool Steam_Screenshots::TagUser( ScreenshotHandle hScreenshot, CSteamID steamID )
{ {
PRINT_DEBUG("TagUser\n"); PRINT_DEBUG("Steam_Screenshots::TagUser\n");
auto it = _screenshots.find(hScreenshot); auto it = _screenshots.find(hScreenshot);
if (it == _screenshots.end()) if (it == _screenshots.end())
@ -150,7 +150,7 @@ bool Steam_Screenshots::TagUser( ScreenshotHandle hScreenshot, CSteamID steamID
// Tags a published file as being visible in the screenshot // Tags a published file as being visible in the screenshot
bool Steam_Screenshots::TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID ) bool Steam_Screenshots::TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID )
{ {
PRINT_DEBUG("TagPublishedFile\n"); PRINT_DEBUG("Steam_Screenshots::TagPublishedFile\n");
auto it = _screenshots.find(hScreenshot); auto it = _screenshots.find(hScreenshot);
if (it == _screenshots.end()) if (it == _screenshots.end())
@ -166,7 +166,7 @@ bool Steam_Screenshots::TagPublishedFile( ScreenshotHandle hScreenshot, Publishe
// Returns true if the app has hooked the screenshot // Returns true if the app has hooked the screenshot
bool Steam_Screenshots::IsScreenshotsHooked() bool Steam_Screenshots::IsScreenshotsHooked()
{ {
PRINT_DEBUG("IsScreenshotsHooked\n"); PRINT_DEBUG("Steam_Screenshots::IsScreenshotsHooked\n");
return hooked; return hooked;
} }
@ -178,7 +178,7 @@ bool Steam_Screenshots::IsScreenshotsHooked()
// JPEG, TGA, and PNG formats are supported. // JPEG, TGA, and PNG formats are supported.
ScreenshotHandle Steam_Screenshots::AddVRScreenshotToLibrary( EVRScreenshotType eType, const char *pchFilename, const char *pchVRFilename ) ScreenshotHandle Steam_Screenshots::AddVRScreenshotToLibrary( EVRScreenshotType eType, const char *pchFilename, const char *pchVRFilename )
{ {
PRINT_DEBUG("AddVRScreenshotToLibrary\n"); PRINT_DEBUG("Steam_Screenshots::AddVRScreenshotToLibrary\n");
return INVALID_SCREENSHOT_HANDLE; return INVALID_SCREENSHOT_HANDLE;
} }

8
dll/steam_video.cpp
View File

@ -20,14 +20,14 @@
// Get a URL suitable for streaming the given Video app ID's video // Get a URL suitable for streaming the given Video app ID's video
void Steam_Video::GetVideoURL( AppId_t unVideoAppID ) void Steam_Video::GetVideoURL( AppId_t unVideoAppID )
{ {
PRINT_DEBUG("GetVideoURL\n"); PRINT_DEBUG("TODO Steam_Video::GetVideoURL\n");
} }
// returns true if user is uploading a live broadcast // returns true if user is uploading a live broadcast
bool Steam_Video::IsBroadcasting( int *pnNumViewers ) bool Steam_Video::IsBroadcasting( int *pnNumViewers )
{ {
PRINT_DEBUG("IsBroadcasting\n"); PRINT_DEBUG("TODO Steam_Video::IsBroadcasting\n");
return false; return false;
} }
@ -36,11 +36,11 @@ bool Steam_Video::IsBroadcasting( int *pnNumViewers )
STEAM_CALL_BACK( GetOPFSettingsResult_t ) STEAM_CALL_BACK( GetOPFSettingsResult_t )
void Steam_Video::GetOPFSettings( AppId_t unVideoAppID ) void Steam_Video::GetOPFSettings( AppId_t unVideoAppID )
{ {
PRINT_DEBUG("GetOPFSettings\n"); PRINT_DEBUG("TODO Steam_Video::GetOPFSettings\n");
} }
bool Steam_Video::GetOPFStringForApp( AppId_t unVideoAppID, char *pchBuffer, int32 *pnBufferSize ) bool Steam_Video::GetOPFStringForApp( AppId_t unVideoAppID, char *pchBuffer, int32 *pnBufferSize )
{ {
PRINT_DEBUG("GetOPFStringForApp\n"); PRINT_DEBUG("TODO Steam_Video::GetOPFStringForApp\n");
return false; return false;
} }