csgo/cstrike15_src/game/shared/base_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 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