source-engine-2018-hl2_src/gcsdk/gcsdk_gcmessages.proto

//====== Copyright 1996-2010, Valve Corporation, All rights reserved. =======
//
// Purpose: The file defines our Google Protocol Buffers which are used in over 
// the wire messages between servers as well as between the TF GC and TF gameservers
// and clients.
//
//=============================================================================

// We care more about speed than code size
option optimize_for = SPEED;

// We don't use the service generation functionality
option cc_generic_services = false;


// 
// STYLE NOTES:
//
// Use CamelCase CMsgMyMessageName style names for messages.
// 
// Use lowercase _ delimited names like my_steam_id for field names, this is non-standard for Steam,
// but plays nice with the Google formatted code generation.  
// 
// Try not to use required fields ever. Only do so if you are really really sure you'll never want them removed. 
// Optional should be preffered as it will make versioning easier and cleaner in the future if someone refactors
// your message and wants to remove or rename fields.
//
// Use fixed64 for JobId_t, GID_t, or SteamID.  This is appropriate for any field that is normally
// going to be larger than 2^56.  Otherwise use int64 for 64 bit values that are frequently smaller
// than 2^56 as it will safe space on the wire in those cases.
//
// Similar to fixed64, use fixed32 for RTime32 or other 32 bit values that are frequently larger than
// 2^28.  It will safe space in those cases, otherwise use int32 which will safe space for smaller values.
// An exception to this rule for RTime32 is if the value will frequently be zero rather than set to an actual 
// time.
//

import "steammessages.proto";

message CMsgSOIDOwner
{
	optional uint32 type = 1;
	optional uint64 id = 2;
}

//
// k_ESOMsg_Create
// k_ESOMsg_Update
// k_ESOMsg_Destroy
//
message CMsgSOSingleObject
{
	optional	fixed64		owner = 1;			// the steam ID of the owner of this object
	optional	int32		type_id = 2;		// the shared object type ID of this object
	optional	bytes		object_data = 3;	// the actual data for the object
	optional	fixed64		version = 4;		// version of the cache

	optional	CMsgSOIDOwner	owner_soid = 5;		// The SOID that owns this object
	optional	uint32			service_id = 6;		// The service that sent this update
};


//
// k_ESOMsg_UpdateMultiple
//
message CMsgSOMultipleObjects
{
	message SingleObject
	{
		optional int32		type_id = 1;		// the shared object type ID of this object
		optional bytes		object_data = 2;	// the actual data for the object
	};
	optional	fixed64			owner = 1;		// the steam ID of the owner of the objects
	repeated	SingleObject	objects = 2;	// a list of types
	optional	fixed64			version = 3;	// version of the cache
	optional	CMsgSOIDOwner	owner_soid = 6;		// The SOID that owns this object
	optional	uint32			service_id = 7;		// The service that sent this update
};


//
// k_ESOMsg_CacheSubscribed
//
message CMsgSOCacheSubscribed
{
	message SubscribedType
	{
		optional int32		type_id = 1;		// ID of the type for these objects
		repeated	bytes	object_data = 2;	// the data for all the objects of this type
	};
	
	optional	fixed64			owner = 1;		// the owner of this cache
	repeated	SubscribedType	objects = 2;	// a list of types
	optional	fixed64			version = 3;	// version of the cache
	optional	CMsgSOIDOwner	owner_soid = 4;		// The SOID that owns this object
	optional	uint32			service_id = 5;		// The service that is providing this SO cache information
	repeated	uint32			service_list = 6;	// Other services that are providing parts of this cache and need to to be received for it to be complete
	optional	fixed64			sync_version = 7;	// The unique ID of the sync to ensure all subscribes across services match. Ignored/not provided if no other GCs are involved
};

//
// k_ESOMsg_CacheSubscribedUpToDate
//
message CMsgSOCacheSubscribedUpToDate
{
	optional	fixed64			version = 1;		// version of the cache for this sub GC
	optional	CMsgSOIDOwner	owner_soid = 2;		// The SOID that owns this object
	optional	uint32			service_id = 3;		// The service that is providing this SO cache information
	repeated	uint32			service_list = 4;	// Other services that are providing parts of this cache and need to to be received for it to be complete
	optional	fixed64			sync_version = 5;	// The unique ID of the sync to ensure all subscribes across services match. Ignored/not provided if no other GCs are involved
};

//
// k_ESOMsg_CacheUnsubscribed
//
message CMsgSOCacheUnsubscribed
{
	optional	fixed64		owner = 1;			// the owner of this cache
};


//
// k_ESOMsg_CacheSubscriptionCheck
//
message CMsgSOCacheSubscriptionCheck
{
	optional	fixed64	owner = 1;		// the owner of the cache
	optional	fixed64	version = 2;			// version of the cache
	optional	CMsgSOIDOwner	owner_soid = 3;	// The SOID that owns this object
	optional	uint32 service_id = 4;			// The service associated with this version
	repeated	uint32 service_list = 5;		// The other services that need to provide information on this cache
	optional	fixed64	sync_version = 6;		// The unique ID of the sync to ensure all subscribes across services match. Ignored/not provided if no other GCs are involved
};


//
// k_ESOMsg_CacheSubscriptionRefresh
//
message CMsgSOCacheSubscriptionRefresh
{
	optional	fixed64			owner = 1;	// the owner of the cache
	optional	CMsgSOIDOwner	owner_soid = 2;		// The SOID that owns this object
};

//
// Stored in memcached for each SO Cache
//
message CMsgSOCacheVersion
{
	optional fixed64	version = 1;			// version of the cache
};

enum PartnerAccountType
{
	//the default for users, which is an account not linked to a provider
	PARTNER_NONE = 0;
	//linked to a Perfect World account
	PARTNER_PERFECT_WORLD = 1;
	//linked to a Nexon account
	PARTNER_NEXON = 2;
};

message CMsgGCMultiplexMessage
{
	optional uint32 msgtype = 1;					// ID of the message being sent
	optional bytes payload = 2;						// Serialized message to send
	repeated fixed64 steamids = 3;					// Clients to send the message to
};


// k_EGCToGCMsgMasterAck
message CGCToGCMsgMasterAck
{
	optional uint32		dir_index = 1;				// the index from the directory that this GC is responsible for
	optional string		machine_name = 3;			// the machine name that this GC is running on so that we can quickly see the universe configuration
	optional string		process_name = 4;			// the name of the process that this is running to ensure that it matches
	repeated uint32		type_instances = 5;			// the list of type instances contained within this process, must match the master directory
};

// k_EGCToGCMsgMasterAck_Response
message CGCToGCMsgMasterAck_Response
{
	optional int32 eresult = 1 [default = 2];		// Is this GC what the master thinks it should be?
};

// k_EGCToGCMsgMasterStartupComplete
message CGCToGCMsgMasterStartupComplete
{
	message GCInfo
	{
		optional uint32	dir_index = 1;
		optional string	machine_name = 2;
	};

	repeated GCInfo	gc_info = 1;
};


// k_EGCToGCMsgRouted
message CGCToGCMsgRouted
{
	optional uint32		msg_type = 1;				// the type of the contained message
	optional fixed64	sender_id = 2;				// steam ID of the client that sent this. If nil, it came from the system instead.
	optional bytes		net_message = 3;			// the binary blob contents of the contained message
};

// k_EGCToGCMsgRoutedReply
message CGCToGCMsgRoutedReply
{
	optional uint32		msg_type = 1;				// the type of the contained message
	optional bytes		net_message = 2;			// the binary blob contents of the contained message
};

// k_EMsgGCUpdateSubGCSessionInfo
message CMsgGCUpdateSubGCSessionInfo
{
	message CMsgUpdate
	{
		optional fixed64 steamid = 1;
		optional fixed32 ip = 2;
		optional bool	 trusted = 3;
	};

	repeated CMsgUpdate		updates = 1;			// the list of updates we should process (in order)
}

// k_EMsgGCRequestSubGCSessionInfo
message CMsgGCRequestSubGCSessionInfo
{
	optional fixed64 steamid = 1;
}

// k_EMsgGCRequestSubGCSessionInfoRespone
message CMsgGCRequestSubGCSessionInfoResponse
{
	optional fixed32	ip = 1;
	optional bool		trusted	= 2;
}

// k_EMsgGCToGCIncrementRecruitmentLevel
message CMsgGCToGCIncrementRecruitmentLevel
{
	optional fixed64 steamid = 1;
}


//
// CMsgSOCacheHaveVersion
//
// An array of these is sent to indicate what SO cache versions we currently have
//
message CMsgSOCacheHaveVersion
{
	optional CMsgSOIDOwner soid = 1;	// ID of the cache we have
	optional fixed64 version = 2;		// version stamp we have of this cache
	optional uint32 service_id = 3;		// For partial caches, what service this version is associated with
};

// !FIXME! DOTAMERGE
////
//// CMsgClientHello
////
//message CMsgClientHello
//{
//	optional uint32 version = 1;
//	repeated CMsgSOCacheHaveVersion socache_have_versions = 2;
//
//	/// Game-specific value indicating what state the client is in,
//	/// and what sort of session is wants.  This is used to decide
//	/// whether the client even needs a session, and if so, what
//	/// priority we should assign
//	optional uint32 client_session_need = 3;
//
//	/// What special partner-specific launcher was used, if any?
//	optional PartnerAccountType client_launcher = 4;
//
//	/// Secret Key used to gain elevated status with the GC
//	optional string secret_key = 5;
//};
//
////
//// CMsgClientWelcome
////
//message CMsgClientWelcome
//{
//	optional uint32 version = 1;
//	optional bytes game_data = 2;
//
//	// List of caches to which the client is now subscribed, but
//	// the GC thinks we don't have the latest data so it is included it here.
//	repeated CMsgSOCacheSubscribed outofdate_subscribed_caches = 3;
//
//	// List of caches to which the client is now subscribed, and the
//	// GC thinks that we already have the latest version.  (It is sending
//	// the version number just to make sure.)
//	repeated CMsgSOCacheSubscriptionCheck uptodate_subscribed_caches = 4;
//
//	// location information
//	message Location
//	{
//		optional float latitude = 1;
//		optional float longitude = 2;
//		optional string country = 3;
//	}
//
//	optional Location location = 5;
//
//	optional bytes save_game_key = 6;
//};

/// Status of connection to GC.
//
// Don't change these values, as they need to be consistent across props, since they
// are central to handshaking with clients old and new!
enum GCConnectionStatus
{
	GCConnectionStatus_HAVE_SESSION = 0; // You have a session.  (The status of one or more services may have changed.)
	GCConnectionStatus_GC_GOING_DOWN = 1; // Notification that the entire GC system is going down.
	GCConnectionStatus_NO_SESSION = 2; // You don't have a session.  Please send a hello message to initiate the session creation process.
	GCConnectionStatus_NO_SESSION_IN_LOGON_QUEUE = 3; // You don't have a session, but we have your info and will sign you on ASAP.  No need to send it again.
	GCConnectionStatus_NO_STEAM = 4; // Client-side only value.  We aren't connected to Steam.
	GCConnectionStatus_SUSPENDED = 5; // Client-side only value.  We were told that we've been suspended from connecting to this GC. No need to try again later.
};

//
// CMsgConnectionStatus
//
message CMsgConnectionStatus
{
	optional GCConnectionStatus status = 1;
	optional uint32 client_session_need = 2; // The last client session need state we got from you.

	//
	// If they are in the queue, this tells them where they are.
	//
	optional int32 queue_position = 3; // your approximate position in the queue
	optional int32 queue_size = 4; // how many people are in the queue
	optional int32 wait_seconds = 5; // how long you've been waiting
	optional int32 estimated_wait_seconds_remaining = 6; // estimated time until you are logged on.

	// TODO: Here we could include a list of services
	//       (perhaps just SO cache type ID's?) that
	//       are currently known to be offline.
};

//k_EMsgGCToGCSOCacheSubscribe
message CMsgGCToGCSOCacheSubscribe
{
	message CMsgHaveVersions
	{
		optional uint32	service_id = 1;
		optional uint64	version = 2;
	};

	optional fixed64	subscriber = 1;				// the ID of the user that is subscribing to a cache
	optional fixed64	subscribe_to = 2;			// the ID of the cache that is being subscribed to
	optional fixed64	sync_version = 3;			// the unique ID that is used to distinguish this synch across the various parts
	repeated CMsgHaveVersions	have_versions = 4;	// the version that the client has already (used to skip unnecessary sends)
};

//k_EMsgGCToGCSOCacheUnsubscribe
message CMsgGCToGCSOCacheUnsubscribe
{
	optional fixed64	subscriber = 1;				// if 0, then this means unsubscribe everyone from the cache
	optional fixed64	unsubscribe_from = 2;		// the cache we are unsubscribing from
};

// k_EMsgGCPingRequest
// k_EMsgGCPingReply
message CMsgGCClientPing
{
	// Remember, if you need to associate ping replies with requests, consider using the JobID field
};

// Do not remove this comment due to a bug on the Mac OS X protobuf compiler