A simple C# library to interface with Counter-Strike: Global Offensive Game State Integration

What is Game State Integration
About CSGSI
Installation
Usage
Events
Null value handling
Example program

This wiki page by Valve explains the concept of GSI.

This library provides means to listen to a specific port for the game clients HTTP POST request. Once a request is received, the game state is parsed and can then be analyzed.

CSGSI uses Newtonsoft's JSON.Net Framework to parse JSON.

Once a GameStateListener instance is running, it continuously listens for incoming HTTP requests.
Every time a request is received, it's JSON content is used to construct a new GameState object.
The GameState class represents the entire game state as it was sent by the client.
It also provides access to all rootnodes (see Usage).

Via NuGet:

Install-Package CSGSI

Manual installation:

1. Get the latest binaries
2. Get the JSON Framework .dll by Newtonsoft
3. Extract Newtonsoft.Json.dll from Bin\Net45\Newtonsoft.Json.dll
4. Add a reference to both CSGSI.dll and Newtonsoft.Json.dll in your project

Hint: The NuGet package will always be up to date with the latest commit, but I will only publish a new binary release every major update.

1. Create a GameStateListener instance by providing a port or passing a specific URI:

GameStateListener gsl = new GameStateListener(3000); //https://localhost:3000/  
GameStateListener gsl = new GameStateListener("https://127.0.0.1:81/");

Please note: If your application needs to listen to a URI other than https://localhost:*/ (for example https://192.168.2.2:100/), you need to ensure that it is run with administrator privileges.
In this case, https://127.0.0.1:*/ is not equivalent to https://localhost:*/.

2. Create a handler:

void OnNewGameState(GameState gs)
{
    //do stuff
}

3. Subscribe to the NewGameState event:

gsl.NewGameState += OnNewGameState;

4. Use GameStateListener.Start() to start listening for HTTP POST requests from the game client. This method will return false if starting the listener fails (most likely due to insufficient privileges).

int Health = gs.Player.State.Health;
//100

string activeWep = gs.Player.Weapons.ActiveWeapon.JSON
//{
//  "name": "weapon_knife",
//  "paintkit": ...
//  ...
//}

CSGSI provides a few helpful events that you can subscribe to avoid having to implement the logic yourself. These events are experimental and not entirely reliable (mostly because CSGO's Game State Integration itself sends inconsistent data).

Raising these events is disabled by default. To enable this feature, set GameStateListener.EnableRaisingIntricateEvents = true.

Available events:

• RoundPhaseChanged - Is raised when the round phase changes (for example "Live", "FreezeTime" etc.).
• PlayerFlashed - Is raised when a player is flashed. Includes information about how much the player was flashed (0 - 255).
• BombPlanted - Is raised when the bomb is planted.
• BombDefused - Is raised when the bomb is defused.
• BombExploded - Is raised when the bomb explodes.
• RoundEnd - Is raised when the round ends.
• RoundBegin - Is raised when a round begins (i.e. exits FreezeTime).

In case the JSON did not contain the requested information or parsing the node failed, these values will be returned instead:

All Enums have a value enum.Undefined that serves the same purpose.

Prints "Bomb has been planted", every time you plant the bomb:

using System;
using CSGSI;
using CSGSI.Nodes;

namespace CSGSI_Test
{
    class Program
    {
        static GameStateListener gsl;
        static void Main(string[] args)
        {
            gsl = new GameStateListener(3000);
            gsl.NewGameState += new NewGameStateHandler(OnNewGameState);
            if (!gsl.Start())
            {
                Environment.Exit(0);
            }
            Console.WriteLine("Listening...");
        }
        
        static void OnNewGameState(GameState gs)
        {
            if(gs.Round.Phase == RoundPhase.Live &&
               gs.Bomb.State == BombState.Planted &&
               gs.Previously.Bomb.State == BombState.Planting)
            {
                Console.WriteLine("Bomb has been planted.");
                IsPlanted = true;
            }
        }
    }
}

Note that you can now also use events provided by the GameStateListener to achieve this:

using System;
using CSGSI;
using CSGSI.Nodes;

namespace CSGSI_Test
{
    class Program
    {
        static GameStateListener gsl;
        static void Main(string[] args)
        {
            gsl = new GameStateListener(3000);
            gsl.BombPlanted += BombPlanted;
            gsl.EnableRaisingIntricateEvents = true;
            if (!gsl.Start())
            {
                Environment.Exit(0);
            }
            Console.WriteLine("Listening...");
        }

        private static void BombPlanted(CSGSI.Events.BombPlantedEventArgs e)
        {
            Console.WriteLine("Bomb has been planted.");
        }
    }
}

You will also need to create a custom gamestate_integration_*.cfg in /csgo/cfg, for example:
gamestate_integration_test.cfg:

"CSGSI Example"
{
	"uri" "https://localhost:3000"
	"timeout" "5.0"
	"auth"
	{
		"token"				"CSGSI Test"
	}
	"data"
	{
		"provider"              	"1"
		"map"                   	"1"
		"round"                 	"1"
		"player_id"					"1"
		"player_weapons"			"1"
		"player_match_stats"		"1"
		"player_state"				"1"
		"allplayers_id"				"1"
		"allplayers_state"			"1"
		"allplayers_match_stats"	"1"
	}
}

Please note: In order to run this test application without explicit administrator privileges, you need to use the URI https://localhost:<port> in this configuration file.