SDK 1.56 and 1.57

public ISteamUser018,

public ISteamUser019,

public ISteamUser020,

public ISteamUser021,

public ISteamUser

{

    Settings *settings;

// Retrieve ticket to be sent to the entity who wishes to authenticate you. 

// pcbTicket retrieves the length of the actual ticket.

HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket )

{

    return GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket, NULL);

}

// SteamNetworkingIdentity is an optional input parameter to hold the public IP address or SteamID of the entity you are connecting to

// if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address

// if a Steam ID is passed Steam will only allow the ticket to be used by that Steam ID

HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSteamNetworkingIdentity )

{

    PRINT_DEBUG("Steam_User::GetAuthSessionTicket %i\n", cbMaxTicket);

    std::lock_guard<std::recursive_mutex> lock(global_mutex);

    return ticket_manager->getTicket(pTicket, cbMaxTicket, pcbTicket);

}

// Request a ticket which will be used for webapi "ISteamUserAuth\AuthenticateUserTicket"

// pchIdentity is an optional input parameter to identify the service the ticket will be sent to

// the ticket will be returned in callback GetTicketForWebApiResponse_t

HAuthTicket GetAuthTicketForWebApi( const char *pchIdentity )

{

    PRINT_DEBUG("TODO: Steam_User::GetAuthTicketForWebApi %s\n", pchIdentity);

    return 0;

}

// Authenticate ticket from entity steamID to be sure it is valid and isnt reused

// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )

EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID )

    {

        GameOverlayActivated_t data = { 0 };

        data.m_bActive = show_overlay;

        data.m_bUserInitiated = true;

        data.m_nAppID = settings->get_local_game_id().AppID();

        callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));

        overlay_state_changed = false;

#define STEAM_CONTROLLER_MAX_COUNT 16

#define STEAM_CONTROLLER_MAX_ANALOG_ACTIONS 16

#define STEAM_CONTROLLER_MAX_ANALOG_ACTIONS 24

#define STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS 128

#define STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS 256

#define STEAM_CONTROLLER_MAX_ORIGINS 8

	k_EControllerActionOrigin_SteamDeck_Reserved19,

	k_EControllerActionOrigin_SteamDeck_Reserved20,

	k_EControllerActionOrigin_Switch_JoyConButton_N, // With a Horizontal JoyCon this will be Y or what would be Dpad Right when vertical

	k_EControllerActionOrigin_Switch_JoyConButton_E, // X

	k_EControllerActionOrigin_Switch_JoyConButton_S, // A

	k_EControllerActionOrigin_Switch_JoyConButton_W, // B

	k_EControllerActionOrigin_PS5_LeftGrip,

	k_EControllerActionOrigin_PS5_RightGrip,

	k_EControllerActionOrigin_PS5_LeftFn,

	k_EControllerActionOrigin_PS5_RightFn,

	k_EControllerActionOrigin_Count, // If Steam has added support for new controllers origins will go here.

	k_EControllerActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.

};

#define ControllerAnalogActionData_t InputAnalogActionData_t

#define ControllerDigitalActionData_t InputDigitalActionData_t

#define ControllerMotionData_t  InputMotionData_t

#define ControllerMotionDataV2_t  InputMotionDataV2_t

#else

struct ControllerAnalogActionData_t

{

{

	enum { k_iCallback = k_iSteamFriendsCallbacks + 31 };

	uint8 m_bActive;		// true if it's just been activated, false otherwise

	bool m_bUserInitiated;	// true if the user asked for the overlay to be activated/deactivated

	AppId_t m_nAppID;		// the appID of the game (should always be the current game)

};

	// Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). 

	// pcbTicket retrieves the length of the actual ticket.

	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;

	// SteamNetworkingIdentity is an optional parameter to hold the public IP address of the entity you are connecting to

	// if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address

	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSnid ) = 0;

	// Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused

	// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )

	)

};

#define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer014"

#define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer015"

#ifndef STEAM_API_EXPORTS

// Global accessor

#ifndef ISTEAMGAMESERVER014_H

#define ISTEAMGAMESERVER014_H

#ifdef STEAM_WIN32

#pragma once

#endif

class ISteamGameServer014

{

public:

//

// Basic server data.  These properties, if set, must be set before before calling LogOn.  They

// may not be changed after logged in.

//

	/// This is called by SteamGameServer_Init, and you will usually not need to call it directly

	STEAM_PRIVATE_API( virtual bool InitGameServer( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char *pchVersionString ) = 0; )

	/// Game product identifier.  This is currently used by the master server for version checking purposes.

	/// It's a required field, but will eventually will go away, and the AppID will be used for this purpose.

	virtual void SetProduct( const char *pszProduct ) = 0;

	/// Description of the game.  This is a required field and is displayed in the steam server browser....for now.

	/// This is a required field, but it will go away eventually, as the data should be determined from the AppID.

	virtual void SetGameDescription( const char *pszGameDescription ) = 0;

	/// If your game is a "mod," pass the string that identifies it.  The default is an empty string, meaning

	/// this application is the original game, not a mod.

	///

	/// @see k_cbMaxGameServerGameDir

	virtual void SetModDir( const char *pszModDir ) = 0;

	/// Is this is a dedicated server?  The default value is false.

	virtual void SetDedicatedServer( bool bDedicated ) = 0;

//

// Login

//

	/// Begin process to login to a persistent game server account

	///

	/// You need to register for callbacks to determine the result of this operation.

	/// @see SteamServersConnected_t

	/// @see SteamServerConnectFailure_t

	/// @see SteamServersDisconnected_t

	virtual void LogOn( const char *pszToken ) = 0;

	/// Login to a generic, anonymous account.

	///

	/// Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init,

	/// but this is no longer the case.

	virtual void LogOnAnonymous() = 0;

	/// Begin process of logging game server out of steam

	virtual void LogOff() = 0;

	// status functions

	virtual bool BLoggedOn() = 0;

	virtual bool BSecure() = 0; 

	virtual CSteamID GetSteamID() = 0;

	/// Returns true if the master server has requested a restart.

	/// Only returns true once per request.

	virtual bool WasRestartRequested() = 0;

//

// Server state.  These properties may be changed at any time.

//

	/// Max player count that will be reported to server browser and client queries

	virtual void SetMaxPlayerCount( int cPlayersMax ) = 0;

	/// Number of bots.  Default value is zero

	virtual void SetBotPlayerCount( int cBotplayers ) = 0;

	/// Set the name of server as it will appear in the server browser

	///

	/// @see k_cbMaxGameServerName

	virtual void SetServerName( const char *pszServerName ) = 0;

	/// Set name of map to report in the server browser

	///

	/// @see k_cbMaxGameServerMapName

	virtual void SetMapName( const char *pszMapName ) = 0;

	/// Let people know if your server will require a password

	virtual void SetPasswordProtected( bool bPasswordProtected ) = 0;

	/// Spectator server port to advertise.  The default value is zero, meaning the

	/// service is not used.  If your server receives any info requests on the LAN,

	/// this is the value that will be placed into the reply for such local queries.

	///

	/// This is also the value that will be advertised by the master server.

	/// The only exception is if your server is using a FakeIP.  Then then the second

	/// fake port number (index 1) assigned to your server will be listed on the master

	/// server as the spectator port, if you set this value to any nonzero value.

	///

	/// This function merely controls the values that are advertised -- it's up to you to

	/// configure the server to actually listen on this port and handle any spectator traffic

	virtual void SetSpectatorPort( uint16 unSpectatorPort ) = 0;

	/// Name of the spectator server.  (Only used if spectator port is nonzero.)

	///

	/// @see k_cbMaxGameServerMapName

	virtual void SetSpectatorServerName( const char *pszSpectatorServerName ) = 0;

	/// Call this to clear the whole list of key/values that are sent in rules queries.

	virtual void ClearAllKeyValues() = 0;

	/// Call this to add/update a key/value pair.

	virtual void SetKeyValue( const char *pKey, const char *pValue ) = 0;

	/// Sets a string defining the "gametags" for this server, this is optional, but if it is set

	/// it allows users to filter in the matchmaking/server-browser interfaces based on the value

	///

	/// @see k_cbMaxGameServerTags

	virtual void SetGameTags( const char *pchGameTags ) = 0;

	/// Sets a string defining the "gamedata" for this server, this is optional, but if it is set

	/// it allows users to filter in the matchmaking/server-browser interfaces based on the value

	///

	/// @see k_cbMaxGameServerGameData

	virtual void SetGameData( const char *pchGameData ) = 0;

	/// Region identifier.  This is an optional field, the default value is empty, meaning the "world" region

	virtual void SetRegion( const char *pszRegion ) = 0;

	/// Indicate whether you wish to be listed on the master server list

	/// and/or respond to server browser / LAN discovery packets.

	/// The server starts with this value set to false.  You should set all

	/// relevant server parameters before enabling advertisement on the server.

	///

	/// (This function used to be named EnableHeartbeats, so if you are wondering

	/// where that function went, it's right here.  It does the same thing as before,

	/// the old name was just confusing.)

	virtual void SetAdvertiseServerActive( bool bActive ) = 0;

//

// Player list management / authentication.

//

	// Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). 

	// pcbTicket retrieves the length of the actual ticket.

	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;

	// Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused

	// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )

	virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0;

	// Stop tracking started by BeginAuthSession - called when no longer playing game with this entity

	virtual void EndAuthSession( CSteamID steamID ) = 0;

	// Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to

	virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0;

	// After receiving a user's authentication data, and passing it to SendUserConnectAndAuthenticate, use this function

	// to determine if the user owns downloadable content specified by the provided AppID.

	virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0;

	// Ask if a user in in the specified group, results returns async by GSUserGroupStatus_t

	// returns false if we're not connected to the steam servers and thus cannot ask

	virtual bool RequestUserGroupStatus( CSteamID steamIDUser, CSteamID steamIDGroup ) = 0;

	// these two functions s are deprecated, and will not return results

	// they will be removed in a future version of the SDK

	virtual void GetGameplayStats( ) = 0;

	STEAM_CALL_RESULT( GSReputation_t )

	virtual SteamAPICall_t GetServerReputation() = 0;

	// Returns the public IP of the server according to Steam, useful when the server is 

	// behind NAT and you want to advertise its IP in a lobby for other clients to directly

	// connect to

	virtual SteamIPAddress_t GetPublicIP() = 0;

// Server browser related query packet processing for shared socket mode.  These are used

// when you pass STEAMGAMESERVER_QUERY_PORT_SHARED as the query port to SteamGameServer_Init.

// IP address and port are in host order, i.e 127.0.0.1 == 0x7f000001

	// These are used when you've elected to multiplex the game server's UDP socket

	// rather than having the master server updater use its own sockets.

	// 

	// Source games use this to simplify the job of the server admins, so they 

	// don't have to open up more ports on their firewalls.

	// Call this when a packet that starts with 0xFFFFFFFF comes in. That means

	// it's for us.

	virtual bool HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort ) = 0;

	// AFTER calling HandleIncomingPacket for any packets that came in that frame, call this.

	// This gets a packet that the master server updater needs to send out on UDP.

	// It returns the length of the packet it wants to send, or 0 if there are no more packets to send.

	// Call this each frame until it returns 0.

	virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0;

//

// Server clan association

//

	// associate this game server with this clan for the purposes of computing player compat

	STEAM_CALL_RESULT( AssociateWithClanResult_t )

	virtual SteamAPICall_t AssociateWithClan( CSteamID steamIDClan ) = 0;

	// ask if any of the current players dont want to play with this new player - or vice versa

	STEAM_CALL_RESULT( ComputeNewPlayerCompatibilityResult_t )

	virtual SteamAPICall_t ComputeNewPlayerCompatibility( CSteamID steamIDNewPlayer ) = 0;

	// Handles receiving a new connection from a Steam user.  This call will ask the Steam

	// servers to validate the users identity, app ownership, and VAC status.  If the Steam servers 

	// are off-line, then it will validate the cached ticket itself which will validate app ownership 

	// and identity.  The AuthBlob here should be acquired on the game client using SteamUser()->InitiateGameConnection()

	// and must then be sent up to the game server for authentication.

	//

	// Return Value: returns true if the users ticket passes basic checks. pSteamIDUser will contain the Steam ID of this user. pSteamIDUser must NOT be NULL

	// If the call succeeds then you should expect a GSClientApprove_t or GSClientDeny_t callback which will tell you whether authentication

	// for the user has succeeded or failed (the steamid in the callback will match the one returned by this call)

	//

	// DEPRECATED!  This function will be removed from the SDK in an upcoming version.

	//              Please migrate to BeginAuthSession and related functions.

	//virtual bool SendUserConnectAndAuthenticate_DEPRECATED( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0;

	virtual bool SendUserConnectAndAuthenticate( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0;

	// Creates a fake user (ie, a bot) which will be listed as playing on the server, but skips validation.  

	// 

	// Return Value: Returns a SteamID for the user to be tracked with, you should call EndAuthSession()

	// when this user leaves the server just like you would for a real user.

	virtual CSteamID CreateUnauthenticatedUserConnection() = 0;

	// Should be called whenever a user leaves our game server, this lets Steam internally

	// track which users are currently on which servers for the purposes of preventing a single

	// account being logged into multiple servers, showing who is currently on a server, etc.

	//

	// DEPRECATED!  This function will be removed from the SDK in an upcoming version.

	//              Please migrate to BeginAuthSession and related functions.

	//virtual void SendUserDisconnect_DEPRECATED( CSteamID steamIDUser ) = 0;

	virtual void SendUserDisconnect( CSteamID steamIDUser ) = 0;

	// Update the data to be displayed in the server browser and matchmaking interfaces for a user

	// currently connected to the server.  For regular users you must call this after you receive a

	// GSUserValidationSuccess callback.

	// 

	// Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player)

	virtual bool BUpdateUserData( CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore ) = 0;

// Deprecated functions.  These will be removed in a future version of the SDK.

// If you really need these, please contact us and help us understand what you are

// using them for.

	STEAM_PRIVATE_API(

		virtual void SetMasterServerHeartbeatInterval_DEPRECATED( int iHeartbeatInterval ) = 0;

		virtual void ForceMasterServerHeartbeat_DEPRECATED() = 0;

	)

};

#endif // ISTEAMGAMESERVER014_H

#define STEAM_INPUT_MAX_COUNT 16

#define STEAM_INPUT_MAX_ANALOG_ACTIONS 16

#define STEAM_INPUT_MAX_ANALOG_ACTIONS 24

#define STEAM_INPUT_MAX_DIGITAL_ACTIONS 128

#define STEAM_INPUT_MAX_DIGITAL_ACTIONS 256

#define STEAM_INPUT_MAX_ORIGINS 8

	k_EInputActionOrigin_Switch_LeftGrip_Upper, // Left JoyCon SL Button

	k_EInputActionOrigin_Switch_RightGrip_Lower,  // Right JoyCon SL Button

	k_EInputActionOrigin_Switch_RightGrip_Upper,  // Right JoyCon SR Button

	k_EInputActionOrigin_Switch_Reserved11,

	k_EInputActionOrigin_Switch_Reserved12,

	k_EInputActionOrigin_Switch_Reserved13,

	k_EInputActionOrigin_Switch_Reserved14,

	k_EInputActionOrigin_Switch_JoyConButton_N, // With a Horizontal JoyCon this will be Y or what would be Dpad Right when vertical

	k_EInputActionOrigin_Switch_JoyConButton_E, // X

	k_EInputActionOrigin_Switch_JoyConButton_S, // A

	k_EInputActionOrigin_Switch_JoyConButton_W, // B

	k_EInputActionOrigin_Switch_Reserved15,

	k_EInputActionOrigin_Switch_Reserved16,

	k_EInputActionOrigin_Switch_Reserved17,

	k_EInputActionOrigin_PS5_Gyro_Yaw,

	k_EInputActionOrigin_PS5_Gyro_Roll,

	k_EInputActionOrigin_PS5_DPad_Move,

	k_EInputActionOrigin_PS5_Reserved1,

	k_EInputActionOrigin_PS5_Reserved2,

	k_EInputActionOrigin_PS5_Reserved3,

	k_EInputActionOrigin_PS5_Reserved4,

	k_EInputActionOrigin_PS5_LeftGrip,

	k_EInputActionOrigin_PS5_RightGrip,

	k_EInputActionOrigin_PS5_LeftFn,

	k_EInputActionOrigin_PS5_RightFn,

	k_EInputActionOrigin_PS5_Reserved5,

	k_EInputActionOrigin_PS5_Reserved6,

	k_EInputActionOrigin_PS5_Reserved7,

struct InputMotionData_t

{

	// Sensor-fused absolute rotation; will drift in heading

	// Sensor-fused absolute rotation; will drift in heading toward average

	float rotQuatX;

	float rotQuatY;

	float rotQuatZ;

	float rotVelZ;

};

struct InputMotionDataV2_t

{

	//

	// Gyro post processing:

	//

	// Drift Corrected Quaternion is calculated after steam input controller calibration values have been applied.

	// Rawest _useful_ version of a quaternion.

	// Most camera implementations should use this by comparing last rotation against current rotation, and applying the difference to the in game camera (plus your own sensitivity tweaks)

	// It is worth viewing 

	float driftCorrectedQuatX;

	float driftCorrectedQuatY;

	float driftCorrectedQuatZ;

	float driftCorrectedQuatW;

	// Sensor fusion corrects using accelerometer, and "average forward over time" for "forward".

	// This can "ouija" your aim, so it's not so  appropriate for camera controls (sensor fusion was originally made for racing game steering )

	// Same result as from old InputMotionData_t::rotQuatX/Y/Z/W

	float sensorFusionQuatX;

	float sensorFusionQuatY;

	float sensorFusionQuatZ;

	float sensorFusionQuatW;

	// Deferred Sensor fusion quaternion with deferred correction

	// Reduces perception of "ouija" effect by only applying correction when the controller is below "low noise" thresholds,

	// while the controller rotates fast - never when the user is attempting precision aim.

	float deferredSensorFusionQuatX;

	float deferredSensorFusionQuatY;

	float deferredSensorFusionQuatZ;

	float deferredSensorFusionQuatW;

	// Same as accel but values are calibrated such that 1 unit = 1G.

	// X = Right

	// Y = Forward out through the joystick USB port.

	// Z = Up through the joystick axis.

	float gravityX;

	float gravityY;

	float gravityZ;

	// 

	// Same as rotVel values in GetMotionData but values are calibrated to degrees per second.

	// Local Space (controller relative)

	// X = Pitch = left to right axis