You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
925 lines
27 KiB
925 lines
27 KiB
//====== 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 save 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";
|
|
|
|
// Messages
|
|
enum EGCBaseMsg
|
|
{
|
|
k_EMsgGCSystemMessage = 4001; // broadcast announcements from the GC
|
|
k_EMsgGCReplicateConVars = 4002; // GC => client
|
|
k_EMsgGCConVarUpdated = 4003; // GC => client
|
|
k_EMsgGCInQueue = 4008; // GC => client
|
|
|
|
// !GROSS! These have ben moved to gcsystemmsgs.proto. But I didn't reassign their number
|
|
//k_EMsgGCClientWelcome = 4004; // GC => client
|
|
//k_EMsgGCServerWelcome = 4005; // GC => server
|
|
//k_EMsgGCClientHello = 4006; // client => GC
|
|
//k_EMsgGCServerHello = 4007; // server => GC
|
|
//k_EMsgGCClientConnectionStatus = 4009; // GC => client
|
|
//k_EMsgGCServerConnectionStatus = 4010; // GC => server
|
|
|
|
// Matchmaking messages
|
|
k_EMsgGCInviteToParty = 4501; // inviting another player to your party
|
|
k_EMsgGCInvitationCreated = 4502; // sent from GC to sender
|
|
k_EMsgGCPartyInviteResponse = 4503; // client accepting a party invite
|
|
k_EMsgGCKickFromParty = 4504; // sent from party leader to GC to kick a player from the party
|
|
k_EMsgGCLeaveParty = 4505; // sent from party member to GC to leave a party
|
|
k_EMsgGCServerAvailable = 4506; // send from a dedicated server when its ready
|
|
k_EMsgGCClientConnectToServer = 4507; // sent to a client to connect to a server
|
|
k_EMsgGCGameServerInfo = 4508; // send from a dedicated server for server address information
|
|
k_EMsgGCError = 4509; // sent from GC to client telling client about an error
|
|
k_EMsgGCReplay_UploadedToYouTube = 4510; // client => GC
|
|
k_EMsgGCLANServerAvailable = 4511; // send from a listen server when its ready
|
|
|
|
};
|
|
|
|
//enum EGCSharedMsg = 7001-7006
|
|
|
|
enum EGCBaseProtoObjectTypes
|
|
{
|
|
k_EProtoObjectPartyInvite = 1001;
|
|
k_EProtoObjectLobbyInvite = 1002;
|
|
};
|
|
|
|
// Econ
|
|
message CGCStorePurchaseInit_LineItem
|
|
{
|
|
optional uint32 item_def_id = 1; // DefIndex of the item to purchase
|
|
optional uint32 quantity = 2; // quantity to purchase
|
|
optional uint32 cost_in_local_currency = 3; // cost in cents of the local currency the user thinks he should pay (if you change this update item_price_t!)
|
|
optional uint32 purchase_type = 4; // is this a regular purchase? a rental? maps to ECartItemType
|
|
};
|
|
|
|
// k_EMsgGCStorePurchaseInit
|
|
message CMsgGCStorePurchaseInit
|
|
{
|
|
optional string country = 1; // Country the purchase is being made from (obtained from Steam)
|
|
optional int32 language = 2; // Client's language
|
|
optional int32 currency = 3; // Currency the purchase is in (obtained from Steam)
|
|
|
|
repeated CGCStorePurchaseInit_LineItem line_items = 4;
|
|
};
|
|
|
|
// k_EMsgGCStorePurchaseInitResponse
|
|
message CMsgGCStorePurchaseInitResponse
|
|
{
|
|
optional int32 result = 1; // Result of the operation
|
|
optional uint64 txn_id = 2; // Transaction ID of the new transaction
|
|
optional string url = 3; // URL that the client will open to follow up
|
|
repeated uint64 item_ids = 4; // ItemIDs for immediately finalized txn
|
|
};
|
|
|
|
|
|
// Shared objects
|
|
|
|
//
|
|
// CSOPartyInvite - sent from the GC to possible new party member
|
|
//
|
|
message CSOPartyInvite
|
|
{
|
|
optional uint64 group_id = 1 [ (key_field) = true ];
|
|
optional fixed64 sender_id = 2;
|
|
optional string sender_name = 3;
|
|
};
|
|
|
|
// Sent from the GC to possible new lobby member
|
|
//
|
|
message CSOLobbyInvite
|
|
{
|
|
optional uint64 group_id = 1 [ (key_field) = true ];
|
|
optional fixed64 sender_id = 2;
|
|
optional string sender_name = 3;
|
|
// TODO: Game mode, etc.
|
|
};
|
|
|
|
//
|
|
// CMsgSystemBroadcast
|
|
//
|
|
message CMsgSystemBroadcast
|
|
{
|
|
optional string message = 1; // the message to display on the client
|
|
};
|
|
|
|
//
|
|
// CMsgInviteToParty - sent from party leader to the GC
|
|
//
|
|
message CMsgInviteToParty
|
|
{
|
|
optional fixed64 steam_id = 1;
|
|
optional uint32 client_version = 2;
|
|
optional uint32 team_invite = 3;
|
|
};
|
|
|
|
|
|
//
|
|
// CMsgInvitationCreated - sent from GC to the party leader
|
|
//
|
|
message CMsgInvitationCreated
|
|
{
|
|
optional uint64 group_id = 1;
|
|
optional fixed64 steam_id = 2;
|
|
};
|
|
|
|
|
|
//
|
|
// CMsgPartyInviteResponse - sent from client to GC when accepting/rejecting a CMsgPartyInvite
|
|
//
|
|
message CMsgPartyInviteResponse
|
|
{
|
|
optional uint64 party_id = 1;
|
|
optional bool accept = 2;
|
|
optional uint32 client_version = 3;
|
|
optional uint32 team_invite = 4;
|
|
};
|
|
|
|
|
|
//
|
|
// CMsgKickFromParty - sent from party leader to the GC
|
|
//
|
|
message CMsgKickFromParty
|
|
{
|
|
optional fixed64 steam_id = 1;
|
|
};
|
|
|
|
//
|
|
// CMsgLeaveParty - sent from party member to the GC
|
|
//
|
|
message CMsgLeaveParty
|
|
{
|
|
};
|
|
|
|
//
|
|
// CMsgServerAvailable - send from a dedicated server to the GC to indicate availability
|
|
//
|
|
message CMsgServerAvailable
|
|
{
|
|
};
|
|
|
|
//
|
|
// CMsgLANServerAvailable - send from a listen server to the GC to indicate availability
|
|
//
|
|
message CMsgLANServerAvailable
|
|
{
|
|
optional fixed64 lobby_id = 1;
|
|
};
|
|
|
|
|
|
//
|
|
// Used by CEconGameAccountClient
|
|
//
|
|
message CSOEconGameAccountClient
|
|
{
|
|
optional uint32 additional_backpack_slots = 1 [ default = 0 ]; // the number of backpack slots this user has on top of DEFAULT_NUM_BACKPACK_SLOTS
|
|
// optional bool trial_account = 2 [ default = false ];
|
|
// optional bool eligible_for_online_play = 3 [ default = true ];
|
|
// optional bool need_to_choose_most_helpful_friend = 4;
|
|
// optional bool in_coaches_list = 5;
|
|
// optional fixed32 trade_ban_expiration = 6;
|
|
// optional fixed32 duel_ban_expiration = 7;
|
|
// optional uint32 preview_item_def = 8 [ default = 0 ];
|
|
// optional bool made_first_purchase = 9 [ default = false ];
|
|
// optional bool eligible_for_community_market = 10;
|
|
// optional uint32 mission_refuse_allowed = 11;
|
|
optional fixed32 bonus_xp_timestamp_refresh = 12;
|
|
optional uint32 bonus_xp_usedflags = 13;
|
|
optional uint32 elevated_state = 14; // represents the state up to <= k_EGameAccountElevatedState_Elevated
|
|
optional uint32 elevated_timestamp = 15; // when applicable is the timestamp (e.g. elevation cooldown expiry, or time when became elevated, etc.)
|
|
};
|
|
|
|
//
|
|
// Used by CEconCraftingRecipe
|
|
//
|
|
message CSOItemCriteriaCondition
|
|
{
|
|
optional int32 op = 1;
|
|
optional string field = 2;
|
|
optional bool required = 3;
|
|
optional float float_value = 4;
|
|
optional string string_value = 5;
|
|
}
|
|
|
|
|
|
message CSOItemCriteria
|
|
{
|
|
optional uint32 item_level = 1;
|
|
optional int32 item_quality = 2;
|
|
|
|
optional bool item_level_set = 3;
|
|
optional bool item_quality_set = 4;
|
|
optional uint32 initial_inventory = 5;
|
|
optional uint32 initial_quantity = 6;
|
|
// optional bool forced_quality_match__DEPRECATED = 7;
|
|
optional bool ignore_enabled_flag = 8;
|
|
|
|
repeated CSOItemCriteriaCondition conditions = 9;
|
|
|
|
optional int32 item_rarity = 10;
|
|
optional bool item_rarity_set = 11;
|
|
|
|
optional bool recent_only = 12;
|
|
};
|
|
|
|
|
|
message CSOItemRecipe
|
|
{
|
|
optional uint32 def_index = 1;
|
|
optional string name = 2;
|
|
optional string n_a = 3;
|
|
optional string desc_inputs = 4;
|
|
optional string desc_outputs = 5;
|
|
optional string di_a = 6;
|
|
optional string di_b = 7;
|
|
optional string di_c = 8;
|
|
optional string do_a = 9;
|
|
optional string do_b = 10;
|
|
optional string do_c = 11;
|
|
optional bool requires_all_same_class = 12;
|
|
optional bool requires_all_same_slot = 13;
|
|
optional int32 class_usage_for_output = 14;
|
|
optional int32 slot_usage_for_output = 15;
|
|
optional int32 set_for_output = 16;
|
|
|
|
repeated CSOItemCriteria input_items_criteria = 20;
|
|
repeated CSOItemCriteria output_items_criteria = 21;
|
|
repeated uint32 input_item_dupe_counts = 22;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCDev_NewItemRequest
|
|
//
|
|
message CMsgDevNewItemRequest
|
|
{
|
|
//using fixed64 since steamids have lots of entropy in their bits
|
|
optional fixed64 receiver = 1;
|
|
optional CSOItemCriteria criteria = 2;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCIncrementKillCountAttribute
|
|
//
|
|
message CMsgIncrementKillCountAttribute
|
|
{
|
|
optional fixed32 killer_account_id = 1;
|
|
optional fixed32 victim_account_id = 2;
|
|
optional uint64 item_id = 3;
|
|
optional uint32 event_type = 4;
|
|
optional uint32 amount = 5;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCApplySticker
|
|
//
|
|
message CMsgApplySticker
|
|
{
|
|
optional uint64 sticker_item_id = 1; // which sticker are attaching?
|
|
optional uint64 item_item_id = 2; // what item are we sticking it on to?
|
|
optional uint32 sticker_slot = 3; // which sticker slot are we modifying? When attaching a sticker replace slot, when 0-sticker just applies wear.
|
|
optional uint32 baseitem_defidx = 4; // If not sticking it on existing item support sticking it on base item
|
|
optional float sticker_wear = 5; // when applying sticker wear this field specifies current wear as seen by client (to prevent double-scraping in case message reaches GC multiple times)
|
|
};
|
|
|
|
|
|
//
|
|
// k_EMsgGStatTrakSwap
|
|
//
|
|
|
|
message CMsgApplyStatTrakSwap
|
|
{
|
|
optional uint64 tool_item_id = 1; // item id of the xfer tool
|
|
optional uint64 item_1_item_id = 2;
|
|
optional uint64 item_2_item_id = 3;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCApplyStrangePart
|
|
//
|
|
message CMsgApplyStrangePart
|
|
{
|
|
optional uint64 strange_part_item_id = 1; // which part are we "inserting"?
|
|
optional uint64 item_item_id = 2; // what strange item are we inserting this new part into?
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCApplyPennantUpgrade
|
|
//
|
|
message CMsgApplyPennantUpgrade
|
|
{
|
|
optional uint64 upgrade_item_id = 1; // pennant upgrade
|
|
optional uint64 pennant_item_id = 2; // what pennant are we upgrading?
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCApplyEggEssence
|
|
//
|
|
message CMsgApplyEggEssence
|
|
{
|
|
optional uint64 essence_item_id = 1; // essence we are using
|
|
optional uint64 egg_item_id = 2; // egg target
|
|
};
|
|
|
|
//
|
|
// Used by CEconItem
|
|
//
|
|
message CSOEconItemAttribute
|
|
{
|
|
optional uint32 def_index = 1;
|
|
optional uint32 value = 2; // DEPRECATED -- see value_bytes
|
|
optional bytes value_bytes = 3;
|
|
}
|
|
|
|
message CSOEconItemEquipped
|
|
{
|
|
optional uint32 new_class = 1;
|
|
optional uint32 new_slot = 2;
|
|
}
|
|
|
|
message CSOEconItem
|
|
{
|
|
optional uint64 id = 1;
|
|
optional uint32 account_id = 2;
|
|
optional uint32 inventory = 3;
|
|
optional uint32 def_index = 4;
|
|
optional uint32 quantity = 5; // [ default = 1 ]; - Uncomment after 5/16 the client/server will have backwards compat with this change by that point
|
|
optional uint32 level = 6; // [ default = 1 ]; - Uncomment after 5/16 the client/server will have backwards compat with this change by that point
|
|
optional uint32 quality = 7;
|
|
optional uint32 flags = 8 [ default = 0 ];
|
|
optional uint32 origin = 9;
|
|
optional string custom_name = 10;
|
|
optional string custom_desc = 11;
|
|
repeated CSOEconItemAttribute attribute = 12;
|
|
optional CSOEconItem interior_item = 13;
|
|
optional bool in_use = 14 [ default = false ];
|
|
optional uint32 style = 15 [default = 0 ];
|
|
optional uint64 original_id = 16 [ default = 0 ];
|
|
// optional bool contains_equipped_state = 17;
|
|
repeated CSOEconItemEquipped equipped_state = 18;
|
|
optional uint32 rarity = 19;
|
|
}
|
|
|
|
//
|
|
// k_EMsgGCAdjustItemEquippedState
|
|
//
|
|
message CMsgAdjustItemEquippedState
|
|
{
|
|
optional uint64 item_id = 1;
|
|
optional uint32 new_class = 2;
|
|
optional uint32 new_slot = 3; // will be -1 if not equipped on this class any longer
|
|
optional bool swap = 4;
|
|
}
|
|
|
|
//
|
|
// k_EMsgGCSortItems
|
|
//
|
|
message CMsgSortItems
|
|
{
|
|
optional uint32 sort_type = 1;
|
|
}
|
|
|
|
//
|
|
// Used by CEconClaimCode
|
|
//
|
|
message CSOEconClaimCode
|
|
{
|
|
optional uint32 account_id = 1;
|
|
optional uint32 code_type = 2;
|
|
optional uint32 time_acquired = 3;
|
|
optional string code = 4;
|
|
}
|
|
|
|
//
|
|
// k_EMsgGCStoreGetUserData
|
|
//
|
|
message CMsgStoreGetUserData
|
|
{
|
|
optional fixed32 price_sheet_version = 1;
|
|
optional int32 currency = 2; // Currency that the user is requesting for pricesheet (pre-negotiated during welcome)
|
|
// 14-November-2014: for backwards compatibility with older clients only new clients request user data with currency,
|
|
// the new clients don't expect to get response as a reply to msg, but rather want a multiplexed standalone pricesheet.
|
|
// old clients still want a reply to msg.
|
|
}
|
|
|
|
|
|
//
|
|
// k_EMsgGCStoreGetUserDataResponse
|
|
//
|
|
message CMsgStoreGetUserDataResponse
|
|
{
|
|
optional int32 result = 1; // Result of the call
|
|
// 14-Nov-2014: pricesheet response is now multiplexed, no personal data included
|
|
optional int32 currency_deprecated = 2; // Currency to display to the user
|
|
optional string country_deprecated = 3; // Country the purchase is being made from (Send back in k_EMsgGCStorePurchaseInit)
|
|
|
|
optional fixed32 price_sheet_version = 4; // Version of the current price sheet on the GC
|
|
|
|
// experiments
|
|
// 14-Nov-2014: pricesheet response is now multiplexed, no personal data included
|
|
// optional uint64 experiment_data = 5 [ default = 0 ]; // top 32 bits = experiment id, bottom 32 bits = experiment group number
|
|
// optional int32 featured_item_idx = 6;
|
|
// optional bool show_hat_descriptions = 7 [ default = true ];
|
|
|
|
// Serialized KV representing the price sheet menu
|
|
optional bytes price_sheet = 8;
|
|
|
|
// optional int32 default_item_sort = 9 [ default = 0 ];
|
|
|
|
// popular items by def
|
|
// repeated uint32 popular_items = 10;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCUpdateItemSchema
|
|
//
|
|
message CMsgUpdateItemSchema
|
|
{
|
|
optional bytes items_game = 1; // actual contents of items_game.txt (only used on dev)
|
|
optional fixed32 item_schema_version = 2; // Version of the items_game.txt we're using
|
|
optional string items_game_url_DEPRECATED2013 = 3; // HTTP URL where they can use to fetch the one we're using, if theirs is out of date and we don't send the contents (deprecated in January 2014, new schema format, actual URL in field#4 now)
|
|
optional string items_game_url = 4; // HTTP URL where they can use to fetch the one we're using, if theirs is out of date and we don't send the contents (rev'd to 4 for new schema format to not explode old clients/servers)
|
|
};
|
|
|
|
// sent from the GC to a client telling him about a GC error
|
|
message CMsgGCError
|
|
{
|
|
optional string error_text = 1;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCRequestInventoryRefresh
|
|
//
|
|
message CMsgRequestInventoryRefresh
|
|
{
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCConvarUpdated
|
|
//
|
|
message CMsgConVarValue
|
|
{
|
|
optional string name = 1;
|
|
optional string value = 2;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCReplicateConVars
|
|
//
|
|
message CMsgReplicateConVars
|
|
{
|
|
repeated CMsgConVarValue convars = 1;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCUseItemRequest
|
|
//
|
|
message CMsgUseItem
|
|
{
|
|
optional uint64 item_id = 1;
|
|
optional fixed64 target_steam_id = 2; // 64-bit field left over from original message
|
|
|
|
repeated uint32 gift__potential_targets = 3;
|
|
optional uint32 duel__class_lock = 4;
|
|
optional fixed64 initiator_steam_id = 5;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCReplay_UploadedToYouTube
|
|
//
|
|
message CMsgReplayUploadedToYouTube
|
|
{
|
|
optional string youtube_url = 1;
|
|
optional string youtube_account_name = 2;
|
|
optional uint64 session_id = 3;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCConsumableExhausted
|
|
//
|
|
message CMsgConsumableExhausted
|
|
{
|
|
optional int32 item_def_id = 1;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCItemAcknowledged__DEPRECATED
|
|
//
|
|
message CMsgItemAcknowledged__DEPRECATED
|
|
{
|
|
optional uint32 account_id = 1;
|
|
optional uint32 inventory = 2;
|
|
optional uint32 def_index = 3;
|
|
optional uint32 quality = 4;
|
|
optional uint32 rarity = 5;
|
|
optional uint32 origin = 6;
|
|
optional uint64 item_id = 7;
|
|
};
|
|
|
|
//
|
|
// OBSOLETE: CMsgSetPresetItemPosition
|
|
//
|
|
// message CMsgSetPresetItemPosition
|
|
// {
|
|
// optional uint32 class_id = 1;
|
|
// optional uint32 preset_id = 2;
|
|
// optional uint32 slot_id = 3;
|
|
// optional uint64 item_id = 4;
|
|
// };
|
|
|
|
//
|
|
// CMsgSetItemPositions
|
|
//
|
|
message CMsgSetItemPositions
|
|
{
|
|
message ItemPosition
|
|
{
|
|
optional uint32 legacy_item_id = 1;
|
|
optional uint32 position = 2;
|
|
optional uint64 item_id = 3;
|
|
}
|
|
|
|
repeated ItemPosition item_positions = 1;
|
|
};
|
|
|
|
//
|
|
// OBSOLETE: CSOEconItemPresetInstance - The preset, class and slot ID's are all marked key fields, so that those
|
|
// fields will always be networked down to clients, even if only the item ID is modified. This is so that
|
|
// when CSharedObjectTypeCache::BUpdateFromMsg() calls its FindSharedObject(), it will have the necessary
|
|
// key data for CEconItemPresetInstance::BIsKeyLess() to be able to function. Without these, FindSharedObject()
|
|
// fails and no object is updated.
|
|
//
|
|
// message CSOEconItemPresetInstance
|
|
// {
|
|
// // optional uint32 account_id = 1; // NOTE: Never use id '1' again - but we don't need to transmit the account id here
|
|
// optional uint32 class_id = 2 [ (key_field) = true ];
|
|
// optional uint32 preset_id = 3 [ (key_field) = true ];
|
|
// optional uint32 slot_id = 4 [ (key_field) = true ];
|
|
// optional uint64 item_id = 5;
|
|
// };
|
|
|
|
//
|
|
// OBSOLETE: CMsgSelectItemPresetForClass
|
|
//
|
|
// message CMsgSelectItemPresetForClass
|
|
// {
|
|
// optional uint32 class_id = 1;
|
|
// optional uint32 preset_id = 2;
|
|
// };
|
|
|
|
//
|
|
// OBSOLETE: CMsgSelectItemPresetForClassReply
|
|
//
|
|
// message CMsgSelectItemPresetForClassReply
|
|
// {
|
|
// optional bool success = 1;
|
|
// };
|
|
|
|
//
|
|
// OBSOLETE: CSOSelectedItemPreset
|
|
//
|
|
// message CSOSelectedItemPreset
|
|
// {
|
|
// optional uint32 account_id = 1 [ (key_field) = true ];
|
|
// optional uint32 class_id = 2 [ (key_field) = true ];
|
|
// optional uint32 preset_id = 3;
|
|
// };
|
|
|
|
//
|
|
// k_EMsgGC_ReportAbuse
|
|
//
|
|
message CMsgGCReportAbuse
|
|
{
|
|
optional fixed64 target_steam_id = 1; // who is the user accusing?
|
|
|
|
optional string description = 4; // in the user's own words
|
|
optional uint64 gid = 5; // meaning depends on content type
|
|
|
|
// If accusing a player:
|
|
optional uint32 abuse_type = 2; // EAbuseReportType
|
|
optional uint32 content_type = 3; // ECommunityContentType
|
|
|
|
// If accusing a game server:
|
|
optional fixed32 target_game_server_ip = 6;
|
|
optional uint32 target_game_server_port = 7;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGC_ReportAbuseResponse
|
|
//
|
|
message CMsgGCReportAbuseResponse
|
|
{
|
|
optional fixed64 target_steam_id = 1; // target to which this reply is in reference
|
|
optional uint32 result = 2; // EResult
|
|
optional string error_message = 3; // Diagnostic error message (not localized, for debugging purposes only)
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCNameItemNotification
|
|
//
|
|
message CMsgGCNameItemNotification
|
|
{
|
|
optional fixed64 player_steamid = 1;
|
|
optional uint32 item_def_index = 2;
|
|
optional string item_name_custom = 3;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCClientDisplayNotification
|
|
//
|
|
message CMsgGCClientDisplayNotification
|
|
{
|
|
optional string notification_title_localization_key = 1;
|
|
optional string notification_body_localization_key = 2;
|
|
repeated string body_substring_keys = 3;
|
|
repeated string body_substring_values = 4;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCShowItemsPickedUp
|
|
//
|
|
message CMsgGCShowItemsPickedUp
|
|
{
|
|
optional fixed64 player_steamid = 1;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCIncrementKillCountResponse
|
|
//
|
|
message CMsgGCIncrementKillCountResponse // was CMsgTFIncrementKillCountResponse
|
|
{
|
|
optional uint32 killer_account_id = 1 [ (key_field) = true ]; // name of the user who got the kill
|
|
optional uint32 num_kills = 2; // number of kills (or: ubers released; or gifts given out; etc.)
|
|
optional uint32 item_def = 3; // id of the item in question
|
|
optional uint32 level_type = 4; // what sort of rank is this? (ie., kills, gifts, etc.) used for looking up strings
|
|
};
|
|
|
|
message CSOEconItemDropRateBonus
|
|
{
|
|
optional uint32 account_id = 1;
|
|
optional fixed32 expiration_date = 2;
|
|
optional float bonus = 3;
|
|
optional uint32 bonus_count = 4;
|
|
optional uint64 item_id = 5;
|
|
optional uint32 def_index = 6;
|
|
};
|
|
|
|
message CSOEconItemLeagueViewPass
|
|
{
|
|
optional uint32 account_id = 1 [ (key_field) = true ];
|
|
optional uint32 league_id = 2 [ (key_field) = true ];
|
|
optional uint32 admin = 3;
|
|
optional uint32 itemindex = 4;
|
|
};
|
|
|
|
message CSOEconItemEventTicket
|
|
{
|
|
optional uint32 account_id = 1;
|
|
optional uint32 event_id = 2;
|
|
optional uint64 item_id = 3;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCItemPreviewItemBoughtNotification
|
|
//
|
|
message CMsgGCItemPreviewItemBoughtNotification
|
|
{
|
|
optional uint32 item_def_index = 1;
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCStorePurchaseCancel
|
|
//
|
|
message CMsgGCStorePurchaseCancel
|
|
{
|
|
optional uint64 txn_id = 1; // Transaction ID for the the transaction
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCStorePurchaseCancelResponse
|
|
//
|
|
message CMsgGCStorePurchaseCancelResponse
|
|
{
|
|
optional uint32 result = 1; // Result of the operation
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCStorePurchaseFinalize
|
|
//
|
|
message CMsgGCStorePurchaseFinalize
|
|
{
|
|
optional uint64 txn_id = 1; // Transaction ID for the the transaction
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCStorePurchaseFinalizeResponse
|
|
//
|
|
message CMsgGCStorePurchaseFinalizeResponse
|
|
{
|
|
optional uint32 result = 1; // Result of the operation
|
|
repeated uint64 item_ids = 2; // If successful, list of uint64's that represent the purchased items
|
|
};
|
|
|
|
// k_EMsgGCBannedWordListRequest
|
|
message CMsgGCBannedWordListRequest
|
|
{
|
|
optional uint32 ban_list_group_id = 1; // The group code to request the word list from (English, Chinese, etc)
|
|
optional uint32 word_id = 2; // The most recent word ID that we want to request (the response will include this ID if present)
|
|
};
|
|
|
|
// k_EMsgGCRequestAnnouncements
|
|
message CMsgGCRequestAnnouncements
|
|
{
|
|
};
|
|
|
|
// k_EMsgGCRequestAnnouncementsResponse
|
|
message CMsgGCRequestAnnouncementsResponse
|
|
{
|
|
optional string announcement_title = 1; // title of the announcement
|
|
optional string announcement = 2; // announcement
|
|
optional string nextmatch_title = 3; // nextmatch title
|
|
optional string nextmatch = 4; // nextmatch
|
|
|
|
};
|
|
|
|
enum GC_BannedWordType
|
|
{
|
|
GC_BANNED_WORD_DISABLE_WORD = 0; // This word is disabled. It may be followed by an enable later
|
|
GC_BANNED_WORD_ENABLE_WORD = 1; // This word is enabled
|
|
};
|
|
|
|
message CMsgGCBannedWord
|
|
{
|
|
optional uint32 word_id = 1; // The ID of this word
|
|
optional GC_BannedWordType word_type = 2; // Enable, disable, or what
|
|
optional string word = 3; // The actual text of the word
|
|
};
|
|
|
|
// k_EMsgGCBannedWordListResponse
|
|
message CMsgGCBannedWordListResponse
|
|
{
|
|
optional uint32 ban_list_group_id = 1; // The ban list group code to request the word list from (English, Chinese, etc)
|
|
repeated CMsgGCBannedWord word_list = 2; // The list of banned word updates relevant for this group
|
|
};
|
|
|
|
// k_EMsgGCToGCBannedWordListBroadcast
|
|
message CMsgGCToGCBannedWordListBroadcast
|
|
{
|
|
optional CMsgGCBannedWordListResponse broadcast = 1; // The banned word message to broadcast
|
|
};
|
|
|
|
// k_EMsgGCToGCBannedWordListUpdated
|
|
message CMsgGCToGCBannedWordListUpdated
|
|
{
|
|
optional uint32 group_id = 1; // The id of the group that has been updated
|
|
};
|
|
|
|
message CSOEconDefaultEquippedDefinitionInstanceClient
|
|
{
|
|
optional uint32 account_id = 1 [ (key_field) = true ];
|
|
optional uint32 item_definition = 2;
|
|
optional uint32 class_id = 3 [ (key_field) = true ];
|
|
optional uint32 slot_id = 4 [ (key_field) = true ];
|
|
};
|
|
|
|
// k_EMsgGCToGCDirtySDOCache
|
|
message CMsgGCToGCDirtySDOCache
|
|
{
|
|
optional uint32 sdo_type = 1; // the type of the cache to dirty
|
|
optional uint64 key_uint64 = 2; // a 64 bit key type
|
|
};
|
|
|
|
// k_EMsgGCToGCDirtyMultipleSDOCache
|
|
message CMsgGCToGCDirtyMultipleSDOCache
|
|
{
|
|
optional uint32 sdo_type = 1; // the type of the cache to dirty
|
|
repeated uint64 key_uint64 = 2; // a 64 bit key type
|
|
};
|
|
|
|
//
|
|
// k_EMsgGCCollectItem
|
|
//
|
|
message CMsgGCCollectItem
|
|
{
|
|
optional uint64 collection_item_id = 1;
|
|
optional uint64 subject_item_id = 2;
|
|
};
|
|
|
|
// No ID - Used for SDO objects that don't make use of memcached and therefore don't need to serialize into a proto object
|
|
message CMsgSDONoMemcached
|
|
{
|
|
};
|
|
|
|
// k_EMsgGCToGCUpdateSQLKeyValue
|
|
message CMsgGCToGCUpdateSQLKeyValue
|
|
{
|
|
optional string key_name = 1;
|
|
};
|
|
|
|
// k_EMsgGCToGCIsTrustedServer
|
|
message CMsgGCToGCIsTrustedServer
|
|
{
|
|
optional fixed64 steam_id = 1;
|
|
};
|
|
|
|
// k_EMsgGCToGCIsTrustedServerResponse
|
|
message CMsgGCToGCIsTrustedServerResponse
|
|
{
|
|
optional bool is_trusted = 1;
|
|
};
|
|
|
|
// k_EMsgGCToGCBroadcastConsoleCommand
|
|
message CMsgGCToGCBroadcastConsoleCommand
|
|
{
|
|
optional string con_command = 1;
|
|
};
|
|
|
|
// k_EMsgGCServerVersionUpdated
|
|
message CMsgGCServerVersionUpdated
|
|
{
|
|
optional uint32 server_version = 1;
|
|
};
|
|
|
|
// k_EMsgGCClientVersionUpdated
|
|
message CMsgGCClientVersionUpdated
|
|
{
|
|
optional uint32 client_version = 1;
|
|
};
|
|
|
|
// k_EMsgGCToGCWebAPIAccountChanged
|
|
message CMsgGCToGCWebAPIAccountChanged
|
|
{
|
|
};
|
|
|
|
// k_EMsgGCRequestPassportItemGrant
|
|
message CMsgGCToGCRequestPassportItemGrant
|
|
{
|
|
optional fixed64 steam_id = 1;
|
|
optional uint32 league_id = 2;
|
|
optional int32 reward_flag = 3;
|
|
};
|
|
|
|
//
|
|
// CMsgGameServerInfo - server address information
|
|
//
|
|
message CMsgGameServerInfo
|
|
{
|
|
optional fixed32 server_public_ip_addr = 1;
|
|
optional fixed32 server_private_ip_addr = 2;
|
|
optional uint32 server_port = 3;
|
|
optional uint32 server_tv_port = 4;
|
|
optional string server_key = 5;
|
|
optional bool server_hibernation = 6;
|
|
enum ServerType
|
|
{
|
|
UNSPECIFIED = 0; // We haven't received the type yet
|
|
GAME = 1; // Game server
|
|
PROXY = 2; // Source TV proxy relay
|
|
}
|
|
optional ServerType server_type = 7 [ default = UNSPECIFIED ];
|
|
optional uint32 server_region = 8; // Region value that matches regions.txt in the GC
|
|
optional float server_loadavg = 9; // current load average
|
|
optional float server_tv_broadcast_time = 10; // This may be negative if the game hasn't started broadcasting
|
|
optional float server_game_time = 11; // Current game clock time
|
|
optional fixed64 server_relay_connected_steam_id = 12; // SteamID of the game or relay server this relay is connected to
|
|
optional uint32 relay_slots_max = 13; // slots total on relay
|
|
optional int32 relays_connected = 14; // count of relays connected
|
|
optional int32 relay_clients_connected = 15; // count of clients connected (all types)
|
|
optional fixed64 relayed_game_server_steam_id = 16; // SteamID of the game server this relay is relaying
|
|
optional uint32 parent_relay_count = 17; // The count of parent relays above this relay
|
|
optional fixed64 tv_secret_code = 18; // The randomly generated ID for this server that requesting connections must use to hash the connecting steam ID to create a unique connection code
|
|
};
|
|
|
|
// Do not remove this comment due to a bug on the Mac OS X protobuf compiler - lol
|
|
|