//====== 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