View source for Think():es

{{otherlang2
|title=Pensando
|de=Thinking:de
|ru=Thinking:ru
|en=Thinking
}}

Las funciones de pensar, '''"think functions"''', permiten a las entidades programar código que más tarde se ejecutará. Mediante reprogramando "thinks", se pueden hacer bucles automáticos, que pueden hacer que una entidad, sea autónoma, pueda pensar por sí misma.


== Scheduling / Programando ==


<code>SetNextThink()</code> se utiliza para configurar cuándo una entidad debería pensar la siguiente acción. Acepta valores [[Float:es|flotantes]].

<source lang=cpp>
void CMyEntity::Spawn()
{
	BaseClass::Spawn();
	SetNextThink( gpGlobals->curtime ); // Pensar AHORA
}

void CMyEntity::Think()
{
	BaseClass::Think(); // Always do this if you override Think() ... Siempre hacer esto si sobreescribimos "Think()".

	Msg( "Pienso, luego existo.\n" );
	SetNextThink( gpGlobals->curtime + 1 ); // Volver a pensar dentro de un segundo.
}
</source>

Date cuenta del uso de "<code>[[gpGlobals]]->curtime</code>", para hacer que un valor que haya sido enviado, sea relativo al tiempo de ejecución.

{{tip|"<code>SetNextThink(-1)</code>" cancelará cualquier futuro "think". Esto es mejor que utilizar "<code>SetNextThink(NULL)</code>", porque "[[TICK_NEVER_THINK]]" significa "-1"}}


== Nuevas funciones de pensar (think)==
Una entidad puede tener cualquier número de funciones de pensar adicionales. Para registrar una nueva:

# Asegúrate de que la función es un "<code>void</code>".
# Añádela a la tabla de descripciones de la entidad, es decir, "[[DATADESC]]", con el código "<code>DEFINE_THINKFUNC()</code>".
# Llama a la función "<code>SetThink()</code>" y envía un pointer a la función. Debajo hay un ejemplo.
# Asegúrate de que "<code>DECLARE_DATADESC();</code>" está en la clase.

<source lang=cpp>
BEGIN_DATADESC( CMiEntidad )
	DEFINE_THINKFUNC( MiPensamiento ), // Register new think function  .... Registra una nueva funcion Think()
END_DATADESC()

void CMiEntidad::Spawn()
{
	BaseClass::Spawn();
	SetThink( &CMiEntidad::MiPensamiento ); // Pass a function pointer ... Envia un pointer a la funcion
	SetNextThink(gpGlobals->curtime);
}

void CMiEntidad::MiPensamiento()
{
	Msg( "Pienso, luego existo.\n" );
	SetNextThink( gpGlobals->curtime + 1 );
}
</source>

Dividiendo tu código de pensar en diferentes funciones hace más fácil que una entidad pueda cambiar entre distintos modos de operación.


{{tip|<code>SetThink()</code> también puede ser llamado dentro de una función de pensar. La siguiente llamada será a la nueva función.}}


== Usando contextos==

Es posible programar cualquier número de funciones Think(), simultáneamente, con los contextos de pensar, o en inglés 'think contexts'. Para crear un nuevo contexto:

# Llama a <code>RegisterThinkContext([[string]] NombreContexto)</code>
# Llama a <code>SetContextThink([[void]]* Function, float NextThinkTime, string NombreContexto)</code>
# Para Thinks() subsecuentes llama a <code>SetNextThink(float NextThinkTime, string NombreContexto)</code>

<source lang=cpp>
BEGIN_DATADESC( CMiEntidad )
	DEFINE_THINKFUNC( NombreContexto ),
END_DATADESC()

void  CMiEntidad::Spawn()
{
	SetNextThink( gpGlobals->curtime ); // Bucle por defecto de pensar - sin contexto 
	
	RegisterThinkContext( "ContextoPrueba" );
	SetContextThink( & CMiEntidad::NombreContexto , gpGlobals->curtime, "ContextoPrueba" );
}

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

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

void  CMiEntidad::NombreContexto()
{
	Msg( "Pensar contexto\n" );
	SetNextThink(gpGlobals->curtime + .2, "ContextoPrueba" );
}
</source>

Esto crea dos bucles de pensar simultáneos, los dos escriben un mensaje en la consola, a una velocidad distinta.


{{tip|Crear un nuevo contexto es una buena forma de retrasar llamadas a funciones al futuro, sin romper los bucles Think() que se estén ejecutando.}}

== Utilidades ==

Esto se explica por sí solo:

<source lang=cpp>
float	GetLastThink()
float	GetNextThink()
int	GetLastThinkTick()
int	GetNextThinkTick()
</source>

[[File:Barnacle.jpg|left|100px|link=npc_barnacle]]

The <code>GetLast</code> 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:

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

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.

 <span style="color:blue;">void</span> C_MyEntity::ClientThink()
 {
 	Msg( <span style="color:brown;">"Don't put anything [[expensive]] in this function!\n"</span> );
 	SetNextClientThink( CLIENT_THINK_ALWAYS ); <span style="color:green;">// Think every frame</span>
 }

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)

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

; CLIENT_THINK_ALWAYS
: Think on the client once every frame. Use with caution! {{tip|Use <code>[[gpGlobals]]->frametime</code> to regulate speed.}}
; CLIENT_THINK_NEVER
: Pause all automated client thinking.

[[Category:Programming]]
[[Category:AI]]
[[Category:Functions]]