g_utils.cpp

this keik game source

void G_Color3f
	(
	float r,
	float g,
	float b
	)

	{
	vertColor = Vector( r, g, b );
	}

void G_Color3v
	(
	Vector color
	)

	{
	vertColor = color;
	}

void G_Color4f
	(
	float r,
	float g,
	float b,
	float alpha
	)

	{
	vertColor = Vector( r, g, b );
	vertAlpha = alpha;
	}

void G_Color3vf
	(
	Vector color,
	float alpha
	)

	{
	vertColor = color;
	vertAlpha = alpha;
	}

void G_BeginLine
	(
	void
	)

	{
	currentVertex = vec_zero;
	vertexIndex = 0;
	}

void G_Vertex
	(
	Vector v
	)

	{
	vertexIndex++;
	if ( vertexIndex > 1 )
		{
		G_DebugLine( currentVertex, v, vertColor[ 0 ], vertColor[ 1 ], vertColor[ 2 ], vertAlpha );
		}
	currentVertex = v;
	}

void G_EndLine
	(
	void
	)

	{
	currentVertex = vec_zero;
	vertexIndex = 0;
	}

void G_DebugBBox
   (
   Vector origin,
   Vector mins,
   Vector maxs,
   float r,
   float g,
   float b,
   float alpha
   )
   {
   int i;
   Vector points[8];

	/*
	** compute a full bounding box
	*/
	for ( i = 0; i < 8; i++ )
	   {
		Vector   tmp;

		if ( i & 1 )
			tmp[0] = origin[0] +  mins[0];
		else
			tmp[0] = origin[0] + maxs[0];

		if ( i & 2 )
			tmp[1] = origin[1] + mins[1];
		else
			tmp[1] = origin[1] + maxs[1];

		if ( i & 4 )
			tmp[2] = origin[2] + mins[2];
		else
			tmp[2] = origin[2] + maxs[2];

		points[i] = tmp;
	   }

   G_Color4f( r, g, b, alpha );

   G_BeginLine();
   G_Vertex( points[0] );
   G_Vertex( points[1] );
   G_Vertex( points[3] );
   G_Vertex( points[2] );
   G_Vertex( points[0] );
   G_EndLine();

   G_BeginLine();
   G_Vertex( points[4] );
   G_Vertex( points[5] );
   G_Vertex( points[7] );
   G_Vertex( points[6] );
   G_Vertex( points[4] );
   G_EndLine();

	for ( i = 0; i < 4; i++ )
      {
      G_BeginLine();
      G_Vertex( points[i] );
      G_Vertex( points[4 + i] );
      G_EndLine();
      }
   }

//
// LED style digits
//
// ****1***
// *      *		8 == /
// 6     *4
// *    * *
// ****2***
// *  *   *
// 7 *--8 5
// **     *
// ****3***
//

static int Numbers[ 10 ][ 8 ] =
	{
		{ 1, 3, 4, 5, 6, 7, 0, 0 }, // 0
		{ 4, 5, 0, 0, 0, 0, 0, 0 }, // 1
		{ 1, 4, 2, 7, 3, 0, 0, 0 }, // 2
		{ 1, 4, 2, 5, 3, 0, 0, 0 }, // 3
		{ 6, 4, 2, 5, 0, 0, 0, 0 }, // 4
		{ 1, 6, 2, 5, 3, 0, 0, 0 }, // 5
		{ 1, 6, 2, 5, 7, 3, 0, 0 }, // 6
		{ 1, 8, 0, 0, 0, 0, 0, 0 }, // 7
		{ 1, 2, 3, 4, 5, 6, 7, 0 }, // 8
		{ 1, 6, 4, 2, 5, 3, 0, 0 }, // 9
	};

static float Lines[ 9 ][ 4 ] =
	{
		{ 0, 0, 0, 0 },		// Unused
		{ -4, 8, 4, 8 },		// 1
		{ -4, 4, 4, 4 },		// 2
		{ -4, 0, 4, 0 },		// 3
		{ 4, 8, 4, 4 },		// 4
		{ 4, 4, 4, 0 },		// 5
		{ -4, 8, -4, 4 },		// 6
		{ -4, 4, -4, 0 },		// 7
		{ 4, 8, -4, 0 },		// 8
	};

void G_DrawDebugNumber
   (
   Vector origin,
	int number,
	float scale,
   float r,
   float g,
   float b
   )

   {
   int i;
	int j;
	int l;
	int num;
	Vector up;
	Vector right;
	Vector pos;
	Vector start;
	Vector ang;
	str text;
	Vector delta;
	
	// only draw entity numbers within a certain radius
	delta = Vector( g_edicts[ 1 ].s.origin ) - origin;
	if ( ( delta * delta ) > ( 1000 * 1000 ) )
		{
		return;
		}

   G_Color4f( r, g, b, 1.0 );

	ang = game.clients[ 0 ].ps.viewangles;
	ang.AngleVectors( NULL, &right, &up );

	up *= scale;
	right *= scale;

	text = va( "%d", number );
	start = origin - ( text.length() - 1 ) * 5 * right;

	for( i = 0; i < text.length(); i++ )
		{
		num = text[ i ] - '0';
		for( j = 0; j < 8; j++ )
			{
			l = Numbers[ num ][ j ];
			if ( l == 0 )
				{
				break;
				}

			G_BeginLine();

			pos = start + Lines[ l ][ 0 ] * right + Lines[ l ][ 1 ] * up;
			G_Vertex( pos );

			pos = start + Lines[ l ][ 2 ] * right + Lines[ l ][ 3 ] * up;
			G_Vertex( pos );

			G_EndLine();
			}

		start += 10 * right;
		}
   }

Vector G_CalculateImpulse
   (
   Vector start,
   Vector end,
   float speed, 
   float gravity
   )

   {
   float traveltime, vertical_speed;
   Vector dir, xydir, velocity;

   dir = end - start;
   xydir = dir;
   xydir.z = 0;
   traveltime = xydir.length() / speed;
   vertical_speed = ( dir.z / traveltime ) + ( 0.5f * gravity * sv_gravity->value * traveltime );
   xydir.normalize();

   velocity = speed * xydir;
   velocity.z = vertical_speed;
   return velocity;
   }

Vector G_PredictPosition
   (
   Vector start,
   Vector target,
   Vector targetvelocity,
   float  speed
   )

   {
   Vector projected;
   float traveltime;
   Vector dir, xydir;

   dir = target - start;
   xydir = dir;
   xydir.z = 0;
   traveltime = xydir.length() / speed;
   projected = target + ( targetvelocity * traveltime );

   return projected;
   }

const char *ExpandLocation
   (
   const char *location
   )

   {
   if ( !strcmpi( location, "all" ) )
      return NULL;

   if ( !strnicmp( location, "torso", 5 ) )
      {
      if ( location[6] == 'u' )
         {
         return ( "upper chest" );
         }
      else if (location[6] == 'l')
         {
         return ( "lower chest" );
         }
      else
         {
         return ( "chest" );
         }
      }
   else if ( !strnicmp( location, "leg", 3 ) )
      {
      if ( location[9] == 'u' )
         {
         return ( "upper leg" );
         }
      else if (location[9] == 'l')
         {
         return ( "lower leg" );
         }
      else
         {
         return ( "leg" );
         }
      }
   else if ( !strnicmp( location, "arm", 3 ) )
      {
      return ( "arm" );
      }
   else if ( !strnicmp( location, "head", 4 ) )
      {
      return ( "head" );
      }

   return NULL;
   }

char *ClientTeam
   (
   edict_t *ent
   )

   {
	static char	value[512];

	value[0] = 0;

	if (!ent->client)
		return value;

   if ( DM_FLAG( DF_MODELTEAMS ) )
      COM_StripExtension( Info_ValueForKey( ent->client->pers.userinfo, "model" ), value );
   else if ( DM_FLAG( DF_SKINTEAMS ) )
      COM_StripExtension( Info_ValueForKey( ent->client->pers.userinfo, "skin" ), value );

	return( value );
   }


qboolean OnSameTeam
   (
   Entity *ent1,
   Entity *ent2
   )

   {
	char	ent1Team [512];
	char	ent2Team [512];

	if ( !DM_FLAG( DF_MODELTEAMS | DF_SKINTEAMS ) )
		return false;

	strcpy (ent1Team, ClientTeam (ent1->edict));
	strcpy (ent2Team, ClientTeam (ent2->edict));

	if ( !strcmp( ent1Team, ent2Team ) )
		return true;

	return false;
   }

/*
==============
G_LoadAndExecScript

Like the man says...
==============
*/
void G_LoadAndExecScript
   (
   const char *filename,
   const char *label
   )

   {
   ScriptThread *pThread;

   if ( gi.LoadFile( filename, NULL, 0 ) != -1 )
		{
	   pThread = Director.CreateThread( filename, LEVEL_SCRIPT, label );
      if ( pThread )
         {
         // start right away
         pThread->Start( -1 );
         }
      else
         {
   		gi.dprintf( "G_LoadAndExecScript : %s could not create thread.", filename );
         }
		}
   }

ScriptThread * ExecuteThread
	(
   str thread_name,
   qboolean start
	)
	{
   GameScript * s;

   if ( thread_name.length() )
      {
      ScriptThread * pThread;

   	s = ScriptLib.GetScript( ScriptLib.GetGameScript() );
      if ( !s )
         {
         gi.dprintf( "StartThread::Null game script\n" );
         return false;
         }
	   pThread = Director.CreateThread( s, thread_name.c_str() );
      if ( pThread )
         {
         if ( start )
            {
            // start right away
            pThread->Start( -1 );
            }
         }
      else
         {
         gi.dprintf( "StartThread::unable to go to %s\n", thread_name.c_str() );
         return NULL;
         }
      return pThread;
      }
   return NULL;
   }

/*
==============
G_ArchiveEdict
==============
*/
void G_ArchiveEdict
   (
   Archiver &arc,
   edict_t *edict
   )

   {
   assert( edict );

   if ( edict->client )
      {
      arc.WriteRaw( edict->client, sizeof( *edict->client ) );
      }

   arc.WriteVector( Vector( edict->s.origin ) );
   arc.WriteVector( Vector( edict->s.angles ) );

   arc.WriteQuat( Quat( edict->s.quat ) );
   arc.WriteQuat( Quat( edict->s.mat ) );
   
   arc.WriteVector( Vector( edict->s.old_origin ) );
   arc.WriteInteger( edict->s.modelindex );
   arc.WriteInteger( edict->s.frame );
   arc.WriteInteger( edict->s.prevframe );

   arc.WriteVector( Vector( edict->s.vieworigin ) );
   arc.WriteVector( Vector( edict->s.viewangles ) );

   arc.WriteInteger( edict->s.anim );
   arc.WriteFloat( edict->s.scale );
   arc.WriteFloat( edict->s.alpha );
   arc.WriteFloat( edict->s.color_r );
   arc.WriteFloat( edict->s.color_g );
   arc.WriteFloat( edict->s.color_b );
   arc.WriteInteger( edict->s.radius );
   arc.WriteRaw( &edict->s.bone, sizeof( edict->s.bone ) );
   arc.WriteInteger( edict->s.parent );
   arc.WriteInteger( edict->s.numgroups );
   arc.WriteRaw( &edict->s.groups, sizeof( edict->s.groups ) );
   arc.WriteInteger( edict->s.gunanim );
   arc.WriteInteger( edict->s.gunframe );
   // index into configstrings
   arc.WriteInteger( edict->s.gunmodelindex );
   arc.WriteInteger( edict->s.lightofs );
   arc.WriteInteger( edict->s.skinnum );
   arc.WriteInteger( edict->s.effects );
   arc.WriteInteger( edict->s.renderfx );
   arc.WriteInteger( edict->s.solid );
   // index into configstrings
   arc.WriteInteger( edict->s.sound );
//   arc.WriteInteger( edict->s.event );

   arc.WriteInteger( edict->svflags );
   arc.WriteVector( Vector( edict->mins ) );
   arc.WriteVector( Vector( edict->maxs ) );
   arc.WriteVector( Vector( edict->absmin ) );
   arc.WriteVector( Vector( edict->absmax ) );
   arc.WriteVector( Vector( edict->size ) );
   arc.WriteVector( Vector( edict->fullmins ) );
   arc.WriteVector( Vector( edict->fullmaxs ) );
   arc.WriteFloat( edict->fullradius );
   arc.WriteVector( Vector( edict->centroid ) );
   arc.WriteInteger( ( int )edict->solid );
   arc.WriteInteger( edict->clipmask );
   if ( edict->owner )
      {
      // s.number may be cleared out, so write the actual number
      arc.WriteInteger( edict->owner - g_edicts );
      }
   else
      {
      arc.WriteInteger( -1 );
      }

   arc.WriteFloat( edict->freetime );
   arc.WriteFloat( edict->spawntime );
   arc.WriteString( str( edict->entname ) );
   }

/*
==============
G_UnarchiveEdict
==============
*/
void G_UnarchiveEdict
   (
   Archiver &arc,
   edict_t *edict
   )

   {
   Vector tempvec;
   str tempstr;
   Quat q;
   int temp;

   assert( edict );

   // 
   // edict will already be setup as far as entnum is concerned
   //
   if ( edict->client )
      {
      arc.ReadRaw( edict->client, sizeof( *edict->client ) );
      }

   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->s.origin );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->s.angles );

   q = arc.ReadQuat();
   edict->s.quat[ 0 ] = q.x;
   edict->s.quat[ 1 ] = q.y;
   edict->s.quat[ 2 ] = q.z;
   edict->s.quat[ 3 ] = q.w;

   q = arc.ReadQuat();
   QuatToMat( q.vec4(), edict->s.mat );

   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->s.old_origin );
   arc.ReadInteger( &edict->s.modelindex );
   arc.ReadInteger( &edict->s.frame );
   arc.ReadInteger( &edict->s.prevframe );

   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->s.vieworigin );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->s.viewangles );

   arc.ReadInteger( &edict->s.anim );
   arc.ReadFloat( &edict->s.scale );
   arc.ReadFloat( &edict->s.alpha );
   arc.ReadFloat( &edict->s.color_r );
   arc.ReadFloat( &edict->s.color_g );
   arc.ReadFloat( &edict->s.color_b );
   arc.ReadInteger( &edict->s.radius );
   arc.ReadRaw( &edict->s.bone, sizeof( edict->s.bone ) );
   arc.ReadInteger( &edict->s.parent );
   arc.ReadInteger( &edict->s.numgroups );
   arc.ReadRaw( &edict->s.groups, sizeof( edict->s.groups ) );
   arc.ReadInteger( &edict->s.gunanim );
   arc.ReadInteger( &edict->s.gunframe );
   // index into configstrings
   arc.ReadInteger( &edict->s.gunmodelindex );
   arc.ReadInteger( &edict->s.lightofs );
   arc.ReadInteger( &edict->s.skinnum );
   arc.ReadInteger( &edict->s.effects );
   arc.ReadInteger( &edict->s.renderfx );
   arc.ReadInteger( &edict->s.solid );
   // index into configstrings
   arc.ReadInteger( &edict->s.sound );
//   arc.ReadInteger( &edict->s.event );

   arc.ReadInteger( &edict->svflags );

   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->mins );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->maxs );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->absmin );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->absmax );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->size );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->fullmins );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->fullmaxs );
   arc.ReadFloat( &edict->fullradius );
   tempvec = arc.ReadVector();
   tempvec.copyTo( edict->centroid );

   edict->solid = ( solid_t )arc.ReadInteger();
   arc.ReadInteger( &edict->clipmask );

   temp = arc.ReadInteger();
   if ( temp < 0 )
      {
      edict->owner = NULL;
      }
   else
      {
      edict->owner = &g_edicts[ temp ];
      }

   arc.ReadFloat( &edict->freetime );
   arc.ReadFloat( &edict->spawntime );
   tempstr = arc.ReadString();
   strcpy( edict->entname, tempstr.c_str() );

   gi.linkentity( edict );
   }

/*
================
G_Milliseconds
================
*/
int G_Milliseconds
   (
   void
   )

   {
#ifdef _WIN32
   static int        base;
   static qboolean   initialized = false;

   if ( !initialized )
      {
      // let base retain 16 bits of effectively random data
      base = timeGetTime() & 0xffff0000;
      initialized = true;
      }

   return timeGetTime() - base;
#else
   //FIXME
   return 0;
#endif
   }

/*
===============
G_DebugPrintf

Outputs a string to the debug window
===============
*/
void G_DebugPrintf
	(
	const char *fmt,
	...
	)

	{
	va_list	argptr;
   char		message[ 1024 ];
	
	va_start( argptr, fmt );
	vsprintf( message, fmt, argptr );
	va_end( argptr );

#ifdef _WIN32
   OutputDebugString( message );
#else
   gi.dprintf( message );
#endif
	}