Backups/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2025-09-19 20:16:10 +08:00
Code Activity

Update IGameEvent (#155)

Browse Source 
Co-authored-by: GAMMACASE <31375974+GAMMACASE@users.noreply.github.com>
This commit is contained in:
Juice
2023-10-09 00:16:21 +03:00
committed by GitHub
parent edef920f90
commit 4c5294550f
2 changed files with 277 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

413
public/igameevents.h
View File

@ -1,187 +1,226 @@
//========= Copyright <20> 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 <20> 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

52
tier1/generichash.cpp
View File

@ -1,4 +1,4 @@
//======= Copyright <20> 2005, , Valve Corporation, All rights reserved. =========
//======= Copyright <20> 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;
}