//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
//
// The copyright to the contents herein is the property of Valve, L.L.C.
// The contents may be used and/or copied only with the written permission of
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//=============================================================================

// No spaces in event names, max length 32
// All strings are case sensitive
// total game event byte length must be < 1024
//
// valid data key types are:
//   none   : value is not networked
//   string : a zero terminated string
//   bool   : unsigned int, 1 bit
//   byte   : unsigned int, 8 bit
//   short  : signed int, 16 bit
//   long   : signed int, 32 bit
//   float  : float, 32 bit


// gameevents + hltvevents + replayevents + engineevents
"allevents"
{
//////////////////////////////////////////////////////////////////////
// Game events
//////////////////////////////////////////////////////////////////////

	"team_info"				// info about team
	{
		"teamid"	"byte"		// unique team id
		"teamname"	"string"	// team name eg "Team Blue"
	}

	"team_score"				// team score changed
	{
		"teamid"	"byte"		// team id
		"score"		"short"		// total team score
	}

	"teamplay_broadcast_audio"	// emits a sound to everyone on a team
	{
		"team"	"byte"			// unique team id
		"sound"	"string"		// name of the sound to emit
	}

	//////////////////////////////////////////////////////////////////////
	// Player events
	//////////////////////////////////////////////////////////////////////

//	"player_team"				// player change his team
//	{
//		"userid"	"short"		// user ID on server
//		"team"		"byte"		// team id
//		"oldteam" "byte"		// old team id
//		"disconnect" "bool"	// team change because player disconnects
//		"autoteam" "bool"		// true if the player was auto assigned to the team
//		"silent" "bool"			// if true wont print the team join messages
//		"name"	"string"		// player's name
//	}

	"player_class"				// a player changed his class
	{
		"userid"	"short"		// user ID on server
		"class"		"string"	// new player class / model
	}

//	"player_death"				// a game event, name may be 32 charaters long
//	{
//		"userid"	"short"   	// user ID who died
//		"attacker"	"short"	 	// user ID who killed
//	}

//	"player_hurt"
//	{
//		"userid"	"short"   	// player index who was hurt
//		"attacker"	"short"	 	// player index who attacked
//		"health"	"byte"		// remaining health points
//	}

	"player_chat"				// a public player chat
	{
		"teamonly"	"bool"		// true if team only chat
		"userid" 	"short"		// chatting player
		"text" 	 	"string"	// chat text
	}

	"player_score"				// players scores changed
	{
		"userid"	"short"		// user ID on server
		"kills"		"short"		// # of kills
		"deaths"	"short"		// # of deaths
		"score"		"short"		// total game score
	}

	"player_spawn"				// player spawned in game
	{
		"userid"	"short"		// user ID on server
	}

	"player_shoot"				// player shoot his weapon
	{
		"userid"	"short"		// user ID on server
		"weapon"	"byte"		// weapon ID
		"mode"		"byte"		// weapon mode
	}

	"player_use"
	{
		"userid"	"short"		// user ID on server
		"entity"	"short"		// entity used by player
	}

	"player_changename"
	{
		"userid"	"short"		// user ID on server
		"oldname"	"string"	// players old (current) name
		"newname"	"string"	// players new name
	}

	"player_hintmessage"
	{
		"hintmessage"	"string"	// localizable string of a hint
	}

	"base_player_teleported"
	{
		"entindex"		"short"
	}

	//////////////////////////////////////////////////////////////////////
	// Game events
	//////////////////////////////////////////////////////////////////////

	"game_init"				// sent when a new game is started
	{
	}

	"game_newmap"				// send when new map is completely loaded
	{
		"mapname"	"string"	// map name
	}

	"game_start"				// a new game starts
	{
		"roundslimit"	"long"		// max round
		"timelimit"	"long"		// time limit
		"fraglimit"	"long"		// frag limit
		"objective"	"string"	// round objective
	}

	"game_end"				// a game ended
	{
		"winner"	"byte"		// winner team/user id
	}

	"round_start"
	{
		"timelimit"	"long"		// round time limit in seconds
		"fraglimit"	"long"		// frag limit in seconds
		"objective"	"string"	// round objective
	}

	"round_end"
	{
		"winner"	"byte"		// winner team/user i
		"reason"	"byte"		// reson why team won
		"message"	"string"	// end round message
	}

	"game_message"				// a message send by game logic to everyone
	{
		"target"	"byte"		// 0 = console, 1 = HUD
		"text"		"string"	// the message text
	}

	"break_breakable"
	{
		"entindex"	"long"
		"userid"		"short"
		"material"	"byte"	// BREAK_GLASS, BREAK_WOOD, etc
	}

	"break_prop"
	{
		"entindex"	"long"
		"userid"	"short"
	}

	"entity_killed"
	{
		"entindex_killed" 	"long"
		"entindex_attacker"	"long"
		"entindex_inflictor"	"long"
		"damagebits"		"long"
	}

	"bonus_updated"
	{
		"numadvanced"	"short"
		"numbronze"	"short"
		"numsilver"	"short"
		"numgold"	"short"
	}

	"achievement_event"
	{
		"achievement_name"	"string"	// non-localized name of achievement
		"cur_val"		"short"		// # of steps toward achievement
		"max_val"		"short"		// total # of steps in achievement
	}

	// sent whenever an achievement that's tracked on the HUD increases
	"achievement_increment"
	{
		"achievement_id"	"long"	// ID of achievement that went up
		"cur_val"		"short"		// # of steps toward achievement
		"max_val"		"short"		// total # of steps in achievement
	}

	"physgun_pickup"
	{
		"entindex"		"long"		// entity picked up
	}

	"flare_ignite_npc"
	{
		"entindex"		"long"		// entity ignited
	}

	"helicopter_grenade_punt_miss"
	{
	}

	"user_data_downloaded"				// fired when achievements/stats are downloaded from Steam or XBox Live
	{
	}

	"ragdoll_dissolved"
	{
		"entindex"	"long"
	}

	"hltv_changed_mode"
	{
		"oldmode"	"short"
		"newmode"	"short"
		"obs_target" "short"
	}
	"hltv_changed_target"
	{
		"mode"		 "short"
		"old_target" "short"
		"obs_target" "short"
	}

	// Client side VoteController talking to HUD
	"vote_ended"
	{
	}
	"vote_started"
	{
		"issue"			"string"
		"param1"		"string"
		"team"			"byte"
		"initiator"		"long" // entity id of the player who initiated the vote
	}
	"vote_changed"
	{
		"vote_option1"		"byte"
		"vote_option2"		"byte"
		"vote_option3"		"byte"
		"vote_option4"		"byte"
		"vote_option5"		"byte"
		"potentialVotes"	"byte"
	}
	"vote_passed"
	{
		"details"		"string"
		"param1"		"string"
		"team"			"byte"
	}
	"vote_failed"
	{
		"team"			"byte"
	}
	"vote_cast"
	{
		"vote_option"	"byte"  // which option the player voted on
		"team"			"short"
		"entityid"		"long"	// entity id of the voter
	}
	"vote_options"
	{
		"count"			"byte"	// Number of options - up to MAX_VOTE_OPTIONS
		"option1"		"string"
		"option2"		"string"
		"option3"		"string"
		"option4"		"string"
		"option5"		"string"
	}

	//////////////////////////////////////////////////////////////////////
	// Replay events
	//////////////////////////////////////////////////////////////////////

	"replay_saved"
	{
	}

	"entered_performance_mode"
	{
	}

	"browse_replays"
	{
	}

	"replay_youtube_stats"
	{
		"views"			"long"
		"likes"			"long"
		"favorited"		"long"
	}

	//////////////////////////////////////////////////////////////////////
	// Economy events
	//////////////////////////////////////////////////////////////////////

	"inventory_updated"
	{
	}
	"cart_updated"
	{
	}
	"store_pricesheet_updated"
	{
	}
	"gc_connected"
	{
	}
	"item_schema_initialized"
	{
	}


//////////////////////////////////////////////////////////////////////
// HLTV specific events
//////////////////////////////////////////////////////////////////////

	"hltv_status"				// general HLTV status
	{
		"clients"	"long"		// number of HLTV spectators
		"slots"		"long"		// number of HLTV slots
		"proxies"	"short"		// number of HLTV proxies
		"master"	"string"	// disptach master IP:port
	}

	"hltv_cameraman"			// a spectator/player is a cameraman
	{
		"index"		"short"			// camera man entity index
	}

	"hltv_rank_camera"			// a camera ranking
	{
		"index"		"byte"			// fixed camera index
		"rank"		"float"			// ranking, how interesting is this camera view
		"target"	"short"			// best/closest target entity
	}

	"hltv_rank_entity"			// an entity ranking
	{
		"index"		"short"			// entity index
		"rank"		"float"			// ranking, how interesting is this entity to view
		"target"	"short"			// best/closest target entity
	}

	"hltv_fixed"				// show from fixed view
	{
		"posx"		"long"		// camera position in world
		"posy"		"long"
		"posz"		"long"
		"theta"		"short"		// camera angles
		"phi"			"short"
		"offset"	"short"
		"fov"			"float"
		"target"	"short"		// follow this entity or 0
	}

	"hltv_chase"					// shot of a single entity
	{
		"target1"		"short"		// primary traget index
		"target2"		"short"		// secondary traget index or 0
		"distance"	"short"		// camera distance
		"theta"			"short"		// view angle horizontal
		"phi"				"short"		// view angle vertical
		"inertia"		"byte"		// camera inertia
		"ineye"			"byte"		// diretcor suggests to show ineye
	}

	"hltv_message"	// a HLTV message send by moderators
	{
		"text"	"string"
	}

	"hltv_title"
	{
		"text"	"string"
	}

	"hltv_chat"	// a HLTV chat msg send by spectators
	{
		"text"	"string"
	}


	//////////////////////////////////////////////////////////////////////
	// replay specific events
	//////////////////////////////////////////////////////////////////////

	"replay_startrecord"	// Sent when the server begins recording - only used to display UI
	{
	}

	"replay_sessioninfo"	// Sent when the server begins recording, or when a client first connects - only sent once per recording session
	{
		"sn"	"string"	// session name
		"di"	"byte"		// dump interval
		"cb"	"long"		// current block
		"st"	"long"		// session start tick
	}

	"replay_endrecord"
	{
	}

	"replay_replaysavailable"
	{
	}

	"replay_servererror"
	{
		"error"	"string"
	}


//////////////////////////////////////////////////////////////////////
// Server events
//////////////////////////////////////////////////////////////////////

	"server_spawn"				// send once a server starts
	{
		"hostname"	"string"	// public host name
		"address"	"string"	// hostame, IP or DNS name
		"ip"		"long"
		"port"		"short"		// server port
		"game"		"string"	// game dir
		"mapname"	"string"	// map name
		"maxplayers"	"long"		// max players
		"os"		"string"	// WIN32, LINUX
		"dedicated"	"bool"		// true if dedicated server
		"password"	"bool"		// true if password protected
	}

	"server_changelevel_failed"
	{
		"levelname"	"string"	// The level name that failed changelevel
	}

	"server_shutdown" 			// server shut down
	{
		"reason"	"string"	// reason why server was shut down
	}

	"server_cvar" 				// a server console var has changed
	{
		"cvarname"	"string"	// cvar name, eg "mp_roundtime"
		"cvarvalue"	"string"	// new cvar value
	}

	"server_message"			// a generic server message
	{
		"text"		"string"	// the message text
	}

	"server_addban"
	{
		"name"		"string"	// player name
		"userid"	"short"		// user ID on server
		"networkid"	"string"	// player network (i.e steam) id
		"ip"		"string"	// IP address
		"duration"	"string"	// length of the ban
		"by"		"string"	// banned by...
		"kicked"	"bool"		// whether the player was also kicked
	}

	"server_removeban"
	{
		"networkid"	"string"	// player network (i.e steam) id
		"ip"		"string"	// IP address
		"by"		"string"	// removed by...
	}

	"player_connect"			// a new client connected - we should only really have server listeners for this, due to the IP being exposed
	{
		"name"		"string"	// player name
		"index"		"byte"		// player slot (entity index-1)
		"userid"	"short"		// user ID on server (unique on server)
		"networkid" "string" // player network (i.e steam) id
		"address"	"string"	// ip:port
		"bot"		"short"		// is a bot
	}

	"player_connect_client"		// a new client connected
	{
		"name"		"string"	// player name
		"index"		"byte"		// player slot (entity index-1)
		"userid"	"short"		// user ID on server (unique on server)
		"networkid" "string" // player network (i.e steam) id
		"bot"		"short"		// is a bot
	}

	"player_info"				// a player changed his name
	{
		"name"			"string"	// player name
		"index"			"byte"		// player slot (entity index-1)
		"userid"		"short"		// user ID on server (unique on server)
		"networkid"		"string"	// player network (i.e steam) id
		"bot"			"bool"		// true if player is a AI bot
	}

	"player_disconnect"			// a client was disconnected
	{
		"userid"	"short"		// user ID on server
		"reason"	"string"	// "self", "kick", "ban", "cheat", "error"
		"name"		"string"	// player name
		"networkid"	"string"	// player network (i.e steam) id
		"bot"		"short"		// is a bot
	}

	"player_activate"
	{
		"userid"	"short"		// user ID on server
	}

	"player_say"
	{
		"userid"	"short"		// user ID on server
		"text"		"string"	// the say text
	}

	"client_disconnect"			// client side disconnect message
	{
		"message"	"string"		// Why are we disconnecting?  This could be a localization token or an English-language string
	}

	"client_beginconnect"			// client tries to connect to server
	{
		"address"	"string"		// Name we used to connect to the server
		"ip"		"long"
		"port"		"short"			// server port
		"source"	"string"		// what caused us to attempt this connection?  (blank for general command line, "serverbrowser", "quickplay", etc)
	}

	"client_connected"			// client has completed the challenge / handshake process and is in SIGNONSTATE_CONNECTED
	{
		"address"	"string"		// Name we used to connect to the server
		"ip"		"long"
		"port"		"short"			// server port
	}

	"client_fullconnect"
	{
		"address"	"string"		// Name we used to connect to the server
		"ip"		"long"
		"port"		"short"			// server port
	}

	"host_quit"
	{
	}


//////////////////////////////////////////////////////////////////////
// CStrike events
//////////////////////////////////////////////////////////////////////

	"player_death"				// a game event, name may be 32 characters long
	{
		// this extents the original player_death by a new fields
		"userid"	"short"   	// user ID who died
		"attacker"	"short"	 	// user ID who killed
		"weapon"	"string" 	// weapon name killer used
		"headshot"	"bool"		// singals a headshot
		"dominated"	"short"		// did killer dominate victim with this kill
		"revenge"	"short"		// did killer get revenge on victim with this kill
	}

	"player_hurt"
	{
		"userid"	"short"   	// player index who was hurt
		"attacker"	"short"	 	// player index who attacked
		"health"	"byte"		// remaining health points
		"armor"		"byte"		// remaining armor points
		"weapon"	"string"	// weapon name attacker used, if not the world
		"dmg_health"	"byte"	// damage done to health
		"dmg_armor"	"byte"		// damage done to armor
		"hitgroup"	"byte"		// hitgroup that was damaged
	}

	"bomb_beginplant"
	{
		"userid"	"short"		// player who is planting the bomb
		"site"		"short"		// bombsite index
	}

	"bomb_abortplant"
	{
		"userid"	"short"		// player who is planting the bomb
		"site"		"short"		// bombsite index
	}

	"bomb_planted"
	{
		"userid"	"short"		// player who planted the bomb
		"site"		"short"		// bombsite index
		"posx"		"short"		// position x
		"posy"		"short"		// position y
	}

	"bomb_defused"
	{
		"userid"	"short"		// player who defused the bomb
		"site"		"short"		// bombsite index
	}

	"bomb_exploded"
	{
		"userid"	"short"		// player who planted the bomb
		"site"		"short"		// bombsite index
	}

	"bomb_dropped"
	{
		"userid"	"short"		// player who dropped the bomb
	}

	"bomb_pickup"
	{
		"userid"	"short"		// player who picked up the bomb
	}

	"bomb_begindefuse"
	{
		"userid"	"short"		// player who is defusing
		"haskit"	"bool"
	}

	"bomb_abortdefuse"
	{
		"userid"	"short"		// player who was defusing
	}

	"hostage_follows"
	{
		"userid"	"short"		// player who touched the hostage
		"hostage"	"short"		// hostage entity index
	}

	"hostage_hurt"
	{
		"userid"	"short"		// player who hurt the hostage
		"hostage"	"short"		// hostage entity index
	}

	"hostage_killed"
	{
		"userid"	"short"		// player who killed the hostage
		"hostage"	"short"		// hostage entity index
	}

	"hostage_rescued"
	{
		"userid"	"short"		// player who rescued the hostage
		"hostage"	"short"		// hostage entity index
		"site"		"short"		// rescue site index
	}

	"hostage_stops_following"
	{
		"userid"	"short"		// player who rescued the hostage
		"hostage"	"short"		// hostage entity index
	}

	"hostage_rescued_all"
	{
	}

	"hostage_call_for_help"
	{
		"hostage"	"short"		// hostage entity index
	}

	"vip_escaped"
	{
		"userid"	"short"		// player who was the VIP
	}

	"vip_killed"
	{
		"userid"		"short"		// player who was the VIP
		"attacker"	"short"	 	// user ID who killed the VIP
	}

	"player_radio"
	{
		"userid"	"short"
		"slot"		"short"
	}

	"bomb_beep"
	{
		"entindex"	"long"		// c4 entity
	}

	"weapon_fire"
	{
		"userid"	"short"
		"weapon"	"string" 	// weapon name used
	}

	"weapon_fire_on_empty"
	{
		"userid"	"short"
		"weapon"	"string" 	// weapon name used
	}

	"weapon_reload"
	{
		"userid"	"short"
	}

	"weapon_zoom"
	{
		"userid"	"short"
	}

	"item_pickup"
	{
		"userid"	"short"
		"item"		"string"	// either a weapon such as 'tmp' or 'hegrenade', or an item such as 'nvgs'
	}

	"grenade_bounce"
	{
		"userid"	"short"
	}

	"hegrenade_detonate"
	{
		"userid"	"short"
	        "x"        "float"
	        "y"        "float"
	        "z"        "float"
	}

	"flashbang_detonate"
	{
		"userid"	"short"
	        "x"        "float"
	        "y"        "float"
	        "z"        "float"
	}

	"smokegrenade_detonate"
	{
		"userid"	"short"
	        "x"        "float"
	        "y"        "float"
	        "z"        "float"
	}

	"bullet_impact"
	{
		"userid"	"short"
		"x"		"float"
		"y"		"float"
		"z"		"float"
	}

	"player_footstep"
	{
		"userid"	"short"
	}

	"player_jump"
	{
		"userid"	"short"
	}

	"player_blind"
	{
		"userid"	"short"
	}

	"player_falldamage"
	{
		"userid"	"short"
		"damage"	"float"
	}

	"door_moving"
	{
		"entindex"	"long"
		"userid"		"short"
	}

	"round_freeze_end"
	{
	}

	"nav_blocked"
	{
		"area"		"long"
		"blocked"	"bool"
	}

	"nav_generate"
	{
	}

	"player_stats_updated"
	{
		"forceupload"	"bool"
	}

	"spec_target_updated"
	{
	}

	"cs_win_panel_round"
	{
		"show_timer_defend"	"bool"
		"show_timer_attack"	"bool"
		"timer_time"		"short"

		"final_event"		"byte"		//define in cs_gamerules.h

		"funfact_token"		"string"
		"funfact_player"	"short"
		"funfact_data1"		"long"
		"funfact_data2"		"long"
		"funfact_data3"		"long"
	}

	"cs_win_panel_match"
	{
		"t_score"						"short"
		"ct_score"						"short"
		"t_kd"							"float"
		"ct_kd"							"float"
		"t_objectives_done"				"short"
		"ct_objectives_done"			"short"
		"t_money_earned"				"long"
		"ct_money_earned"				"long"
	}

	"show_freezepanel"
	{
		"killer"	"short"		// entindex of the killer entity
	}

	"hide_freezepanel"
	{
	}

	"freezecam_started"
	{
	}

	"player_avenged_teammate"
	{
		"avenger_id"			"short"
		"avenged_player_id"		"short"
	}

	"achievement_earned"
	{
		"player"	"byte"		// entindex of the player
		"achievement"	"short"		// achievement ID
	}

	"achievement_earned_local"
	{
		"achievement"	"short"		// achievement ID
	}

	"match_end_conditions"
	{
		"frags"			"long"
		"max_rounds"	"long"
		"win_rounds"	"long"
		"time"			"long"
	}

	"round_mvp"
	{
		"userid"		"short"
		"reason"		"short"
	}

	"player_decal"
	{
		"userid"	"short"
	}

	"teamplay_round_start"			// round restart
	{
		"full_reset"	"bool"		// is this a full reset of the map
	}

	"christmas_gift_grab"
	{
		"userid"	"short"
	}
}