First version of the SOurce SDK 2013

1 files changed, 193 insertions, 0 deletions

diff --git a/mp/src/public/igameevents.h b/mp/src/public/igameevents.h
new file mode 100644
index 00000000..a1b69775
--- /dev/null
+++ b/mp/src/public/igameevents.h
@@ -0,0 +1,193 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $Workfile:     $

+// $Date:         $

+//

+//-----------------------------------------------------------------------------

+// $Log: $

+//

+// $NoKeywords: $

+//=============================================================================//

+#if !defined( IGAMEEVENTS_H )

+#define IGAMEEVENTS_H

+#ifdef _WIN32

+#pragma once

+#endif

+

+#include "tier1/interface.h"

+

+#define INTERFACEVERSION_GAMEEVENTSMANAGER	"GAMEEVENTSMANAGER001"	// old game event manager, don't use it!

+#define INTERFACEVERSION_GAMEEVENTSMANAGER2	"GAMEEVENTSMANAGER002"	// new game event manager,

+

+#include "tier1/bitbuf.h"

+//-----------------------------------------------------------------------------

+// 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 IGameEvent

+{

+public:

+	virtual ~IGameEvent() {};

+	virtual const char *GetName() const = 0;	// get event name

+

+	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 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 SetBool( const char *keyName, bool value ) = 0;

+	virtual void SetInt( const char *keyName, int value ) = 0;

+	virtual void SetFloat( const char *keyName, float value ) = 0;

+	virtual void SetString( const char *keyName, const char *value ) = 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:

+	virtual	~IGameEventManager2( void ) {};

+

+	// load game event descriptions from a file eg "resource\gameevents.res"

+	virtual int LoadEventsFromFile( const char *filename ) = 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 ) = 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, bf_write *buf ) = 0;

+	virtual IGameEvent *UnserializeEvent( bf_read *buf ) = 0; // create new KeyValues, must be deleted

+};

+

+// the old game event manager interface, don't use it. Rest is legacy support:

+

+abstract_class IGameEventListener

+{

+public:

+	virtual	~IGameEventListener( void ) {};

+

+	// FireEvent is called by EventManager if event just occured

+	// KeyValue memory will be freed by manager if not needed anymore

+	virtual void FireGameEvent( KeyValues * event) = 0;

+};

+

+abstract_class IGameEventManager : public IBaseInterface

+{

+public:

+	virtual	~IGameEventManager( void ) {};

+	

+	// load game event descriptions from a file eg "resource\gameevents.res"

+	virtual int LoadEventsFromFile( const char * filename ) = 0;

+

+	// removes all and anything

+	virtual void  Reset() = 0;	

+				

+	virtual KeyValues *GetEvent(const char * name) = 0; // returns keys for event

+	

+	// adds a listener for a particular event

+	virtual bool AddListener( IGameEventListener * listener, const char * event, bool bIsServerSide ) = 0;

+	// registers for all known events

+	virtual bool AddListener( IGameEventListener * listener, bool bIsServerSide ) = 0; 

+	

+	// removes a listener 

+	virtual void RemoveListener( IGameEventListener * listener) = 0;

+		

+	// fires an global event, specific event data is stored in KeyValues

+	// local listeners will receive the event instantly

+	// a network message will be send to all connected clients to invoke

+	// the same event there

+	virtual bool FireEvent( KeyValues * event ) = 0;

+

+	// fire a side server event, that it wont be broadcasted to player clients

+	virtual bool FireEventServerOnly( KeyValues * event ) = 0;

+

+	// fires an event only on this local client

+	// can be used to fake events coming over the network 

+	virtual bool FireEventClientOnly( KeyValues * event ) = 0;

+

+	// write/read event to/from bitbuffer

+	virtual bool SerializeKeyValues( KeyValues *event, bf_write *buf, CGameEvent *eventtype = NULL ) = 0;

+	virtual KeyValues *UnserializeKeyValue( bf_read *msg ) = 0; // create new KeyValues, must be deleted

+};

+

+

+

+

+#endif // IGAMEEVENTS_H