From 4c5294550f719b267f78ad1a54ebd83843473e7f Mon Sep 17 00:00:00 2001
From: Juice <5415811+etojuice@users.noreply.github.com>
Date: Mon, 9 Oct 2023 00:16:21 +0300
Subject: [PATCH] Update IGameEvent (#155)

Co-authored-by: GAMMACASE <31375974+GAMMACASE@users.noreply.github.com>
---
 public/igameevents.h  | 413 +++++++++++++++++++++++-------------------
 tier1/generichash.cpp |  52 +++++-
 2 files changed, 277 insertions(+), 188 deletions(-)

diff --git a/public/igameevents.h b/public/igameevents.h
index 08f4b957..d8b9f741 100644
--- a/public/igameevents.h
+++ b/public/igameevents.h
@@ -1,187 +1,226 @@
-//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
-//
-// Purpose: 
-//
-// $Workfile:     $
-// $Date:         $
-//
-//-----------------------------------------------------------------------------
-// $Log: $
-//
-// $NoKeywords: $
-//=============================================================================//
-#if !defined( IGAMEEVENTS_H )
-#define IGAMEEVENTS_H
-#ifdef _WIN32
-#pragma once
-#endif
-
-#include "interfaces/interfaces.h"
-#include "tier1/bitbuf.h"
-
-class CMsgSource1LegacyGameEvent;
-class CPlayerSlot;
-class CBasePlayer;
-class CEntityIndex;
-class CEntityHandle;
-class CBaseEntity;
-//-----------------------------------------------------------------------------
-// Purpose: Engine interface into global game event management
-//-----------------------------------------------------------------------------
-
-/* 
-
-The GameEventManager keeps track and fires of all global game events. Game events 
-are fired by game.dll for events like player death or team wins. Each event has a
-unique name and comes with a KeyValue structure providing informations about this
-event. Some events are generated also by the engine.
-
-Events are networked to connected clients and invoked there to. Therefore you
-have to specify all data fields and there data types in an public resource
-file which is parsed by server and broadcasted to it's clients. A typical game 
-event is defined like this:
-
-	"game_start"				// a new game starts
-	{
-		"roundslimit"	"long"		// max round
-		"timelimit"		"long"		// time limit
-		"fraglimit"		"long"		// frag limit
-		"objective"		"string"	// round objective
-	}
-
-All events must have unique names (case sensitive) and may have a list
-of data fields. each data field must specify a data type, so the engine
-knows how to serialize/unserialize that event for network transmission.
-Valid data types are string, float, long, short, byte & bool. If a 
-data field should not be broadcasted to clients, use the type "local".
-*/
-
-
-#define MAX_EVENT_NAME_LENGTH	32		// max game event name length
-#define MAX_EVENT_BITS			9		// max bits needed for an event index
-#define MAX_EVENT_NUMBER		(1<<MAX_EVENT_BITS)		// max number of events allowed
-#define MAX_EVENT_BYTES			1024	// max size in bytes for a serialized event
-
-class KeyValues;
-class CGameEvent;
-
-abstract_class IToolGameEventAPI
-{
-	virtual void unk001( void * ) = 0;
-};
-
-abstract_class IGameEvent
-{
-public:
-	virtual ~IGameEvent() {};
-	virtual const char *GetName() const = 0;	// get event name
-	virtual int GetID() const = 0;
-
-	virtual bool  IsReliable() const = 0; // if event handled reliable
-	virtual bool  IsLocal() const = 0; // if event is never networked
-	virtual bool  IsEmpty(const char *keyName = NULL) = 0; // check if data field exists
-	
-	// Data access
-	virtual bool  GetBool( const char *keyName = NULL, bool defaultValue = false ) = 0;
-	virtual int   GetInt( const char *keyName = NULL, int defaultValue = 0 ) = 0;
-	virtual uint64 GetUint64( const char *keyName = NULL, uint64 defaultValue = 0 ) = 0;
-	virtual float GetFloat( const char *keyName = NULL, float defaultValue = 0.0f ) = 0;
-	virtual const char *GetString( const char *keyName = NULL, const char *defaultValue = "" ) = 0;
-	virtual void *GetPtr( const char *keyName = NULL, void *defaultValue = NULL ) = 0;
-
-	/* These function prototypes and names are very speculative and might be incorrect */
-	virtual CEntityHandle GetEHandle( const char *keyName, CEntityHandle defaultValue ) = 0;
-	virtual CEntityHandle GetStrictEHandle( const char *keyName, CEntityHandle defaultValue ) = 0;
-	virtual CEntityHandle GetEHandle2( const char *keyName, CEntityHandle defaultValue ) = 0;
-
-	virtual CPlayerSlot *GetPlayerSlot( const char *keyName = NULL ) = 0;
-	virtual CBasePlayer *GetPlayer( const char *keyName = NULL ) = 0;
-
-	virtual void *GetPlayerController( const char *keyName = NULL ) = 0;
-	virtual CEntityHandle GetPlayerControllerEHandle( const char *keyName = NULL ) = 0;
-	virtual CEntityHandle GetPlayerControllerEHandle2( const char *keyName = NULL ) = 0;
-	/* ============================================================ */
-
-	virtual void SetBool( const char *keyName, bool value ) = 0;
-	virtual void SetInt( const char *keyName, int value ) = 0;
-	virtual void SetUint64( const char *keyName, uint64 value ) = 0;
-	virtual void SetFloat( const char *keyName, float value ) = 0;
-	virtual void SetString( const char *keyName, const char *value ) = 0;
-	virtual void SetPtr( const char *keyName, void *value ) = 0;
-
-	/* These function prototypes and names are very speculative and might be incorrect */
-	virtual void SetEHandleStrict( const char *keyName, CEntityHandle handle ) = 0;
-	virtual void SetEHandle( const char *keyName, CEntityHandle handle ) = 0;
-
-	// Also sets the _pawn key
-	virtual void SetPlayerSlot( const char *keyName, CPlayerSlot value ) = 0;
-	virtual void SetPlayer( const char *keyName, CBasePlayer *value ) = 0;
-	/* ============================================================ */
-
-	virtual bool HasKey( const char *keyName ) = 0;
-
-	// Something script vm related
-	virtual void unk001() = 0;
-	
-	virtual KeyValues *GetDataKeys() const = 0;
-};
-
-abstract_class IGameEventListener2
-{
-public:
-	virtual	~IGameEventListener2( void ) {};
-
-	// FireEvent is called by EventManager if event just occured
-	// KeyValue memory will be freed by manager if not needed anymore
-	virtual void FireGameEvent( IGameEvent *event ) = 0;
-};
-
-abstract_class IGameEventManager2 : public IBaseInterface, public IToolGameEventAPI
-{
-public:
-	virtual	~IGameEventManager2( void ) {};
-
-	// load game event descriptions from a file eg "resource\gameevents.res"
-	virtual int LoadEventsFromFile( const char *filename, bool bSearchAll ) = 0;
-
-	// removes all and anything
-	virtual void  Reset() = 0;	
-
-	// adds a listener for a particular event
-	virtual bool AddListener( IGameEventListener2 *listener, const char *name, bool bServerSide ) = 0;
-
-	// returns true if this listener is listens to given event
-	virtual bool FindListener( IGameEventListener2 *listener, const char *name ) = 0;
-
-	// removes a listener 
-	virtual void RemoveListener( IGameEventListener2 *listener) = 0;
-
-	// create an event by name, but doesn't fire it. returns NULL is event is not
-	// known or no listener is registered for it. bForce forces the creation even if no listener is active
-	virtual IGameEvent *CreateEvent( const char *name, bool bForce = false, int *pCookie = NULL ) = 0;
-
-	// fires a server event created earlier, if bDontBroadcast is set, event is not send to clients
-	virtual bool FireEvent( IGameEvent *event, bool bDontBroadcast = false ) = 0;
-
-	// fires an event for the local client only, should be used only by client code
-	virtual bool FireEventClientSide( IGameEvent *event ) = 0;
-
-	// create a new copy of this event, must be free later
-	virtual IGameEvent *DuplicateEvent( IGameEvent *event ) = 0;
-
-	// if an event was created but not fired for some reason, it has to bee freed, same UnserializeEvent
-	virtual void FreeEvent( IGameEvent *event ) = 0;
-
-	// write/read event to/from bitbuffer
-	virtual bool SerializeEvent( IGameEvent *event, CMsgSource1LegacyGameEvent *ev ) = 0;
-	virtual IGameEvent *UnserializeEvent( const CMsgSource1LegacyGameEvent &ev ) = 0; // create new KeyValues, must be deleted
-	
-	virtual int LookupEventId( const char *name ) = 0;
-	
-	virtual void PrintEventToString( IGameEvent *event, CUtlString &out ) = 0;
-
-	virtual bool HasEventDescriptor( const char *name ) = 0;
-};
-
-
-#endif // IGAMEEVENTS_H
+//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( IGAMEEVENTS_H )
+#define IGAMEEVENTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "interfaces/interfaces.h"
+#include "tier1/bitbuf.h"
+#include "tier1/generichash.h"
+#include "tier1/utlstring.h"
+#include "ihandleentity.h"
+
+class CMsgSource1LegacyGameEvent;
+class CPlayerSlot;
+class CBasePlayer;
+class CEntityIndex;
+class CEntityHandle;
+class CBaseEntity;
+class CEntityInstance;
+class CBasePlayerController;
+class CBasePlayerPawn;
+//-----------------------------------------------------------------------------
+// Purpose: Engine interface into global game event management
+//-----------------------------------------------------------------------------
+
+/* 
+
+The GameEventManager keeps track and fires of all global game events. Game events 
+are fired by game.dll for events like player death or team wins. Each event has a
+unique name and comes with a KeyValue structure providing informations about this
+event. Some events are generated also by the engine.
+
+Events are networked to connected clients and invoked there to. Therefore you
+have to specify all data fields and there data types in an public resource
+file which is parsed by server and broadcasted to it's clients. A typical game 
+event is defined like this:
+
+	"game_start"				// a new game starts
+	{
+		"roundslimit"	"long"		// max round
+		"timelimit"		"long"		// time limit
+		"fraglimit"		"long"		// frag limit
+		"objective"		"string"	// round objective
+	}
+
+All events must have unique names (case sensitive) and may have a list
+of data fields. each data field must specify a data type, so the engine
+knows how to serialize/unserialize that event for network transmission.
+Valid data types are string, float, long, short, byte & bool. If a 
+data field should not be broadcasted to clients, use the type "local".
+*/
+
+struct GameEventKeySymbol_t
+{
+	inline GameEventKeySymbol_t(const char* keyName): m_nHashCode(0), m_pszKeyName(NULL)
+	{		
+		if (!keyName || !keyName[0])
+			return;
+
+		CUtlString buf( keyName );
+		buf.ToLowerFast();
+
+		m_nHashCode = MurmurHash2(buf.Get(), strlen(keyName), 0x31415926);
+		m_pszKeyName = keyName;
+
+#if 0
+		if (g_bUpdateStringTokenDatabase)
+		{
+			RegisterStringToken(m_nHashCode, keyName, 0, true);
+		}
+#endif
+	}
+
+private:
+	unsigned int m_nHashCode;
+	const char* m_pszKeyName;
+};
+
+
+#define MAX_EVENT_NAME_LENGTH	32		// max game event name length
+#define MAX_EVENT_BITS			9		// max bits needed for an event index
+#define MAX_EVENT_NUMBER		(1<<MAX_EVENT_BITS)		// max number of events allowed
+#define MAX_EVENT_BYTES			1024	// max size in bytes for a serialized event
+
+class KeyValues;
+class CGameEvent;
+
+abstract_class IToolGameEventAPI
+{
+	virtual void unk001( void * ) = 0;
+};
+
+abstract_class IGameEvent
+{
+public:
+	virtual ~IGameEvent() {};
+	virtual const char *GetName() const = 0;	// get event name
+	virtual int GetID() const = 0;
+
+	virtual bool IsReliable() const = 0; // if event handled reliable
+	virtual bool IsLocal() const = 0; // if event is never networked
+	virtual bool IsEmpty( const GameEventKeySymbol_t &keySymbol ) = 0; // check if data field exists
+
+	// Data access
+	virtual bool  GetBool( const GameEventKeySymbol_t &keySymbol, bool defaultValue = false ) = 0;
+	virtual int GetInt( const GameEventKeySymbol_t &keySymbol, int defaultValue = 0 ) = 0;
+	virtual uint64 GetUint64( const GameEventKeySymbol_t &keySymbol, uint64 defaultValue = 0 ) = 0;
+	virtual float GetFloat( const GameEventKeySymbol_t &keySymbol, float defaultValue = 0.0f ) = 0;
+	virtual const char *GetString( const GameEventKeySymbol_t &keySymbol, const char *defaultValue = "" ) = 0;
+	virtual void *GetPtr( const GameEventKeySymbol_t &keySymbol ) = 0;
+
+	virtual CEntityHandle GetEHandle( const GameEventKeySymbol_t &keySymbol, CEntityHandle defaultValue = CEntityHandle() ) = 0;
+
+	// Returns the entity instance, mostly used for _pawn keys, might return 0 if used on any other key (even on a controller).
+	virtual IHandleEntity *GetEntity( const GameEventKeySymbol_t &keySymbol, IHandleEntity *fallbackInstance = NULL ) = 0;
+	virtual CEntityIndex GetEntityIndex( const GameEventKeySymbol_t &keySymbol, CEntityIndex defaultValue = CEntityIndex( -1 ) ) = 0;
+
+	virtual CPlayerSlot GetPlayerSlot( const GameEventKeySymbol_t &keySymbol ) = 0;
+
+	virtual IHandleEntity *GetPlayerController( const GameEventKeySymbol_t &keySymbol ) = 0;
+	virtual IHandleEntity *GetPlayerPawn( const GameEventKeySymbol_t &keySymbol ) = 0;
+
+	// Returns the EHandle for the _pawn entity.
+	virtual CEntityHandle GetPawnEHandle( const GameEventKeySymbol_t &keySymbol ) = 0;
+	// Returns the CEntityIndex for the _pawn entity.
+	virtual CEntityIndex GetPawnEntityIndex( const GameEventKeySymbol_t &keySymbol ) = 0;
+
+	virtual void SetBool( const GameEventKeySymbol_t &keySymbol, bool value ) = 0;
+	virtual void SetInt( const GameEventKeySymbol_t &keySymbol, int value ) = 0;
+	virtual void SetUint64( const GameEventKeySymbol_t &keySymbol, uint64 value ) = 0;
+	virtual void SetFloat( const GameEventKeySymbol_t &keySymbol, float value ) = 0;
+	virtual void SetString( const GameEventKeySymbol_t &keySymbol, const char *value ) = 0;
+	virtual void SetPtr( const GameEventKeySymbol_t &keySymbol, void *value ) = 0;
+
+	virtual void SetEntity( const GameEventKeySymbol_t &keySymbol, CEntityIndex value ) = 0;
+	virtual void SetEntity( const GameEventKeySymbol_t &keySymbol, IHandleEntity *value ) = 0;
+
+	// Also sets the _pawn key
+	virtual void SetPlayer( const GameEventKeySymbol_t &keySymbol, CPlayerSlot value ) = 0;
+	// Also sets the _pawn key (Expects pawn entity to be passed)
+	virtual void SetPlayer( const GameEventKeySymbol_t &keySymbol, IHandleEntity *pawn ) = 0;
+
+	// Expects pawn entity to be passed, will set the controller entity as a controllerKeyName
+	// and pawn entity as a pawnKeyName.
+	virtual void SetPlayerRaw( const GameEventKeySymbol_t &controllerKeySymbol, const GameEventKeySymbol_t &pawnKeySymbol, IHandleEntity *pawn ) = 0;
+
+	virtual bool HasKey( const GameEventKeySymbol_t &keySymbol ) = 0;
+
+	// Something script vm related
+	virtual void unk001() = 0;
+
+	// Not based on keyvalues anymore as it seems like
+	virtual void* GetDataKeys() const = 0;
+};
+
+abstract_class IGameEventListener2
+{
+public:
+	virtual	~IGameEventListener2( void ) {};
+
+	// FireEvent is called by EventManager if event just occured
+	// KeyValue memory will be freed by manager if not needed anymore
+	virtual void FireGameEvent( IGameEvent *event ) = 0;
+};
+
+abstract_class IGameEventManager2 : public IBaseInterface, public IToolGameEventAPI
+{
+public:
+	virtual	~IGameEventManager2( void ) {};
+
+	// load game event descriptions from a file eg "resource\gameevents.res"
+	virtual int LoadEventsFromFile( const char *filename, bool bSearchAll ) = 0;
+
+	// removes all and anything
+	virtual void  Reset() = 0;	
+
+	// adds a listener for a particular event
+	virtual bool AddListener( IGameEventListener2 *listener, const char *name, bool bServerSide ) = 0;
+
+	// returns true if this listener is listens to given event
+	virtual bool FindListener( IGameEventListener2 *listener, const char *name ) = 0;
+
+	// removes a listener 
+	virtual void RemoveListener( IGameEventListener2 *listener) = 0;
+
+	// create an event by name, but doesn't fire it. returns NULL is event is not
+	// known or no listener is registered for it. bForce forces the creation even if no listener is active
+	virtual IGameEvent *CreateEvent( const char *name, bool bForce = false, int *pCookie = NULL ) = 0;
+
+	// fires a server event created earlier, if bDontBroadcast is set, event is not send to clients
+	virtual bool FireEvent( IGameEvent *event, bool bDontBroadcast = false ) = 0;
+
+	// fires an event for the local client only, should be used only by client code
+	virtual bool FireEventClientSide( IGameEvent *event ) = 0;
+
+	// create a new copy of this event, must be free later
+	virtual IGameEvent *DuplicateEvent( IGameEvent *event ) = 0;
+
+	// if an event was created but not fired for some reason, it has to bee freed, same UnserializeEvent
+	virtual void FreeEvent( IGameEvent *event ) = 0;
+
+	// write/read event to/from bitbuffer
+	virtual bool SerializeEvent( IGameEvent *event, CMsgSource1LegacyGameEvent *ev ) = 0;
+	virtual IGameEvent *UnserializeEvent( const CMsgSource1LegacyGameEvent &ev ) = 0; // create new KeyValues, must be deleted
+	
+	virtual int LookupEventId( const char *name ) = 0;
+	
+	virtual void PrintEventToString( IGameEvent *event, CUtlString &out ) = 0;
+
+	virtual bool HasEventDescriptor( const char *name ) = 0;
+};
+
+
+#endif // IGAMEEVENTS_H
diff --git a/tier1/generichash.cpp b/tier1/generichash.cpp
index f251f1c4..bfe8b63e 100644
--- a/tier1/generichash.cpp
+++ b/tier1/generichash.cpp
@@ -1,4 +1,4 @@
-//======= Copyright © 2005, , Valve Corporation, All rights reserved. =========
+//======= Copyright � 2005, , Valve Corporation, All rights reserved. =========
 //
 // Purpose: Variant Pearson Hash general purpose hashing algorithm described
 //			by Cargill in C++ Report 1994.  Generates a 16-bit result.
@@ -301,3 +301,53 @@ unsigned FASTCALL HashBlock( const void *pKey, unsigned size )
 	return (even << 8) | odd;
 }
 
+uint32 MurmurHash2( const void *key, int len, uint32 seed )
+{
+  // 'm' and 'r' are mixing constants generated offline.
+  // They're not really 'magic', they just happen to work well.
+
+  const uint32 m = 0x5bd1e995;
+  const int r = 24;
+
+  // Initialize the hash to a 'random' value
+
+  uint32 h = seed ^ len;
+
+  // Mix 4 bytes at a time into the hash
+
+  const unsigned char * data = (const unsigned char *)key;
+
+  while(len >= 4)
+  {
+    uint32 k = LittleDWord( *(uint32 *)data );
+
+    k *= m;
+    k ^= k >> r;
+    k *= m;
+
+    h *= m;
+    h ^= k;
+
+    data += 4;
+    len -= 4;
+  }
+
+  // Handle the last few bytes of the input array
+
+  switch(len)
+  {
+  case 3: h ^= data[2] << 16;
+  case 2: h ^= data[1] << 8;
+  case 1: h ^= data[0];
+      h *= m;
+  };
+
+  // Do a few final mixes of the hash to ensure the last few
+  // bytes are well-incorporated.
+
+  h ^= h >> 13;
+  h *= m;
+  h ^= h >> 15;
+
+  return h;
+}