Thinking

Think functions allow entities to schedule code to be run in the future. By constantly rescheduling, automated "think loops" can be created that make the entity run code autonomously.

Scheduling

SetNextThink() is used to configure when an entity should next think. Its accepts a float value.

void CMyEntity::Spawn()
{
	BaseClass::Spawn();
	SetNextThink( gpGlobals->curtime ); // Think now
}

void CMyEntity::Think()
{
	BaseClass::Think(); // Always do this if you override Think()

	Msg( "I think, therefore I am.\n" );
	SetNextThink( gpGlobals->curtime + 1 ); // Think again in 1 second
}

Notice the use of gpGlobals->curtime to make the value passed relative to the time of execution.

Tip:SetNextThink(0) or SetNextThink(null) will cancel any future thinks.

New think functions

An entity can have any number of additional think functions. To register a new one:

1. Ensure the function is void.
2. Add it to the entity's DATADESC with DEFINE_THINKFUNC().
3. Call SetThink() and pass a pointer to the function (see example below).

BEGIN_DATADESC( CMyEntity )
	DEFINE_THINKFUNC( MyThink ), // Register new think function
END_DATADESC()

void CMyEntity::Spawn()
{
	BaseClass::Spawn();
	SetThink( &CMyEntity::MyThink ); // Pass a function pointer
	SetNextThink(gpGlobals->curtime);
}

void CMyEntity::MyThink()
{
	Msg( "I think, therefore I am.\n" );
	SetNextThink( gpGlobals->curtime + 1 );
}

Splitting your think code into different functions makes it easy to switch an entity between modes of operation.

Tip:SetThink() can be called from within a think function, too. The next call will be to the new function.

Using contexts

It is possible to schedule any number of think functions side-by-side with "think contexts". To create a new context:

1. Call RegisterThinkContext(string ContextName)
2. Call SetContextThink(void* Function, float NextThinkTime, string ContextName)
3. For subsequent thinks, call SetNextThink(float NextThinkTime, string ContextName)

BEGIN_DATADESC( CMyEntity )
	DEFINE_THINKFUNC( ContextThink ),
END_DATADESC()

void CMyEntity::Spawn()
{
	SetNextThink( gpGlobals->curtime ); // Default think loop - no context 
	
	RegisterThinkContext( "TestContext" );
	SetContextThink( &TestEnt432::ContextThink, gpGlobals->curtime, "TestContext" );
}

void TestEnt432::Think()
{
	BaseClass::Think();

	Msg( "Think\n" );
	SetNextThink( gpGlobals->curtime + .1 );
}

void TestEnt432::ContextThink()
{
	Msg( "Context think\n" );
	SetNextThink(gpGlobals->curtime + .2, "TestContext" );
}

This creates two simulataneous think loops, both writing to the console at different rates.

Tip:Creating a new context is a great way to delay function calls to the future without upsetting existing think loops.

Utilities

These should be self-explanatory:

float	GetLastThink()
float	GetNextThink()
int	GetLastThinkTick()
int	GetNextThinkTick()

The GetLast functions are useful for controlling the rate at which something occurs. This think code from npc_barnacle modulates the speed of tongue movement, even if the frequency of thinking changes:

float dt = gpGlobals->curtime - GetLastThink(); // dt is "delta time"
SetAltitude( m_flAltitude + m_flBarnaclePullSpeed * dt ); // Change tongue altitude

For its non-skeletal animation to be smooth this code would need to be executed every frame. This is exactly what happens, until the barnacle is no longer in the player's PVS and the rate is slowed down – thus requiring the above code.

ClientThink()

Thinking can also occur on the client, but its effects are limited. Only one think function is supported for each entity.

void C_MyEntity::ClientThink()
{
	Msg( "Don't put anything expensive in this function!\n" );
	SetNextClientThink( CLIENT_THINK_ALWAYS ); // Think every frame
}

Some examples of client-side thinking are:

• Visual effects / particles
• VGUI screen interaction
• Modifying player speed (done on the client as well as server to avoid prediction errors)
• Striders’ legs snapping ropes (disabled by default)

SetNextClientThink() is used to schedule ClientThink(). There are two special values it accepts:

CLIENT_THINK_ALWAYS

Think on the client once every frame. Use with caution!

CLIENT_THINK_NEVER

Pause all automated client thinking.