EventTypes.hpp

Go to the documentation of this file.

// Generated by `voltmod framework eventgen` from the game's .gameevents files. Do not edit.
 
#pragma once
 
#include <VoltMod/Engine/EngineTypes.hpp>
#include <VoltMod/Engine/Team.hpp>
#include <VoltMod/Entities/HitGroup.hpp>
#include <VoltMod/Events/BulletImpact.hpp>
#include <cstdint>
#include <string>
#include <string_view>
 
namespace VoltMod
{
 
// Every game event, decoded once in From(). A player the event is about is `Slot`, any other is
// `<Key>Slot`; both are -1 when absent. `GameEvents::On` drops an event whose `Slot` is not a
// valid slot.
 
struct AchievementEarned
{
    static constexpr std::string_view EventName = "achievement_earned";
    int PlayerSlot = -1;  ///< entindex of the player
    int Achievement = 0;  ///< achievement ID
    static AchievementEarned From(IGameEvent& e);
};
 
struct AchievementEarnedLocal
{
    static constexpr std::string_view EventName = "achievement_earned_local";
    int Achievement = 0;        ///< achievement ID
    int Splitscreenplayer = 0;  ///< splitscreen ID
    static AchievementEarnedLocal From(IGameEvent& e);
};
 
struct AchievementEvent
{
    static constexpr std::string_view EventName = "achievement_event";
    std::string AchievementName;  ///< non-localized name of achievement
    int CurVal = 0;               ///< # of steps toward achievement
    int MaxVal = 0;               ///< total # of steps in achievement
    static AchievementEvent From(IGameEvent& e);
};
 
struct AchievementInfoLoaded
{
    static constexpr std::string_view EventName = "achievement_info_loaded";
    static AchievementInfoLoaded From(IGameEvent& e);
};
 
struct AchievementWriteFailed
{
    static constexpr std::string_view EventName = "achievement_write_failed";
    static AchievementWriteFailed From(IGameEvent& e);
};
 
struct AddBulletHitMarker
{
    static constexpr std::string_view EventName = "add_bullet_hit_marker";
    int Slot = -1;
    int Bone = 0;
    int PosX = 0;
    int PosY = 0;
    int PosZ = 0;
    int AngX = 0;
    int AngY = 0;
    int AngZ = 0;
    int StartX = 0;
    int StartY = 0;
    int StartZ = 0;
    bool Hit = false;
    static AddBulletHitMarker From(IGameEvent& e);
};
 
struct AddPlayerSonarIcon
{
    static constexpr std::string_view EventName = "add_player_sonar_icon";
    int Slot = -1;
    float PosX = 0.0f;
    float PosY = 0.0f;
    float PosZ = 0.0f;
    static AddPlayerSonarIcon From(IGameEvent& e);
};
 
struct AmmoPickup
{
    static constexpr std::string_view EventName = "ammo_pickup";
    int Slot = -1;
    std::string Item;  ///< either a weapon such as 'tmp' or 'hegrenade', or an item such as 'nvgs'
    int Index = 0;     ///< the weapon entindex
    static AmmoPickup From(IGameEvent& e);
};
 
struct AmmoRefill
{
    static constexpr std::string_view EventName = "ammo_refill";
    int Slot = -1;
    bool Success = false;
    static AmmoRefill From(IGameEvent& e);
};
 
struct AnnouncePhaseEnd
{
    static constexpr std::string_view EventName = "announce_phase_end";
    static AnnouncePhaseEnd From(IGameEvent& e);
};
 
struct BeginNewMatch
{
    static constexpr std::string_view EventName = "begin_new_match";
    static BeginNewMatch From(IGameEvent& e);
};
 
struct BombAbortdefuse
{
    static constexpr std::string_view EventName = "bomb_abortdefuse";
    int Slot = -1;  ///< player who was defusing
    static BombAbortdefuse From(IGameEvent& e);
};
 
struct BombAbortplant
{
    static constexpr std::string_view EventName = "bomb_abortplant";
    int Slot = -1;  ///< player who is planting the bomb
    int Site = 0;   ///< bombsite index
    static BombAbortplant From(IGameEvent& e);
};
 
struct BombBeep
{
    static constexpr std::string_view EventName = "bomb_beep";
    int Entindex = 0;  ///< c4 entity
    static BombBeep From(IGameEvent& e);
};
 
struct BombBegindefuse
{
    static constexpr std::string_view EventName = "bomb_begindefuse";
    int Slot = -1;  ///< player who is defusing
    bool Haskit = false;
    static BombBegindefuse From(IGameEvent& e);
};
 
struct BombBeginplant
{
    static constexpr std::string_view EventName = "bomb_beginplant";
    int Slot = -1;  ///< player who is planting the bomb
    int Site = 0;   ///< bombsite index
    static BombBeginplant From(IGameEvent& e);
};
 
struct BombDefused
{
    static constexpr std::string_view EventName = "bomb_defused";
    int Slot = -1;  ///< player who defused the bomb
    int Site = 0;   ///< bombsite index
    int C4 = 0;
    static BombDefused From(IGameEvent& e);
};
 
struct BombDropped
{
    static constexpr std::string_view EventName = "bomb_dropped";
    int Slot = -1;  ///< player who dropped the bomb
    int Entindex = 0;
    static BombDropped From(IGameEvent& e);
};
 
struct BombExploded
{
    static constexpr std::string_view EventName = "bomb_exploded";
    int Slot = -1;  ///< player who planted the bomb
    int Site = 0;   ///< bombsite index
    int C4 = 0;
    static BombExploded From(IGameEvent& e);
};
 
struct BombPickup
{
    static constexpr std::string_view EventName = "bomb_pickup";
    // skipped: userid: player_pawn
    static BombPickup From(IGameEvent& e);
};
 
struct BombPlanted
{
    static constexpr std::string_view EventName = "bomb_planted";
    int Slot = -1;  ///< player who planted the bomb
    int Site = 0;   ///< bombsite index
    int C4 = 0;
    static BombPlanted From(IGameEvent& e);
};
 
struct BonusUpdated
{
    static constexpr std::string_view EventName = "bonus_updated";
    int Numadvanced = 0;
    int Numbronze = 0;
    int Numsilver = 0;
    int Numgold = 0;
    static BonusUpdated From(IGameEvent& e);
};
 
struct BotTakeover
{
    static constexpr std::string_view EventName = "bot_takeover";
    int Slot = -1;
    int BotidSlot = -1;
    float P = 0.0f;
    float Y = 0.0f;
    float R = 0.0f;
    static BotTakeover From(IGameEvent& e);
};
 
struct BreakBreakable
{
    static constexpr std::string_view EventName = "break_breakable";
    int Entindex = 0;
    int Material = 0;  ///< BREAK_GLASS, BREAK_WOOD, etc
    // skipped: userid: player_pawn
    static BreakBreakable From(IGameEvent& e);
};
 
struct BreakProp
{
    static constexpr std::string_view EventName = "break_prop";
    int Entindex = 0;
    // skipped: userid: player_pawn
    static BreakProp From(IGameEvent& e);
};
 
struct BrokenBreakable
{
    static constexpr std::string_view EventName = "broken_breakable";
    int Entindex = 0;
    int Material = 0;  ///< BREAK_GLASS, BREAK_WOOD, etc
    // skipped: userid: player_pawn
    static BrokenBreakable From(IGameEvent& e);
};
 
struct BulletDamage
{
    static constexpr std::string_view EventName = "bullet_damage";
    int VictimSlot = -1;           ///< player index who was hurt
    int AttackerSlot = -1;         ///< player index who attacked
    float Distance = 0.0f;         ///< how far the bullet travelled before it hit the player
    float DamageDirX = 0.0f;       ///< direction vector of the bullet
    float DamageDirY = 0.0f;       ///< direction vector of the bullet
    float DamageDirZ = 0.0f;       ///< direction vector of the bullet
    int NumPenetrations = 0;       ///< how many surfaces were penetrated
    bool NoScope = false;          ///< was the shooter noscoped?
    bool InAir = false;            ///< was the shooter jumping?
    float ShootAngX = 0.0f;        ///< shoot angle x
    float ShootAngY = 0.0f;        ///< shoot angle y
    float ShootAngZ = 0.0f;        ///< shoot angle z
    float AimPunchX = 0.0f;        ///< aim punch x
    float AimPunchY = 0.0f;        ///< aim punch y
    float AimPunchZ = 0.0f;        ///< aim punch z
    int AttackTickCount = 0;       ///< attack tick
    float AttackTickFrac = 0.0f;   ///< attack frac
    int RenderTickCount = 0;       ///< render tick
    float RenderTickFrac = 0.0f;   ///< render frac
    float InaccuracyTotal = 0.0f;  ///< total inaccuracy
    float InaccuracyMove = 0.0f;   ///< move inaccuracy
    float InaccuracyAir = 0.0f;    ///< air inaccuracy
    float RecoilIndex = 0.0f;      ///< recoil index. Yes this is really a float.
    int Type = 0;                  ///< lag compensation type
    static BulletDamage From(IGameEvent& e);
};
 
struct BuymenuClose
{
    static constexpr std::string_view EventName = "buymenu_close";
    int Slot = -1;
    static BuymenuClose From(IGameEvent& e);
};
 
struct BuymenuOpen
{
    static constexpr std::string_view EventName = "buymenu_open";
    static BuymenuOpen From(IGameEvent& e);
};
 
struct BuytimeEnded
{
    static constexpr std::string_view EventName = "buytime_ended";
    static BuytimeEnded From(IGameEvent& e);
};
 
struct CartUpdated
{
    static constexpr std::string_view EventName = "cart_updated";
    static CartUpdated From(IGameEvent& e);
};
 
struct ChoppersIncomingWarning
{
    static constexpr std::string_view EventName = "choppers_incoming_warning";
    bool Global = false;
    static ChoppersIncomingWarning From(IGameEvent& e);
};
 
struct ClientDisconnect
{
    static constexpr std::string_view EventName = "client_disconnect";
    static ClientDisconnect From(IGameEvent& e);
};
 
struct ClientLoadoutChanged
{
    static constexpr std::string_view EventName = "client_loadout_changed";
    static ClientLoadoutChanged From(IGameEvent& e);
};
 
struct ClientsideLessonClosed
{
    static constexpr std::string_view EventName = "clientside_lesson_closed";
    std::string LessonName;
    static ClientsideLessonClosed From(IGameEvent& e);
};
 
struct ClientsideReloadCustomEcon
{
    static constexpr std::string_view EventName = "clientside_reload_custom_econ";
    std::string Steamid;
    static ClientsideReloadCustomEcon From(IGameEvent& e);
};
 
struct CsGameDisconnected
{
    static constexpr std::string_view EventName = "cs_game_disconnected";
    static CsGameDisconnected From(IGameEvent& e);
};
 
struct CsIntermission
{
    static constexpr std::string_view EventName = "cs_intermission";
    static CsIntermission From(IGameEvent& e);
};
 
struct CsMatchEndRestart
{
    static constexpr std::string_view EventName = "cs_match_end_restart";
    static CsMatchEndRestart From(IGameEvent& e);
};
 
struct CsPreRestart
{
    static constexpr std::string_view EventName = "cs_pre_restart";
    static CsPreRestart From(IGameEvent& e);
};
 
struct CsPrevNextSpectator
{
    static constexpr std::string_view EventName = "cs_prev_next_spectator";
    bool Next = false;
    static CsPrevNextSpectator From(IGameEvent& e);
};
 
struct CsRoundFinalBeep
{
    static constexpr std::string_view EventName = "cs_round_final_beep";
    static CsRoundFinalBeep From(IGameEvent& e);
};
 
struct CsRoundStartBeep
{
    static constexpr std::string_view EventName = "cs_round_start_beep";
    static CsRoundStartBeep From(IGameEvent& e);
};
 
struct CsWinPanelMatch
{
    static constexpr std::string_view EventName = "cs_win_panel_match";
    static CsWinPanelMatch From(IGameEvent& e);
};
 
struct CsWinPanelRound
{
    static constexpr std::string_view EventName = "cs_win_panel_round";
    bool ShowTimerDefend = false;
    bool ShowTimerAttack = false;
    int TimerTime = 0;
    int FinalEvent = 0;  ///< define in cs_gamerules.h
    std::string FunfactToken;
    int FunfactPlayerSlot = -1;
    int FunfactData1 = 0;
    int FunfactData2 = 0;
    int FunfactData3 = 0;
    static CsWinPanelRound From(IGameEvent& e);
};
 
struct DecoyDetonate
{
    static constexpr std::string_view EventName = "decoy_detonate";
    int Slot = -1;
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static DecoyDetonate From(IGameEvent& e);
};
 
struct DecoyFiring
{
    static constexpr std::string_view EventName = "decoy_firing";
    int Slot = -1;
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static DecoyFiring From(IGameEvent& e);
};
 
struct DecoyStarted
{
    static constexpr std::string_view EventName = "decoy_started";
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    // skipped: userid: player_pawn
    static DecoyStarted From(IGameEvent& e);
};
 
struct DefuserDropped
{
    static constexpr std::string_view EventName = "defuser_dropped";
    int Entityid = 0;  ///< defuser's entity ID
    static DefuserDropped From(IGameEvent& e);
};
 
struct DefuserPickup
{
    static constexpr std::string_view EventName = "defuser_pickup";
    int Entityid = 0;  ///< defuser's entity ID
    int Slot = -1;     ///< player who picked up the defuser
    static DefuserPickup From(IGameEvent& e);
};
 
struct DemoSkip
{
    static constexpr std::string_view EventName = "demo_skip";
    int PlaybackTick = 0;  ///< current playback tick
    int SkiptoTick = 0;    ///< tick we're going to
    // skipped: user_message_list: local
    // skipped: dota_hero_chase_list: local
    static DemoSkip From(IGameEvent& e);
};
 
struct DemoStart
{
    static constexpr std::string_view EventName = "demo_start";
    // skipped: dota_combatlog_list: local
    // skipped: dota_hero_chase_list: local
    // skipped: dota_pick_hero_list: local
    static DemoStart From(IGameEvent& e);
};
 
struct DemoStop
{
    static constexpr std::string_view EventName = "demo_stop";
    static DemoStop From(IGameEvent& e);
};
 
struct DifficultyChanged
{
    static constexpr std::string_view EventName = "difficulty_changed";
    int NewDifficulty = 0;
    int OldDifficulty = 0;
    std::string StrDifficulty;  ///< new difficulty as string
    static DifficultyChanged From(IGameEvent& e);
};
 
struct DmBonusWeaponStart
{
    static constexpr std::string_view EventName = "dm_bonus_weapon_start";
    int Time = 0;  ///< The length of time that this bonus lasts
    int Pos = 0;   ///< Loadout position of the bonus weapon
    static DmBonusWeaponStart From(IGameEvent& e);
};
 
struct DoorBreak
{
    static constexpr std::string_view EventName = "door_break";
    int Entindex = 0;
    int Dmgstate = 0;
    static DoorBreak From(IGameEvent& e);
};
 
struct DoorClose
{
    static constexpr std::string_view EventName = "door_close";
    bool Checkpoint = false;  ///< Is the door a checkpoint door
    // skipped: userid: player_pawn
    static DoorClose From(IGameEvent& e);
};
 
struct DoorClosed
{
    static constexpr std::string_view EventName = "door_closed";
    int Entindex = 0;
    // skipped: userid: player_pawn
    static DoorClosed From(IGameEvent& e);
};
 
struct DoorMoving
{
    static constexpr std::string_view EventName = "door_moving";
    int Slot = -1;
    int Entindex = 0;
    static DoorMoving From(IGameEvent& e);
};
 
struct DoorOpen
{
    static constexpr std::string_view EventName = "door_open";
    int Entindex = 0;
    // skipped: userid: player_pawn
    static DoorOpen From(IGameEvent& e);
};
 
struct DroneAboveRoof
{
    static constexpr std::string_view EventName = "drone_above_roof";
    int Slot = -1;
    int Cargo = 0;
    static DroneAboveRoof From(IGameEvent& e);
};
 
struct DroneCargoDetached
{
    static constexpr std::string_view EventName = "drone_cargo_detached";
    int Slot = -1;
    int Cargo = 0;
    bool Delivered = false;
    static DroneCargoDetached From(IGameEvent& e);
};
 
struct DroneDispatched
{
    static constexpr std::string_view EventName = "drone_dispatched";
    int Slot = -1;
    int Priority = 0;
    // skipped: drone_dispatched: its name DroneDispatched is taken
    static DroneDispatched From(IGameEvent& e);
};
 
struct DronegunAttack
{
    static constexpr std::string_view EventName = "dronegun_attack";
    int Slot = -1;
    static DronegunAttack From(IGameEvent& e);
};
 
struct DropRateModified
{
    static constexpr std::string_view EventName = "drop_rate_modified";
    static DropRateModified From(IGameEvent& e);
};
 
struct DynamicShadowLightChanged
{
    static constexpr std::string_view EventName = "dynamic_shadow_light_changed";
    static DynamicShadowLightChanged From(IGameEvent& e);
};
 
struct DzItemInteraction
{
    static constexpr std::string_view EventName = "dz_item_interaction";
    int Slot = -1;     ///< player entindex
    int Subject = 0;   ///< crate entindex
    std::string Type;  ///< type of crate (metal, wood, or paradrop)
    static DzItemInteraction From(IGameEvent& e);
};
 
struct EnableRestartVoting
{
    static constexpr std::string_view EventName = "enable_restart_voting";
    bool Enable = false;
    static EnableRestartVoting From(IGameEvent& e);
};
 
struct EndmatchCmmStartRevealItems
{
    static constexpr std::string_view EventName = "endmatch_cmm_start_reveal_items";
    static EndmatchCmmStartRevealItems From(IGameEvent& e);
};
 
struct EndmatchMapvoteSelectingMap
{
    static constexpr std::string_view EventName = "endmatch_mapvote_selecting_map";
    int Count = 0;  ///< Number of "ties"
    int Slot1 = 0;
    int Slot2 = 0;
    int Slot3 = 0;
    int Slot4 = 0;
    int Slot5 = 0;
    int Slot6 = 0;
    int Slot7 = 0;
    int Slot8 = 0;
    int Slot9 = 0;
    int Slot10 = 0;
    static EndmatchMapvoteSelectingMap From(IGameEvent& e);
};
 
struct EnterBombzone
{
    static constexpr std::string_view EventName = "enter_bombzone";
    int Slot = -1;
    bool Hasbomb = false;
    bool Isplanted = false;
    static EnterBombzone From(IGameEvent& e);
};
 
struct EnterBuyzone
{
    static constexpr std::string_view EventName = "enter_buyzone";
    int Slot = -1;
    bool Canbuy = false;
    static EnterBuyzone From(IGameEvent& e);
};
 
struct EnterRescueZone
{
    static constexpr std::string_view EventName = "enter_rescue_zone";
    int Slot = -1;
    static EnterRescueZone From(IGameEvent& e);
};
 
struct EntityKilled
{
    static constexpr std::string_view EventName = "entity_killed";
    int EntindexKilled = 0;
    int EntindexAttacker = 0;
    int EntindexInflictor = 0;
    int Damagebits = 0;
    static EntityKilled From(IGameEvent& e);
};
 
struct EntityVisible
{
    static constexpr std::string_view EventName = "entity_visible";
    int Slot = -1;           ///< The player who sees the entity
    int Subject = 0;         ///< Entindex of the entity they see
    std::string Classname;   ///< Classname of the entity they see
    std::string Entityname;  ///< name of the entity they see
    static EntityVisible From(IGameEvent& e);
};
 
struct EventTicketModified
{
    static constexpr std::string_view EventName = "event_ticket_modified";
    static EventTicketModified From(IGameEvent& e);
};
 
struct ExitBombzone
{
    static constexpr std::string_view EventName = "exit_bombzone";
    int Slot = -1;
    bool Hasbomb = false;
    bool Isplanted = false;
    static ExitBombzone From(IGameEvent& e);
};
 
struct ExitBuyzone
{
    static constexpr std::string_view EventName = "exit_buyzone";
    int Slot = -1;
    bool Canbuy = false;
    static ExitBuyzone From(IGameEvent& e);
};
 
struct ExitRescueZone
{
    static constexpr std::string_view EventName = "exit_rescue_zone";
    int Slot = -1;
    static ExitRescueZone From(IGameEvent& e);
};
 
struct FinaleStart
{
    static constexpr std::string_view EventName = "finale_start";
    int Rushes = 0;
    static FinaleStart From(IGameEvent& e);
};
 
struct FirstbombsIncomingWarning
{
    static constexpr std::string_view EventName = "firstbombs_incoming_warning";
    bool Global = false;
    static FirstbombsIncomingWarning From(IGameEvent& e);
};
 
struct FlareIgniteNpc
{
    static constexpr std::string_view EventName = "flare_ignite_npc";
    int Entindex = 0;  ///< entity ignited
    static FlareIgniteNpc From(IGameEvent& e);
};
 
struct FlashbangDetonate
{
    static constexpr std::string_view EventName = "flashbang_detonate";
    int Slot = -1;
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static FlashbangDetonate From(IGameEvent& e);
};
 
/** a game ended */
struct GameEnd
{
    static constexpr std::string_view EventName = "game_end";
    int Winner = 0;  ///< winner team/user id
    static GameEnd From(IGameEvent& e);
};
 
/** sent when a new game is started */
struct GameInit
{
    static constexpr std::string_view EventName = "game_init";
    static GameInit From(IGameEvent& e);
};
 
/** a message send by game logic to everyone */
struct GameMessage
{
    static constexpr std::string_view EventName = "game_message";
    int Target = 0;    ///< 0 = console, 1 = HUD
    std::string Text;  ///< the message text
    static GameMessage From(IGameEvent& e);
};
 
/** send when new map is completely loaded */
struct GameNewmap
{
    static constexpr std::string_view EventName = "game_newmap";
    std::string Mapname;  ///< map name
    static GameNewmap From(IGameEvent& e);
};
 
struct GamePhaseChanged
{
    static constexpr std::string_view EventName = "game_phase_changed";
    int NewPhase = 0;
    static GamePhaseChanged From(IGameEvent& e);
};
 
/** a new game starts */
struct GameStart
{
    static constexpr std::string_view EventName = "game_start";
    int Roundslimit = 0;    ///< max round
    int Timelimit = 0;      ///< time limit
    int Fraglimit = 0;      ///< frag limit
    std::string Objective;  ///< round objective
    static GameStart From(IGameEvent& e);
};
 
struct GameinstructorDraw
{
    static constexpr std::string_view EventName = "gameinstructor_draw";
    static GameinstructorDraw From(IGameEvent& e);
};
 
struct GameinstructorNodraw
{
    static constexpr std::string_view EventName = "gameinstructor_nodraw";
    static GameinstructorNodraw From(IGameEvent& e);
};
 
struct GameuiHidden
{
    static constexpr std::string_view EventName = "gameui_hidden";
    static GameuiHidden From(IGameEvent& e);
};
 
struct GcConnected
{
    static constexpr std::string_view EventName = "gc_connected";
    static GcConnected From(IGameEvent& e);
};
 
struct GgKilledEnemy
{
    static constexpr std::string_view EventName = "gg_killed_enemy";
    int VictimidSlot = -1;    ///< user ID who died
    int AttackeridSlot = -1;  ///< user ID who killed
    int Dominated = 0;        ///< did killer dominate victim with this kill
    int Revenge = 0;          ///< did killer get revenge on victim with this kill
    bool Bonus = false;       ///< did killer kill with a bonus weapon?
    static GgKilledEnemy From(IGameEvent& e);
};
 
struct GrenadeBounce
{
    static constexpr std::string_view EventName = "grenade_bounce";
    int Slot = -1;
    static GrenadeBounce From(IGameEvent& e);
};
 
struct GrenadeThrown
{
    static constexpr std::string_view EventName = "grenade_thrown";
    int Slot = -1;
    std::string Weapon;  ///< weapon name used
    static GrenadeThrown From(IGameEvent& e);
};
 
struct GuardianWaveRestart
{
    static constexpr std::string_view EventName = "guardian_wave_restart";
    static GuardianWaveRestart From(IGameEvent& e);
};
 
struct HegrenadeDetonate
{
    static constexpr std::string_view EventName = "hegrenade_detonate";
    int Slot = -1;
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static HegrenadeDetonate From(IGameEvent& e);
};
 
struct HelicopterGrenadePuntMiss
{
    static constexpr std::string_view EventName = "helicopter_grenade_punt_miss";
    static HelicopterGrenadePuntMiss From(IGameEvent& e);
};
 
struct HideDeathpanel
{
    static constexpr std::string_view EventName = "hide_deathpanel";
    static HideDeathpanel From(IGameEvent& e);
};
 
/** a spectator/player is a cameraman */
struct HltvCameraman
{
    static constexpr std::string_view EventName = "hltv_cameraman";
    int Slot = -1;  ///< camera man entity index
    static HltvCameraman From(IGameEvent& e);
};
 
struct HltvChangedMode
{
    static constexpr std::string_view EventName = "hltv_changed_mode";
    int Oldmode = 0;
    int Newmode = 0;
    int ObsTarget = 0;
    static HltvChangedMode From(IGameEvent& e);
};
 
/** shot of a single entity */
struct HltvChase
{
    static constexpr std::string_view EventName = "hltv_chase";
    int Target1Slot = -1;  ///< primary traget index
    int Target2Slot = -1;  ///< secondary traget index or 0
    int Distance = 0;      ///< camera distance
    int Theta = 0;         ///< view angle horizontal
    int Phi = 0;           ///< view angle vertical
    int Inertia = 0;       ///< camera inertia
    int Ineye = 0;         ///< diretcor suggests to show ineye
    static HltvChase From(IGameEvent& e);
};
 
/** a HLTV chat msg sent by spectators */
struct HltvChat
{
    static constexpr std::string_view EventName = "hltv_chat";
    std::string Text;
    uint64_t SteamID = 0;  ///< steam id
    static HltvChat From(IGameEvent& e);
};
 
/** show from fixed view */
struct HltvFixed
{
    static constexpr std::string_view EventName = "hltv_fixed";
    int Posx = 0;  ///< camera position in world
    int Posy = 0;
    int Posz = 0;
    int Theta = 0;  ///< camera angles
    int Phi = 0;
    int Offset = 0;
    float Fov = 0.0f;
    int TargetSlot = -1;  ///< follow this player
    static HltvFixed From(IGameEvent& e);
};
 
/** a HLTV message send by moderators */
struct HltvMessage
{
    static constexpr std::string_view EventName = "hltv_message";
    std::string Text;
    static HltvMessage From(IGameEvent& e);
};
 
/** a camera ranking */
struct HltvRankCamera
{
    static constexpr std::string_view EventName = "hltv_rank_camera";
    int Index = 0;        ///< fixed camera index
    float Rank = 0.0f;    ///< ranking, how interesting is this camera view
    int TargetSlot = -1;  ///< best/closest target entity
    static HltvRankCamera From(IGameEvent& e);
};
 
/** an entity ranking */
struct HltvRankEntity
{
    static constexpr std::string_view EventName = "hltv_rank_entity";
    int Slot = -1;        ///< player slot
    float Rank = 0.0f;    ///< ranking, how interesting is this entity to view
    int TargetSlot = -1;  ///< best/closest target entity
    static HltvRankEntity From(IGameEvent& e);
};
 
struct HltvReplay
{
    static constexpr std::string_view EventName = "hltv_replay";
    int Delay = 0;   ///< number of seconds in killer replay delay
    int Reason = 0;  ///< reason for replay (ReplayEventType_t)
    static HltvReplay From(IGameEvent& e);
};
 
struct HltvReplayStatus
{
    static constexpr std::string_view EventName = "hltv_replay_status";
    int Reason = 0;  ///< reason for hltv replay status change ()
    static HltvReplayStatus From(IGameEvent& e);
};
 
/** general HLTV status */
struct HltvStatus
{
    static constexpr std::string_view EventName = "hltv_status";
    int Clients = 0;     ///< number of HLTV spectators
    int Slots = 0;       ///< number of HLTV slots
    int Proxies = 0;     ///< number of HLTV proxies
    std::string Master;  ///< disptach master IP:port
    static HltvStatus From(IGameEvent& e);
};
 
struct HltvTitle
{
    static constexpr std::string_view EventName = "hltv_title";
    std::string Text;
    static HltvTitle From(IGameEvent& e);
};
 
struct HltvVersioninfo
{
    static constexpr std::string_view EventName = "hltv_versioninfo";
    int Version = 0;
    static HltvVersioninfo From(IGameEvent& e);
};
 
struct HostageCallForHelp
{
    static constexpr std::string_view EventName = "hostage_call_for_help";
    int Hostage = 0;  ///< hostage entity index
    static HostageCallForHelp From(IGameEvent& e);
};
 
struct HostageFollows
{
    static constexpr std::string_view EventName = "hostage_follows";
    int Slot = -1;    ///< player who touched the hostage
    int Hostage = 0;  ///< hostage entity index
    static HostageFollows From(IGameEvent& e);
};
 
struct HostageHurt
{
    static constexpr std::string_view EventName = "hostage_hurt";
    int Slot = -1;    ///< player who hurt the hostage
    int Hostage = 0;  ///< hostage entity index
    static HostageHurt From(IGameEvent& e);
};
 
struct HostageKilled
{
    static constexpr std::string_view EventName = "hostage_killed";
    int Slot = -1;    ///< player who killed the hostage
    int Hostage = 0;  ///< hostage entity index
    static HostageKilled From(IGameEvent& e);
};
 
struct HostageRescued
{
    static constexpr std::string_view EventName = "hostage_rescued";
    int Slot = -1;    ///< player who rescued the hostage
    int Hostage = 0;  ///< hostage entity index
    int Site = 0;     ///< rescue site index
    static HostageRescued From(IGameEvent& e);
};
 
struct HostageRescuedAll
{
    static constexpr std::string_view EventName = "hostage_rescued_all";
    static HostageRescuedAll From(IGameEvent& e);
};
 
struct HostageStopsFollowing
{
    static constexpr std::string_view EventName = "hostage_stops_following";
    int Slot = -1;    ///< player who rescued the hostage
    int Hostage = 0;  ///< hostage entity index
    static HostageStopsFollowing From(IGameEvent& e);
};
 
struct HostnameChanged
{
    static constexpr std::string_view EventName = "hostname_changed";
    std::string Hostname;
    static HostnameChanged From(IGameEvent& e);
};
 
struct InfernoExpire
{
    static constexpr std::string_view EventName = "inferno_expire";
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static InfernoExpire From(IGameEvent& e);
};
 
struct InfernoExtinguish
{
    static constexpr std::string_view EventName = "inferno_extinguish";
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static InfernoExtinguish From(IGameEvent& e);
};
 
struct InfernoStartburn
{
    static constexpr std::string_view EventName = "inferno_startburn";
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static InfernoStartburn From(IGameEvent& e);
};
 
struct InspectWeapon
{
    static constexpr std::string_view EventName = "inspect_weapon";
    int Slot = -1;
    static InspectWeapon From(IGameEvent& e);
};
 
struct InstructorCloseLesson
{
    static constexpr std::string_view EventName = "instructor_close_lesson";
    int Slot = -1;         ///< The player who this lesson is intended for
    std::string HintName;  ///< Name of the lesson to start.  Must match instructor_lesson.txt
    static InstructorCloseLesson From(IGameEvent& e);
};
 
/** create a hint using data supplied entirely by the server/map. Intended for hints to smooth playtests before content
 * is ready to make the hint unneccessary. NOT INTENDED AS A SHIPPABLE CRUTCH */
struct InstructorServerHintCreate
{
    static constexpr std::string_view EventName = "instructor_server_hint_create";
    int Slot = -1;         ///< user ID of the player that triggered the hint
    std::string HintName;  ///< what to name the hint. For referencing it again later (e.g. a kill command for the hint
                           ///< instead of a timeout)
    std::string HintReplaceKey;          ///< type name so that messages of the same type will replace each other
    int HintTarget = 0;                  ///< entity id that the hint should display at
    int HintActivatorUseridSlot = -1;    ///< userid id of the activator
    int HintTimeout = 0;                 ///< how long in seconds until the hint automatically times out, 0 = never
    std::string HintIconOnscreen;        ///< the hint icon to use when the hint is onscreen. e.g. "icon_alert_red"
    std::string HintIconOffscreen;       ///< the hint icon to use when the hint is offscreen. e.g. "icon_alert"
    std::string HintCaption;             ///< the hint caption. e.g. "#ThisIsDangerous"
    std::string HintActivatorCaption;    ///< the hint caption that only the activator sees e.g. "#YouPushedItGood"
    std::string HintColor;               ///< the hint color in "r,g,b" format where each component is 0-255
    float HintIconOffset = 0.0f;         ///< how far on the z axis to offset the hint from entity origin
    float HintRange = 0.0f;              ///< range before the hint is culled
    int HintFlags = 0;                   ///< hint flags
    std::string HintBinding;             ///< bindings to use when use_binding is the onscreen icon
    std::string HintGamepadBinding;      ///< gamepad bindings to use when use_binding is the onscreen icon
    bool HintAllowNodrawTarget = false;  ///< if false, the hint will dissappear if the target entity is invisible
    bool HintNooffscreen = false;        ///< if true, the hint will not show when outside the player view
    bool HintForcecaption = false;       ///< if true, the hint caption will show even if the hint is occluded
    bool HintLocalPlayerOnly = false;    ///< if true, only the local player will see the hint
    static InstructorServerHintCreate From(IGameEvent& e);
};
 
/** destroys a server/map created hint */
struct InstructorServerHintStop
{
    static constexpr std::string_view EventName = "instructor_server_hint_stop";
    std::string HintName;  ///< The hint to stop. Will stop ALL hints with this name
    static InstructorServerHintStop From(IGameEvent& e);
};
 
struct InstructorStartLesson
{
    static constexpr std::string_view EventName = "instructor_start_lesson";
    int Slot = -1;         ///< The player who this lesson is intended for
    std::string HintName;  ///< Name of the lesson to start.  Must match instructor_lesson.txt
    int HintTarget = 0;    ///< entity id that the hint should display at. Leave empty if controller target
    int VrMovementType = 0;
    bool VrSingleController = false;
    int VrControllerType = 0;
    static InstructorStartLesson From(IGameEvent& e);
};
 
struct InventoryUpdated
{
    static constexpr std::string_view EventName = "inventory_updated";
    static InventoryUpdated From(IGameEvent& e);
};
 
struct ItemEquip
{
    static constexpr std::string_view EventName = "item_equip";
    int Slot = -1;
    std::string Item;  ///< either a weapon such as 'tmp' or 'hegrenade', or an item such as 'nvgs'
    int Defindex = 0;
    bool Canzoom = false;
    bool Hassilencer = false;
    bool Issilenced = false;
    bool Hastracers = false;
    int Weptype = 0;
    bool Ispainted = false;
    static ItemEquip From(IGameEvent& e);
};
 
struct ItemPickup
{
    static constexpr std::string_view EventName = "item_pickup";
    int Slot = -1;
    std::string Item;  ///< either a weapon such as 'tmp' or 'hegrenade', or an item such as 'nvgs'
    bool Silent = false;
    int Defindex = 0;
    static ItemPickup From(IGameEvent& e);
};
 
struct ItemPickupFailed
{
    static constexpr std::string_view EventName = "item_pickup_failed";
    int Slot = -1;
    std::string Item;
    int Reason = 0;
    int Limit = 0;
    static ItemPickupFailed From(IGameEvent& e);
};
 
struct ItemPickupSlerp
{
    static constexpr std::string_view EventName = "item_pickup_slerp";
    int Slot = -1;
    int Index = 0;
    int Behavior = 0;
    static ItemPickupSlerp From(IGameEvent& e);
};
 
struct ItemPurchase
{
    static constexpr std::string_view EventName = "item_purchase";
    int Slot = -1;
    VoltMod::Team Team = VoltMod::Team::None;
    int Loadout = 0;
    std::string Weapon;
    static ItemPurchase From(IGameEvent& e);
};
 
struct ItemRemove
{
    static constexpr std::string_view EventName = "item_remove";
    int Slot = -1;
    std::string Item;  ///< either a weapon such as 'tmp' or 'hegrenade', or an item such as 'nvgs'
    int Defindex = 0;
    static ItemRemove From(IGameEvent& e);
};
 
struct ItemSchemaInitialized
{
    static constexpr std::string_view EventName = "item_schema_initialized";
    static ItemSchemaInitialized From(IGameEvent& e);
};
 
struct JointeamFailed
{
    static constexpr std::string_view EventName = "jointeam_failed";
    int Slot = -1;
    int Reason = 0;  ///< 0 = team_full
    static JointeamFailed From(IGameEvent& e);
};
 
struct LocalPlayerControllerTeam
{
    static constexpr std::string_view EventName = "local_player_controller_team";
    static LocalPlayerControllerTeam From(IGameEvent& e);
};
 
struct LocalPlayerPawnChanged
{
    static constexpr std::string_view EventName = "local_player_pawn_changed";
    static LocalPlayerPawnChanged From(IGameEvent& e);
};
 
struct LocalPlayerTeam
{
    static constexpr std::string_view EventName = "local_player_team";
    static LocalPlayerTeam From(IGameEvent& e);
};
 
struct LootCrateOpened
{
    static constexpr std::string_view EventName = "loot_crate_opened";
    int Slot = -1;     ///< player entindex
    std::string Type;  ///< type of crate (metal, wood, or paradrop)
    static LootCrateOpened From(IGameEvent& e);
};
 
struct LootCrateVisible
{
    static constexpr std::string_view EventName = "loot_crate_visible";
    int Slot = -1;     ///< player entindex
    int Subject = 0;   ///< crate entindex
    std::string Type;  ///< type of crate (metal, wood, or paradrop)
    static LootCrateVisible From(IGameEvent& e);
};
 
struct MapShutdown
{
    static constexpr std::string_view EventName = "map_shutdown";
    static MapShutdown From(IGameEvent& e);
};
 
struct MapTransition
{
    static constexpr std::string_view EventName = "map_transition";
    static MapTransition From(IGameEvent& e);
};
 
struct MatchEndConditions
{
    static constexpr std::string_view EventName = "match_end_conditions";
    int Frags = 0;
    int MaxRounds = 0;
    int WinRounds = 0;
    int Time = 0;
    static MatchEndConditions From(IGameEvent& e);
};
 
struct MaterialDefaultComplete
{
    static constexpr std::string_view EventName = "material_default_complete";
    static MaterialDefaultComplete From(IGameEvent& e);
};
 
struct MbInputLockCancel
{
    static constexpr std::string_view EventName = "mb_input_lock_cancel";
    static MbInputLockCancel From(IGameEvent& e);
};
 
struct MbInputLockSuccess
{
    static constexpr std::string_view EventName = "mb_input_lock_success";
    static MbInputLockSuccess From(IGameEvent& e);
};
 
struct MolotovDetonate
{
    static constexpr std::string_view EventName = "molotov_detonate";
    int Slot = -1;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static MolotovDetonate From(IGameEvent& e);
};
 
struct NavBlocked
{
    static constexpr std::string_view EventName = "nav_blocked";
    int Area = 0;
    bool Blocked = false;
    static NavBlocked From(IGameEvent& e);
};
 
struct NavGenerate
{
    static constexpr std::string_view EventName = "nav_generate";
    static NavGenerate From(IGameEvent& e);
};
 
/** a game event, name may be 32 characters long */
struct NextlevelChanged
{
    static constexpr std::string_view EventName = "nextlevel_changed";
    std::string Nextlevel;
    std::string Mapgroup;
    std::string Skirmishmode;
    static NextlevelChanged From(IGameEvent& e);
};
 
struct OpenCrateInstr
{
    static constexpr std::string_view EventName = "open_crate_instr";
    int Slot = -1;     ///< player entindex
    int Subject = 0;   ///< crate entindex
    std::string Type;  ///< type of crate (metal, wood, or paradrop)
    static OpenCrateInstr From(IGameEvent& e);
};
 
struct OtherDeath
{
    static constexpr std::string_view EventName = "other_death";
    int Otherid = 0;               ///< other entity ID who died
    std::string Othertype;         ///< other entity type
    int Attacker = 0;              ///< user ID who killed
    std::string Weapon;            ///< weapon name killer used
    std::string WeaponItemid;      ///< inventory item id of weapon killer used
    std::string WeaponFauxitemid;  ///< faux item id of weapon killer used
    std::string WeaponOriginalownerXuid;
    bool Headshot = false;       ///< singals a headshot
    int Penetrated = 0;          ///< number of objects shot penetrated before killing target
    bool Noscope = false;        ///< kill happened without a scope, used for death notice icon
    bool Thrusmoke = false;      ///< hitscan weapon went through smoke grenade
    bool Attackerblind = false;  ///< attacker was blind from flashbang
    static OtherDeath From(IGameEvent& e);
};
 
struct ParachuteDeploy
{
    static constexpr std::string_view EventName = "parachute_deploy";
    int Slot = -1;
    static ParachuteDeploy From(IGameEvent& e);
};
 
struct ParachutePickup
{
    static constexpr std::string_view EventName = "parachute_pickup";
    int Slot = -1;
    static ParachutePickup From(IGameEvent& e);
};
 
struct PhysgunPickup
{
    static constexpr std::string_view EventName = "physgun_pickup";
    // skipped: target: ehandle
    static PhysgunPickup From(IGameEvent& e);
};
 
struct PlayerActivate
{
    static constexpr std::string_view EventName = "player_activate";
    int Slot = -1;  ///< user ID on server
    static PlayerActivate From(IGameEvent& e);
};
 
struct PlayerAvengedTeammate
{
    static constexpr std::string_view EventName = "player_avenged_teammate";
    int AvengerIdSlot = -1;
    int AvengedPlayerIdSlot = -1;
    static PlayerAvengedTeammate From(IGameEvent& e);
};
 
struct PlayerBlind
{
    static constexpr std::string_view EventName = "player_blind";
    int Slot = -1;
    int AttackerSlot = -1;  ///< user ID who threw the flash
    int Entityid = 0;       ///< the flashbang going off
    float BlindDuration = 0.0f;
    static PlayerBlind From(IGameEvent& e);
};
 
struct PlayerChangename
{
    static constexpr std::string_view EventName = "player_changename";
    int Slot = -1;        ///< user ID on server
    std::string Oldname;  ///< players old (current) name
    std::string Newname;  ///< players new name
    static PlayerChangename From(IGameEvent& e);
};
 
/** a public player chat */
struct PlayerChat
{
    static constexpr std::string_view EventName = "player_chat";
    bool Teamonly = false;  ///< true if team only chat
    int Userid = 0;         ///< chatting player
    std::string Text;       ///< chat text
    static PlayerChat From(IGameEvent& e);
};
 
/** a new client connected */
struct PlayerConnect
{
    static constexpr std::string_view EventName = "player_connect";
    std::string Name;       ///< player name
    int Slot = -1;          ///< user ID on server (unique on server)
    std::string Networkid;  ///< player network (i.e steam) id
    uint64_t Xuid = 0;      ///< steam id
    bool Bot = false;
    static PlayerConnect From(IGameEvent& e);
};
 
/** player has sent final message in the connection sequence */
struct PlayerConnectFull
{
    static constexpr std::string_view EventName = "player_connect_full";
    int Slot = -1;  ///< user ID on server (unique on server)
    static PlayerConnectFull From(IGameEvent& e);
};
 
/** a game event, name may be 32 characters long */
struct PlayerDeath
{
    static constexpr std::string_view EventName = "player_death";
    int Slot = -1;                 ///< user who died
    int AttackerSlot = -1;         ///< player who killed
    int AssisterSlot = -1;         ///< player who assisted in the kill
    bool Assistedflash = false;    ///< assister helped with a flash
    std::string Weapon;            ///< weapon name killer used
    std::string WeaponItemid;      ///< inventory item id of weapon killer used
    std::string WeaponFauxitemid;  ///< faux item id of weapon killer used
    std::string WeaponOriginalownerXuid;
    bool Headshot = false;       ///< singals a headshot
    int Dominated = 0;           ///< did killer dominate victim with this kill
    int Revenge = 0;             ///< did killer get revenge on victim with this kill
    int Wipe = 0;                ///< is the kill resulting in squad wipe
    int Penetrated = 0;          ///< number of objects shot penetrated before killing target
    bool Noreplay = false;       ///< if replay data is unavailable, this will be present and set to false
    bool Noscope = false;        ///< kill happened without a scope, used for death notice icon
    bool Thrusmoke = false;      ///< hitscan weapon went through smoke grenade
    bool Attackerblind = false;  ///< attacker was blind from flashbang
    float Distance = 0.0f;       ///< distance to victim in meters
    int DmgHealth = 0;           ///< damage done to health
    int DmgArmor = 0;            ///< damage done to armor
    VoltMod::HitGroup Hitgroup = VoltMod::HitGroup::Generic;  ///< hitgroup that was damaged
    bool Attackerinair = false;                               ///< attacker was in midair
    static PlayerDeath From(IGameEvent& e);
};
 
struct PlayerDecal
{
    static constexpr std::string_view EventName = "player_decal";
    // skipped: userid: player_pawn
    static PlayerDecal From(IGameEvent& e);
};
 
/** a client was disconnected */
struct PlayerDisconnect
{
    static constexpr std::string_view EventName = "player_disconnect";
    int Slot = -1;          ///< user ID on server
    int Reason = 0;         ///< see networkdisconnect enum protobuf
    std::string Name;       ///< player name
    std::string Networkid;  ///< player network (i.e steam) id
    uint64_t Xuid = 0;      ///< steam id
    int PlayerID = 0;
    bool EverFullyConnected = false;  ///< Was the player ever fully connected?
    static PlayerDisconnect From(IGameEvent& e);
};
 
struct PlayerFalldamage
{
    static constexpr std::string_view EventName = "player_falldamage";
    int Slot = -1;
    float Damage = 0.0f;
    static PlayerFalldamage From(IGameEvent& e);
};
 
struct PlayerFootstep
{
    static constexpr std::string_view EventName = "player_footstep";
    int Slot = -1;
    static PlayerFootstep From(IGameEvent& e);
};
 
struct PlayerFullUpdate
{
    static constexpr std::string_view EventName = "player_full_update";
    int Slot = -1;  ///< user ID on server
    int Count = 0;  ///< Number of this full update
    static PlayerFullUpdate From(IGameEvent& e);
};
 
struct PlayerGivenC4
{
    static constexpr std::string_view EventName = "player_given_c4";
    int Slot = -1;  ///< user ID who received the c4
    static PlayerGivenC4 From(IGameEvent& e);
};
 
struct PlayerHintmessage
{
    static constexpr std::string_view EventName = "player_hintmessage";
    std::string Hintmessage;  ///< localizable string of a hint
    static PlayerHintmessage From(IGameEvent& e);
};
 
struct PlayerHurt
{
    static constexpr std::string_view EventName = "player_hurt";
    int Slot = -1;                                            ///< player index who was hurt
    int AttackerSlot = -1;                                    ///< player index who attacked
    int Health = 0;                                           ///< remaining health points
    int Armor = 0;                                            ///< remaining armor points
    std::string Weapon;                                       ///< weapon name attacker used, if not the world
    int DmgHealth = 0;                                        ///< damage done to health
    int DmgArmor = 0;                                         ///< damage done to armor
    VoltMod::HitGroup Hitgroup = VoltMod::HitGroup::Generic;  ///< hitgroup that was damaged
    static PlayerHurt From(IGameEvent& e);
};
 
/** a player changed his name */
struct PlayerInfo
{
    static constexpr std::string_view EventName = "player_info";
    std::string Name;      ///< player name
    int Slot = -1;         ///< user ID on server (unique on server)
    uint64_t Steamid = 0;  ///< player network (i.e steam) id
    bool Bot = false;      ///< true if player is a AI bot
    static PlayerInfo From(IGameEvent& e);
};
 
struct PlayerJump
{
    static constexpr std::string_view EventName = "player_jump";
    int Slot = -1;
    static PlayerJump From(IGameEvent& e);
};
 
struct PlayerPing
{
    static constexpr std::string_view EventName = "player_ping";
    int Slot = -1;
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    bool Urgent = false;
    static PlayerPing From(IGameEvent& e);
};
 
struct PlayerPingStop
{
    static constexpr std::string_view EventName = "player_ping_stop";
    int Entityid = 0;
    static PlayerPingStop From(IGameEvent& e);
};
 
struct PlayerRadio
{
    static constexpr std::string_view EventName = "player_radio";
    int Slot = -1;
    // skipped: slot: its name Slot is taken
    static PlayerRadio From(IGameEvent& e);
};
 
struct PlayerResetVote
{
    static constexpr std::string_view EventName = "player_reset_vote";
    int Slot = -1;
    bool Vote = false;
    static PlayerResetVote From(IGameEvent& e);
};
 
/** players scores changed */
struct PlayerScore
{
    static constexpr std::string_view EventName = "player_score";
    int Slot = -1;   ///< user ID on server
    int Kills = 0;   ///< # of kills
    int Deaths = 0;  ///< # of deaths
    int Score = 0;   ///< total game score
    static PlayerScore From(IGameEvent& e);
};
 
/** player shoot his weapon */
struct PlayerShoot
{
    static constexpr std::string_view EventName = "player_shoot";
    int Slot = -1;   ///< user ID on server
    int Weapon = 0;  ///< weapon ID
    int Mode = 0;    ///< weapon mode
    static PlayerShoot From(IGameEvent& e);
};
 
struct PlayerSound
{
    static constexpr std::string_view EventName = "player_sound";
    int Slot = -1;
    int Radius = 0;
    float Duration = 0.0f;
    bool Step = false;
    static PlayerSound From(IGameEvent& e);
};
 
/** player spawned in game */
struct PlayerSpawn
{
    static constexpr std::string_view EventName = "player_spawn";
    int Slot = -1;
    static PlayerSpawn From(IGameEvent& e);
};
 
struct PlayerSpawned
{
    static constexpr std::string_view EventName = "player_spawned";
    int Slot = -1;
    bool Inrestart = false;  ///< true if restart is pending
    static PlayerSpawned From(IGameEvent& e);
};
 
struct PlayerStatsUpdated
{
    static constexpr std::string_view EventName = "player_stats_updated";
    bool Forceupload = false;
    static PlayerStatsUpdated From(IGameEvent& e);
};
 
/** player change his team */
struct PlayerTeam
{
    static constexpr std::string_view EventName = "player_team";
    int Slot = -1;                                ///< player
    VoltMod::Team Team = VoltMod::Team::None;     ///< team id
    VoltMod::Team Oldteam = VoltMod::Team::None;  ///< old team id
    bool Disconnect = false;                      ///< team change because player disconnects
    bool Silent = false;
    bool Isbot = false;  ///< true if player is a bot
    static PlayerTeam From(IGameEvent& e);
};
 
struct RagdollDissolved
{
    static constexpr std::string_view EventName = "ragdoll_dissolved";
    int Entindex = 0;
    static RagdollDissolved From(IGameEvent& e);
};
 
/** read user titledata from profile */
struct ReadGameTitledata
{
    static constexpr std::string_view EventName = "read_game_titledata";
    int ControllerId = 0;  ///< Controller id of user
    static ReadGameTitledata From(IGameEvent& e);
};
 
struct RepostXboxAchievements
{
    static constexpr std::string_view EventName = "repost_xbox_achievements";
    int Splitscreenplayer = 0;  ///< splitscreen ID
    static RepostXboxAchievements From(IGameEvent& e);
};
 
/** reset user titledata; do not automatically write profile */
struct ResetGameTitledata
{
    static constexpr std::string_view EventName = "reset_game_titledata";
    int ControllerId = 0;  ///< Controller id of user
    static ResetGameTitledata From(IGameEvent& e);
};
 
struct RoundAnnounceFinal
{
    static constexpr std::string_view EventName = "round_announce_final";
    static RoundAnnounceFinal From(IGameEvent& e);
};
 
struct RoundAnnounceLastRoundHalf
{
    static constexpr std::string_view EventName = "round_announce_last_round_half";
    static RoundAnnounceLastRoundHalf From(IGameEvent& e);
};
 
struct RoundAnnounceMatchPoint
{
    static constexpr std::string_view EventName = "round_announce_match_point";
    static RoundAnnounceMatchPoint From(IGameEvent& e);
};
 
struct RoundAnnounceMatchStart
{
    static constexpr std::string_view EventName = "round_announce_match_start";
    static RoundAnnounceMatchStart From(IGameEvent& e);
};
 
struct RoundAnnounceWarmup
{
    static constexpr std::string_view EventName = "round_announce_warmup";
    static RoundAnnounceWarmup From(IGameEvent& e);
};
 
struct RoundEnd
{
    static constexpr std::string_view EventName = "round_end";
    int Winner = 0;       ///< winner team/user i
    int Reason = 0;       ///< reson why team won
    std::string Message;  ///< end round message
    int Legacy = 0;       ///< server-generated legacy value
    int PlayerCount = 0;  ///< total number of players alive at the end of round, used for statistics gathering,
                          ///< computed on the server in the event client is in replay when receiving this message
    int Nomusic = 0;      ///< if set, don't play round end music, because action is still on-going
    static RoundEnd From(IGameEvent& e);
};
 
struct RoundEndUploadStats
{
    static constexpr std::string_view EventName = "round_end_upload_stats";
    static RoundEndUploadStats From(IGameEvent& e);
};
 
struct RoundFreezeEnd
{
    static constexpr std::string_view EventName = "round_freeze_end";
    static RoundFreezeEnd From(IGameEvent& e);
};
 
struct RoundMvp
{
    static constexpr std::string_view EventName = "round_mvp";
    int Slot = -1;
    int Reason = 0;
    int Value = 0;
    int Musickitmvps = 0;
    int Nomusic = 0;
    int Musickitid = 0;
    static RoundMvp From(IGameEvent& e);
};
 
struct RoundOfficiallyEnded
{
    static constexpr std::string_view EventName = "round_officially_ended";
    static RoundOfficiallyEnded From(IGameEvent& e);
};
 
/** sent after all other round restart actions */
struct RoundPoststart
{
    static constexpr std::string_view EventName = "round_poststart";
    static RoundPoststart From(IGameEvent& e);
};
 
/** sent before all other round restart actions */
struct RoundPrestart
{
    static constexpr std::string_view EventName = "round_prestart";
    static RoundPrestart From(IGameEvent& e);
};
 
struct RoundStart
{
    static constexpr std::string_view EventName = "round_start";
    int Timelimit = 0;      ///< round time limit in seconds
    int Fraglimit = 0;      ///< frag limit in seconds
    std::string Objective;  ///< round objective
    static RoundStart From(IGameEvent& e);
};
 
struct RoundStartPostNav
{
    static constexpr std::string_view EventName = "round_start_post_nav";
    static RoundStartPostNav From(IGameEvent& e);
};
 
struct RoundStartPreEntity
{
    static constexpr std::string_view EventName = "round_start_pre_entity";
    static RoundStartPreEntity From(IGameEvent& e);
};
 
struct RoundTimeWarning
{
    static constexpr std::string_view EventName = "round_time_warning";
    static RoundTimeWarning From(IGameEvent& e);
};
 
struct SeasoncoinLevelup
{
    static constexpr std::string_view EventName = "seasoncoin_levelup";
    int Slot = -1;
    int Category = 0;
    int Rank = 0;
    static SeasoncoinLevelup From(IGameEvent& e);
};
 
/** a server console var has changed */
struct ServerCvar
{
    static constexpr std::string_view EventName = "server_cvar";
    std::string Cvarname;   ///< cvar name, eg "mp_roundtime"
    std::string Cvarvalue;  ///< new cvar value
    static ServerCvar From(IGameEvent& e);
};
 
/** a generic server message */
struct ServerMessage
{
    static constexpr std::string_view EventName = "server_message";
    std::string Text;  ///< the message text
    static ServerMessage From(IGameEvent& e);
};
 
/** server is about to be shut down */
struct ServerPreShutdown
{
    static constexpr std::string_view EventName = "server_pre_shutdown";
    std::string Reason;  ///< reason why server is about to be shut down
    static ServerPreShutdown From(IGameEvent& e);
};
 
/** server shut down */
struct ServerShutdown
{
    static constexpr std::string_view EventName = "server_shutdown";
    std::string Reason;  ///< reason why server was shut down
    static ServerShutdown From(IGameEvent& e);
};
 
/** send once a server starts */
struct ServerSpawn
{
    static constexpr std::string_view EventName = "server_spawn";
    std::string Hostname;    ///< public host name
    std::string Address;     ///< hostame, IP or DNS name
    int Port = 0;            ///< server port
    std::string Game;        ///< game dir
    std::string Mapname;     ///< map name
    std::string Addonname;   ///< addon name
    int Maxplayers = 0;      ///< max players
    std::string Os;          ///< WIN32, LINUX
    bool Dedicated = false;  ///< true if dedicated server
    bool Password = false;   ///< true if password protected
    static ServerSpawn From(IGameEvent& e);
};
 
struct SetInstructorGroupEnabled
{
    static constexpr std::string_view EventName = "set_instructor_group_enabled";
    std::string Group;
    int Enabled = 0;
    static SetInstructorGroupEnabled From(IGameEvent& e);
};
 
struct Sfuievent
{
    static constexpr std::string_view EventName = "sfuievent";
    std::string Action;
    std::string Data;
    int Slot = 0;
    static Sfuievent From(IGameEvent& e);
};
 
struct ShowDeathpanel
{
    static constexpr std::string_view EventName = "show_deathpanel";
    int VictimSlot = -1;  ///< endindex of the one who was killed
    int KillerControllerSlot = -1;
    int HitsTaken = 0;
    int DamageTaken = 0;
    int HitsGiven = 0;
    int DamageGiven = 0;
    // skipped: killer: ehandle
    static ShowDeathpanel From(IGameEvent& e);
};
 
struct ShowSurvivalRespawnStatus
{
    static constexpr std::string_view EventName = "show_survival_respawn_status";
    std::string LocToken;
    int Duration = 0;
    int Slot = -1;
    static ShowSurvivalRespawnStatus From(IGameEvent& e);
};
 
struct SilencerDetach
{
    static constexpr std::string_view EventName = "silencer_detach";
    int Slot = -1;
    static SilencerDetach From(IGameEvent& e);
};
 
struct SilencerOff
{
    static constexpr std::string_view EventName = "silencer_off";
    int Slot = -1;
    static SilencerOff From(IGameEvent& e);
};
 
struct SilencerOn
{
    static constexpr std::string_view EventName = "silencer_on";
    int Slot = -1;
    static SilencerOn From(IGameEvent& e);
};
 
struct SmokeBeaconParadrop
{
    static constexpr std::string_view EventName = "smoke_beacon_paradrop";
    int Slot = -1;
    int Paradrop = 0;
    static SmokeBeaconParadrop From(IGameEvent& e);
};
 
struct SmokegrenadeDetonate
{
    static constexpr std::string_view EventName = "smokegrenade_detonate";
    int Slot = -1;
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static SmokegrenadeDetonate From(IGameEvent& e);
};
 
struct SmokegrenadeExpired
{
    static constexpr std::string_view EventName = "smokegrenade_expired";
    int Slot = -1;
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static SmokegrenadeExpired From(IGameEvent& e);
};
 
struct SpecModeUpdated
{
    static constexpr std::string_view EventName = "spec_mode_updated";
    int Slot = -1;  ///< entindex of the player
    static SpecModeUpdated From(IGameEvent& e);
};
 
struct SpecTargetUpdated
{
    static constexpr std::string_view EventName = "spec_target_updated";
    int Slot = -1;  ///< spectating player
    // skipped: target: ehandle
    static SpecTargetUpdated From(IGameEvent& e);
};
 
struct StartHalftime
{
    static constexpr std::string_view EventName = "start_halftime";
    static StartHalftime From(IGameEvent& e);
};
 
struct StartVote
{
    static constexpr std::string_view EventName = "start_vote";
    int Slot = -1;
    int Type = 0;
    int VoteParameter = 0;
    static StartVote From(IGameEvent& e);
};
 
struct StorePricesheetUpdated
{
    static constexpr std::string_view EventName = "store_pricesheet_updated";
    static StorePricesheetUpdated From(IGameEvent& e);
};
 
struct SurvivalAnnouncePhase
{
    static constexpr std::string_view EventName = "survival_announce_phase";
    int Phase = 0;  ///< The phase #
    static SurvivalAnnouncePhase From(IGameEvent& e);
};
 
struct SurvivalNoRespawnsFinal
{
    static constexpr std::string_view EventName = "survival_no_respawns_final";
    int Slot = -1;
    static SurvivalNoRespawnsFinal From(IGameEvent& e);
};
 
struct SurvivalNoRespawnsWarning
{
    static constexpr std::string_view EventName = "survival_no_respawns_warning";
    int Slot = -1;
    static SurvivalNoRespawnsWarning From(IGameEvent& e);
};
 
struct SurvivalParadropBreak
{
    static constexpr std::string_view EventName = "survival_paradrop_break";
    int Entityid = 0;
    static SurvivalParadropBreak From(IGameEvent& e);
};
 
struct SurvivalParadropSpawn
{
    static constexpr std::string_view EventName = "survival_paradrop_spawn";
    int Entityid = 0;
    static SurvivalParadropSpawn From(IGameEvent& e);
};
 
struct SurvivalTeammateRespawn
{
    static constexpr std::string_view EventName = "survival_teammate_respawn";
    int Slot = -1;
    static SurvivalTeammateRespawn From(IGameEvent& e);
};
 
struct SwitchTeam
{
    static constexpr std::string_view EventName = "switch_team";
    int NumPlayers = 0;     ///< number of active players on both T and CT
    int NumSpectators = 0;  ///< number of spectators
    int AvgRank = 0;        ///< average rank of human players
    int NumTSlotsFree = 0;
    int NumCTSlotsFree = 0;
    static SwitchTeam From(IGameEvent& e);
};
 
struct TagrenadeDetonate
{
    static constexpr std::string_view EventName = "tagrenade_detonate";
    int Slot = -1;
    int Entityid = 0;
    float X = 0.0f;
    float Y = 0.0f;
    float Z = 0.0f;
    static TagrenadeDetonate From(IGameEvent& e);
};
 
/** info about team */
struct TeamInfo
{
    static constexpr std::string_view EventName = "team_info";
    int Teamid = 0;        ///< unique team id
    std::string Teamname;  ///< team name eg "Team Blue"
    static TeamInfo From(IGameEvent& e);
};
 
struct TeamIntroEnd
{
    static constexpr std::string_view EventName = "team_intro_end";
    static TeamIntroEnd From(IGameEvent& e);
};
 
struct TeamIntroStart
{
    static constexpr std::string_view EventName = "team_intro_start";
    static TeamIntroStart From(IGameEvent& e);
};
 
/** team score changed */
struct TeamScore
{
    static constexpr std::string_view EventName = "team_score";
    int Teamid = 0;  ///< team id
    int Score = 0;   ///< total team score
    static TeamScore From(IGameEvent& e);
};
 
struct TeamchangePending
{
    static constexpr std::string_view EventName = "teamchange_pending";
    int Slot = -1;
    int Toteam = 0;
    static TeamchangePending From(IGameEvent& e);
};
 
/** emits a sound to everyone on a team */
struct TeamplayBroadcastAudio
{
    static constexpr std::string_view EventName = "teamplay_broadcast_audio";
    VoltMod::Team Team = VoltMod::Team::None;  ///< unique team id
    std::string Sound;                         ///< name of the sound to emit
    static TeamplayBroadcastAudio From(IGameEvent& e);
};
 
/** round restart */
struct TeamplayRoundStart
{
    static constexpr std::string_view EventName = "teamplay_round_start";
    bool FullReset = false;  ///< is this a full reset of the map
    static TeamplayRoundStart From(IGameEvent& e);
};
 
struct TournamentReward
{
    static constexpr std::string_view EventName = "tournament_reward";
    int Defindex = 0;
    int Totalrewards = 0;
    int Accountid = 0;
    static TournamentReward From(IGameEvent& e);
};
 
struct TrialTimeExpired
{
    static constexpr std::string_view EventName = "trial_time_expired";
    int Slot = -1;  ///< player whose time has expired
    static TrialTimeExpired From(IGameEvent& e);
};
 
struct UgcFileDownloadFinished
{
    static constexpr std::string_view EventName = "ugc_file_download_finished";
    uint64_t Hcontent = 0;  ///< id of this specific content (may be image or map)
    static UgcFileDownloadFinished From(IGameEvent& e);
};
 
struct UgcFileDownloadStart
{
    static constexpr std::string_view EventName = "ugc_file_download_start";
    uint64_t Hcontent = 0;         ///< id of this specific content (may be image or map)
    uint64_t PublishedFileId = 0;  ///< id of the associated content package
    static UgcFileDownloadStart From(IGameEvent& e);
};
 
struct UgcMapDownloadError
{
    static constexpr std::string_view EventName = "ugc_map_download_error";
    uint64_t PublishedFileId = 0;
    int ErrorCode = 0;
    static UgcMapDownloadError From(IGameEvent& e);
};
 
struct UgcMapInfoReceived
{
    static constexpr std::string_view EventName = "ugc_map_info_received";
    uint64_t PublishedFileId = 0;
    static UgcMapInfoReceived From(IGameEvent& e);
};
 
struct UgcMapUnsubscribed
{
    static constexpr std::string_view EventName = "ugc_map_unsubscribed";
    uint64_t PublishedFileId = 0;
    static UgcMapUnsubscribed From(IGameEvent& e);
};
 
struct UpdateMatchmakingStats
{
    static constexpr std::string_view EventName = "update_matchmaking_stats";
    static UpdateMatchmakingStats From(IGameEvent& e);
};
 
/** fired when achievements/stats are downloaded from Steam or XBox Live */
struct UserDataDownloaded
{
    static constexpr std::string_view EventName = "user_data_downloaded";
    static UserDataDownloaded From(IGameEvent& e);
};
 
struct VipEscaped
{
    static constexpr std::string_view EventName = "vip_escaped";
    int Slot = -1;  ///< player who was the VIP
    static VipEscaped From(IGameEvent& e);
};
 
struct VipKilled
{
    static constexpr std::string_view EventName = "vip_killed";
    int Slot = -1;          ///< player who was the VIP
    int AttackerSlot = -1;  ///< user ID who killed the VIP
    static VipKilled From(IGameEvent& e);
};
 
struct VoteCast
{
    static constexpr std::string_view EventName = "vote_cast";
    int VoteOption = 0;  ///< which option the player voted on
    VoltMod::Team Team = VoltMod::Team::None;
    int Slot = -1;  ///< player who voted
    static VoteCast From(IGameEvent& e);
};
 
struct VoteCastNo
{
    static constexpr std::string_view EventName = "vote_cast_no";
    VoltMod::Team Team = VoltMod::Team::None;
    int Entityid = 0;  ///< entity id of the voter
    static VoteCastNo From(IGameEvent& e);
};
 
struct VoteCastYes
{
    static constexpr std::string_view EventName = "vote_cast_yes";
    VoltMod::Team Team = VoltMod::Team::None;
    int Entityid = 0;  ///< entity id of the voter
    static VoteCastYes From(IGameEvent& e);
};
 
struct VoteChanged
{
    static constexpr std::string_view EventName = "vote_changed";
    int VoteOption1 = 0;
    int VoteOption2 = 0;
    int VoteOption3 = 0;
    int VoteOption4 = 0;
    int VoteOption5 = 0;
    int PotentialVotes = 0;
    static VoteChanged From(IGameEvent& e);
};
 
struct VoteEnded
{
    static constexpr std::string_view EventName = "vote_ended";
    static VoteEnded From(IGameEvent& e);
};
 
struct VoteFailed
{
    static constexpr std::string_view EventName = "vote_failed";
    VoltMod::Team Team = VoltMod::Team::None;
    static VoteFailed From(IGameEvent& e);
};
 
struct VoteOptions
{
    static constexpr std::string_view EventName = "vote_options";
    int Count = 0;  ///< Number of options - up to MAX_VOTE_OPTIONS
    std::string Option1;
    std::string Option2;
    std::string Option3;
    std::string Option4;
    std::string Option5;
    static VoteOptions From(IGameEvent& e);
};
 
struct VotePassed
{
    static constexpr std::string_view EventName = "vote_passed";
    std::string Details;
    std::string Param1;
    VoltMod::Team Team = VoltMod::Team::None;
    static VotePassed From(IGameEvent& e);
};
 
struct VoteStarted
{
    static constexpr std::string_view EventName = "vote_started";
    std::string Issue;
    std::string Param1;
    VoltMod::Team Team = VoltMod::Team::None;
    int Initiator = 0;  ///< entity id of the player who initiated the vote
    static VoteStarted From(IGameEvent& e);
};
 
struct WarmupEnd
{
    static constexpr std::string_view EventName = "warmup_end";
    static WarmupEnd From(IGameEvent& e);
};
 
struct WeaponFire
{
    static constexpr std::string_view EventName = "weapon_fire";
    int Slot = -1;
    std::string Weapon;     ///< weapon name used
    bool Silenced = false;  ///< is weapon silenced
    static WeaponFire From(IGameEvent& e);
};
 
struct WeaponFireOnEmpty
{
    static constexpr std::string_view EventName = "weapon_fire_on_empty";
    int Slot = -1;
    std::string Weapon;  ///< weapon name used
    static WeaponFireOnEmpty From(IGameEvent& e);
};
 
struct WeaponReload
{
    static constexpr std::string_view EventName = "weapon_reload";
    int Slot = -1;
    static WeaponReload From(IGameEvent& e);
};
 
struct WeaponZoom
{
    static constexpr std::string_view EventName = "weapon_zoom";
    int Slot = -1;
    static WeaponZoom From(IGameEvent& e);
};
 
struct WeaponZoomRifle
{
    static constexpr std::string_view EventName = "weapon_zoom_rifle";
    int Slot = -1;
    static WeaponZoomRifle From(IGameEvent& e);
};
 
struct WeaponhudSelection
{
    static constexpr std::string_view EventName = "weaponhud_selection";
    int Slot = -1;     ///< Player who this event applies to
    int Mode = 0;      ///< EWeaponHudSelectionMode (switch / pickup / drop)
    int Entindex = 0;  ///< Weapon entity index
    static WeaponhudSelection From(IGameEvent& e);
};
 
/** write user titledata in profile */
struct WriteGameTitledata
{
    static constexpr std::string_view EventName = "write_game_titledata";
    int ControllerId = 0;  ///< Controller id of user
    static WriteGameTitledata From(IGameEvent& e);
};
 
struct WriteProfileData
{
    static constexpr std::string_view EventName = "write_profile_data";
    static WriteProfileData From(IGameEvent& e);
};
 
}  // namespace VoltMod