add gsi event

Author: mastercoms

src/game/shared/gamestate/gamestate.cpp

@@ -92,12 +92,18 @@ class CHTTPServerThread : public CThread
 		"getingame"
 	},
 	m_UnprivilegedEvents{
-		"closedmenu"
+		"ingame",
+		"gsi"
 	}
 	{
 		SetName("GameStateHTTPThread");
 	}
 
+	int64_t GetClientId( crow::websocket::connection& conn )
+	{
+		return *static_cast<int64_t*>( conn.userdata() );
+	}
+
 	// Return 0 for success
 	virtual int Run() OVERRIDE
 	{
@@ -122,7 +128,7 @@ class CHTTPServerThread : public CThread
 				AUTO_LOCK( m_clientsMutex )
 				int64_t clientId = m_iNextClientId++;
 				*userdata = new int64_t(clientId);
-				if ( m_iPrivilegedClientId == -1 )
+				if ( m_iPrivilegedClientId == 0 )
 				{
 					m_iPrivilegedClientId = clientId;
 				}
@@ -145,8 +151,9 @@ class CHTTPServerThread : public CThread
 				int64_t clientId = *userdata;
 				if ( m_iPrivilegedClientId == clientId )
 				{
-					m_iPrivilegedClientId = -1;
+					m_iPrivilegedClientId = 0;
 				}
+				m_SubscribedClientIds.erase( clientId );
 				for ( std::size_t i = 0; i < size; i++ )
 				{
 					if ( *static_cast<int64_t*>( m_connectedClients[i]->userdata() ) == clientId )
@@ -207,16 +214,43 @@ class CHTTPServerThread : public CThread
 					Assert( 0 );
 					m_connectedClients.push_back( &conn );
 				}
+				int64_t clientId = GetClientId( conn );
 				if ( !V_strcmp(strCommand.c_str(), "disconnect") )
 				{
 					// immediately send back a message for closing
-					crow::json::wvalue dcResp;
-					dcResp["i"] = id;
-					conn.send_text( dcResp.dump() );
-					m_iPrivilegedClientId = -1;
+					crow::json::wvalue resp;
+					resp["i"] = id;
+					conn.send_text( resp.dump() );
+					m_iPrivilegedClientId = 0;
+					return;
+				}
+				if ( !V_strcmp( strCommand.c_str(), "subscribe" ) )
+				{
+					// immediately send back a message for subscribing
+					crow::json::wvalue resp;
+					resp["i"] = id;
+					conn.send_text( resp.dump() );
+					if ( m_iPrivilegedClientId != clientId )
+					{
+						m_SubscribedClientIds.insert( clientId );
+					}
+					GetGameStateManager()->InitSubscriptions();
 					return;
 				}
-				bIsPrivileged = m_iPrivilegedClientId == *static_cast<int64_t*>( conn.userdata() );
+				if ( !V_strcmp( strCommand.c_str(), "unsubscribe" ) )
+				{
+					// immediately send back a message for unsubscribing
+					crow::json::wvalue resp;
+					resp["i"] = id;
+					conn.send_text( resp.dump() );
+					m_SubscribedClientIds.erase( clientId );
+					if ( m_SubscribedClientIds.size() < 1 )
+					{
+						GetGameStateManager()->StopSubscriptions();
+					}
+					return;
+				}
+				bIsPrivileged = m_iPrivilegedClientId == clientId;
 			}
 
 			std::string params;
@@ -425,8 +459,10 @@ class CHTTPServerThread : public CThread
 	std::unordered_set<std::string> m_UnprivilegedMethods;
 	std::unordered_set<std::string> m_UnprivilegedEvents;
 
+	std::unordered_set<int64_t> m_SubscribedClientIds;
+
 	int64_t m_iNextClientId = 1;
-	int64_t m_iPrivilegedClientId = -1;
+	int64_t m_iPrivilegedClientId = 0;
 
 	std::vector<crow::websocket::connection*> m_connectedClients;
 	CThreadMutex m_clientsMutex;
@@ -636,8 +672,17 @@ void CGameStateManager::Shutdown()
 	m_pServerThread = NULL;
 }
 
+void CGameStateManager::FireGameEvent(IGameEvent* event)
+{
+	const char* pszEvent = event->GetName();
+	std::string data = pszEvent;
+	data += " ";
+	KeyValuesDumpAsString( event->GetDataKeys(), &data );
+	QueueEvent( "gsi", data );
+}
+
 void CGameStateManager::RegisterMethod(std::string methodName,
-	const std::function<std::string(const std::string& params)>& method)
+                                       const std::function<std::string(const std::string& params)>& method)
 {
 	if (!m_bInit)
 		return;
@@ -666,3 +711,59 @@ void CGameStateManager::QueueEvent(const std::string& strEvent, const std::strin
 
 	m_pServerThread->QueueEvent(strEvent, strParams);
 }
+
+void CGameStateManager::InitSubscriptions()
+{
+	if ( m_bListeningToEvents )
+		return;
+
+	m_bListeningToEvents = true;
+
+	ListenForGameEvent( "game_newmap" );
+	ListenForGameEvent( "player_connect" );
+	ListenForGameEvent( "player_disconnect" );
+	ListenForGameEvent( "player_changeclass" );
+	ListenForGameEvent( "player_team" );
+	ListenForGameEvent( "player_info" );
+	ListenForGameEvent( "player_death" );
+	ListenForGameEvent( "player_spawn" );
+	ListenForGameEvent( "player_hurt" );
+	ListenForGameEvent( "round_start" );
+	ListenForGameEvent( "round_end" );
+	ListenForGameEvent( "server_spawn" );
+	ListenForGameEvent( "client_disconnect" );
+	ListenForGameEvent( "controlpoint_starttouch" );
+	ListenForGameEvent( "controlpoint_endtouch" );
+	ListenForGameEvent( "ctf_flag_captured" );
+	ListenForGameEvent( "teamplay_broadcast_audio" );
+	ListenForGameEvent( "teamplay_capture_blocked" );
+	ListenForGameEvent( "teamplay_flag_event" );
+	ListenForGameEvent( "teamplay_game_over" );
+	ListenForGameEvent( "teamplay_point_captured" );
+	ListenForGameEvent( "teamplay_round_stalemate" );
+	ListenForGameEvent( "teamplay_round_start" );
+	ListenForGameEvent( "teamplay_round_win" );
+	ListenForGameEvent( "teamplay_timer_time_added" );
+	ListenForGameEvent( "teamplay_update_timer" );
+	ListenForGameEvent( "teamplay_win_panel" );
+	ListenForGameEvent( "teamplay_setup_finished" );
+	ListenForGameEvent( "teamplay_alert" );
+	ListenForGameEvent( "teamplay_teambalanced_player" );
+	ListenForGameEvent( "teamplay_point_startcapture" );
+	ListenForGameEvent( "teamplay_round_active" );
+	ListenForGameEvent( "tf_game_over" );
+	ListenForGameEvent( "object_destroyed" );
+	ListenForGameEvent( "object_detonated" );
+	ListenForGameEvent( "tournament_stateupdate" );
+	ListenForGameEvent( "num_cappers_changed" );
+}
+
+void CGameStateManager::StopSubscriptions()
+{
+	if ( !m_bListeningToEvents )
+		return;
+
+	m_bListeningToEvents = false;
+
+	StopListeningForAllEvents();
+}

src/game/shared/gamestate/gamestate.h

@@ -14,24 +14,30 @@
 #include <functional>
 #include "igamesystem.h"
 
-class CGameStateManager : public CAutoGameSystemPerFrame
+class CGameStateManager : public CAutoGameSystemPerFrame, public CGameEventListener
 {
 public:
 	CGameStateManager();
 
 	virtual bool Init() OVERRIDE;
 	virtual void Update(float frametime) OVERRIDE;
 	virtual void Shutdown() OVERRIDE;
+	virtual char const* Name() OVERRIDE { return "CGameStateManager"; }
+	virtual void FireGameEvent( IGameEvent* event ) OVERRIDE;
 	void RegisterMethod(std::string methodName, const std::function<std::string(const std::string& params) >& method);
 	void UnregisterMethod(std::string methodName);
 	void QueueEvent(const std::string& strEvent, const std::string& strParams);
 
 	bool IsReady() { return m_bReady; }
 	void MarkReady() { m_bReady = true; }
+	
+	void InitSubscriptions();
+	void StopSubscriptions();
 
 private:
 	bool m_bInit = false;
 	bool m_bReady = false;
+	bool m_bListeningToEvents = false;
 	class CHTTPServerThread* m_pServerThread = NULL;
 };
 

src/public/tier1/KeyValues.h

@@ -22,6 +22,7 @@
 #endif
 #endif
 
+#include <string>
 #include "utlvector.h"
 #include "Color.h"
 
@@ -492,4 +493,22 @@ inline bool KeyValuesDumpAsDevMsg( KeyValues *pKeyValues, int nIndentLevel = 0,
 	return pKeyValues->Dump( &ctx, nIndentLevel );
 }
 
+class CKeyValuesDumpContextAsString : public IKeyValuesDumpContextAsText
+{
+public:
+	CKeyValuesDumpContextAsString( std::string* str ) : m_strBuf{ str } {}
+
+public:
+	virtual bool KvWriteText( char const* szText );
+
+protected:
+	std::string* m_strBuf;
+};
+
+inline bool KeyValuesDumpAsString( KeyValues* pKeyValues, std::string* str, int nIndentLevel = 0 )
+{
+	CKeyValuesDumpContextAsString ctx( str );
+	return pKeyValues->Dump( &ctx, nIndentLevel );
+}
+
 #endif // KEYVALUES_H

src/tier1/KeyValues.cpp

@@ -3281,3 +3281,9 @@ bool CKeyValuesDumpContextAsDevMsg::KvWriteText( char const *szText )
 	}
 	return true;
 }
+
+bool CKeyValuesDumpContextAsString::KvWriteText( char const* szText )
+{
+	m_strBuf->append(szText);
+	return true;
+}