Renegade/Code/Commando/multihud.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***                            Confidential - Westwood Studios                              ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Commando                                                     *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/Commando/multihud.cpp                        $*
 *                                                                                             *
 *                      $Author:: Byon_g                                                      $*
 *                                                                                             *
 *                     $Modtime:: 2/11/02 6:06p                                               $*
 *                                                                                             *
 *                    $Revision:: 139                                                         $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "multihud.h"

#include <stdio.h>

#include "soldier.h"
#include "assets.h"
#include "wwprofile.h"
#include "playermanager.h"
#include "teammanager.h"
#include "cnetwork.h"
#include "timemgr.h"
#include "miscutil.h"
#include "gamedata.h"
#include "combat.h"
#include "ccamera.h"
#include "gameobjmanager.h"
#include "smartgameobj.h"
#include "vehicle.h"
#include "physcoltest.h"
#include "pscene.h"
#include "phys.h"
#include "damage.h"
#include "movephys.h"
#include "humanphys.h"
#include "weapons.h"
#include "useroptions.h"
#include "devoptions.h"
#include "wwdebug.h"
#include "overlay.h"
#include "spawn.h"
#include "string_ids.h"
#include "translatedb.h"
#include "texture.h"
#include "render2d.h"
#include "render2dsentence.h"
#include "networkobjectmgr.h"
#include "networkobject.h"
#include "building.h"
#include "powerup.h"
#include "staticnetworkobject.h"
#include "widestring.h"
#include "font3d.h"
#include "apppackettypes.h"
#include "bandwidthgraph.h"
#include "priority.h"
#include "consolemode.h"
#include "stylemgr.h"
#include "demosupport.h"

//
// MultiHUDClass statics
//
const float					MultiHUDClass::MAX_OVERLAY_DISTANCE_M		= 50;
const float					MultiHUDClass::Y_INCREMENT_FACTOR			= 1.2f;

#ifdef WWDEBUG
Render2DTextClass	*		MultiHUDClass::PTextRenderer					= NULL;
Font3DInstanceClass *	MultiHUDClass::PFont								= NULL;
#endif

Render2DSentenceClass* MultiHUDClass::NameRenderer					= NULL;
float							MultiHUDClass::BottomTextYPos					= 0;
//bool							MultiHUDClass::VerboseLists					= false;
PlayerlistFormatEnum		MultiHUDClass::PlayerlistFormat				= PLAYERLIST_FORMAT_TINY;
bool							MultiHUDClass::IsOn								= false;

//-----------------------------------------------------------------------------
void MultiHUDClass::Init(void)
{
	WWDEBUG_SAY(("MultiHUDClass::Init\n"));
	if (!ConsoleBox.Is_Exclusive()) {
#ifdef WWDEBUG
		WWASSERT(WW3DAssetManager::Get_Instance() != NULL);
   	PFont = WW3DAssetManager::Get_Instance()->Get_Font3DInstance("FONT6x8.TGA");
   	WWASSERT(PFont != NULL);
		PFont->Set_Mono_Spaced();
		SET_REF_OWNER(PFont);

		PTextRenderer = new Render2DTextClass(PFont);
		PTextRenderer->Set_Coordinate_Range(Render2DClass::Get_Screen_Resolution());
#endif

		NameRenderer = new Render2DSentenceClass;
		StyleMgrClass::Assign_Font(NameRenderer, StyleMgrClass::FONT_INGAME_TXT);
		NameRenderer->Set_Mono_Spaced(true);

		IsOn = true;
	}
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Shutdown(void)
{
	WWDEBUG_SAY(("MultiHUDClass::Shutdown\n"));

	if (NameRenderer) {
		delete NameRenderer;
		NameRenderer = NULL;
	}

#ifdef WWDEBUG
	if (PTextRenderer != NULL) {
		delete PTextRenderer;
		PTextRenderer = NULL;
	}

	if (PFont != NULL) {
		PFont->Release_Ref();
		PFont = NULL;
	}
#endif

	IsOn = false;
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Render_Text(WideStringClass & text, float x, float y, ULONG color)
{
	if (NameRenderer) {
		//
		// Text comes out blurry with the new text system if the text position
		// is non-integral.
		//

		x = cMathUtil::Round(x);
		y = cMathUtil::Round(y);

		NameRenderer->Set_Location(Vector2(x, y));
		NameRenderer->Build_Sentence(text);
		NameRenderer->Draw_Sentence(color);
	}
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Toggle(void)
{
	if (IsOn) {
		Shutdown();
	} else {
		Init();
	}
}

//-----------------------------------------------------------------------------
bool MultiHUDClass::Is_On(void)
{
	return IsOn;
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Render(void)
{
#ifdef WWDEBUG
	if (PTextRenderer != NULL) {
		WWPROFILE("MultiHud Debug Render");
		PTextRenderer->Render();
	}
#endif

	if (NameRenderer != NULL) {
		WWPROFILE("MultiHud Render");
		NameRenderer->Render();
	}
}

//-----------------------------------------------------------------------------
//
// Simple but presumably hugely inefficient code follows
//
void MultiHUDClass::Show_Player_Names(void)
{
	if (NameRenderer == NULL) {
		return;
	}

	WWPROFILE("Show_Player_Name");
   if (GameModeManager::Find("Menu")->Is_Active() ||
		COMBAT_CAMERA == NULL ||
		!cNetwork::I_Am_Client() ||
      cUserOptions::ShowNamesOnSoldier.Is_False()) {

		return;
   }

   //
   // Project name of each player onto his commando
	//

   for (
		SLNode<SmartGameObj> * smart_objnode = GameObjManager::Get_Smart_Game_Obj_List()->Head();
		smart_objnode;
		smart_objnode = smart_objnode->Next()) {

		SmartGameObj * p_smart_obj = smart_objnode->Data();
      WWASSERT(p_smart_obj != NULL);

		//
		// We will eliminate candidates with sequential tests. Want to
		// avoid deep conditional nesting here
		//

		if (p_smart_obj->Is_Delete_Pending()) {
			continue;
      }

      //
		// We are only interested in soldiers
		//
		if (p_smart_obj->As_SoldierGameObj() == NULL) {
			continue;
      }

      //
		// ... living soldiers
		//
		WWASSERT(p_smart_obj->Get_Defense_Object() != NULL);
      float health = p_smart_obj->Get_Defense_Object()->Get_Health();
		if (health < WWMATH_EPSILON) {
			continue;
		}

		//

		// ... with player objects
		//
		cPlayer * p_player = NULL;
      if (p_smart_obj->Has_Player()) {
         p_player = cPlayerManager::Find_Player(p_smart_obj->Get_Control_Owner());
      }
		if (p_player == NULL) {
			continue;
		}

      //
		// Is this guy inside our frustrum?
		//
		Vector3 text_position_3d;
		p_smart_obj->Get_Position(&text_position_3d);
      text_position_3d.Z += 1.3f;

	   Vector3 text_position_2d;
      if (COMBAT_CAMERA->Project(text_position_2d, text_position_3d) != CameraClass::INSIDE_FRUSTUM) {
			continue;
		}

		//
		// Take stealthing into account.
		//
		bool is_stealthed = false;
		SoldierGameObj * p_soldier = p_smart_obj->As_SoldierGameObj();
		WWASSERT(p_soldier != NULL);
		VehicleGameObj * p_vehicle = NULL;
		if (p_soldier->Is_Stealthed()) {
			is_stealthed = true;
		} else {
			p_vehicle = p_soldier->Get_Vehicle();
			if (p_vehicle != NULL && p_vehicle->Is_Stealthed()) {
				is_stealthed = true;
			}
		}

		if (COMBAT_STAR != NULL && p_soldier->Is_Teammate(COMBAT_STAR)) {
			//
			// Don't skip for teammates...
			//
		} else if (is_stealthed) {
			continue;
		}

		//
		// adjust x,y from range -1 to 1
		//
		text_position_2d.X = (text_position_2d.X + 1) * Render2DClass::Get_Screen_Resolution().Width() / 2;
		text_position_2d.Y = (1 - text_position_2d.Y) * Render2DClass::Get_Screen_Resolution().Height() / 2;

      //
		// Is this guy nearby?
		//
		Vector3 ray_start = COMBAT_CAMERA->Get_Transform().Get_Translation();
		Vector3 delta = text_position_3d - ray_start;
		float apparent_distance = delta.Length();
		if (COMBAT_CAMERA->Is_Star_Sniping()) {
			//
			// adjust the apparent distance
			//
			float zoom = COMBAT_CAMERA->Get_Profile_Zoom();
			WWASSERT(zoom > 0);
			apparent_distance /= zoom;
		}
		if (apparent_distance > MAX_OVERLAY_DISTANCE_M) {
			continue;
		}

		if (CombatManager::Is_First_Person() && COMBAT_STAR != NULL) {
			//
			// Ignore collision between ray and own commando
			//
			COMBAT_STAR->Peek_Physical_Object()->Inc_Ignore_Counter();
		}

      //
      // Ok! This guy deserves a ray-cast for visibility...
      //
		Vector3 ray_end = ray_start + delta * 1.1f;
		LineSegClass ray(ray_start, ray_end);
		CastResultStruct res;
		PhysRayCollisionTestClass raytest(ray, &res,
			BULLET_COLLISION_GROUP, COLLISION_TYPE_PHYSICAL);

		{
			WWPROFILE("Cast Ray");
			COMBAT_SCENE->Cast_Ray(raytest);
		}

		if (CombatManager::Is_First_Person() && COMBAT_STAR != NULL) {
			COMBAT_STAR->Peek_Physical_Object()->Dec_Ignore_Counter();
		}

		if (raytest.CollidedPhysObj == NULL) {
			//
			// I think this means that the ray collided with the terrain.
			//
			continue;
		}

		if (raytest.CollidedPhysObj->Get_Observer() == NULL) {
			continue;
		} else {
			PhysicalGameObj * p_blocker = ((CombatPhysObserverClass *)raytest.CollidedPhysObj->Get_Observer())->As_PhysicalGameObj();
	      //if (p_blocker != p_smart_obj) {
	      if ((p_blocker == NULL) || 
				 ((p_blocker != p_smart_obj) && (p_blocker != p_vehicle))) {
			   //
				// The ray failed to collide with the soldier in question
				//
	         continue;
		   }
		}

		//
		// OK, we should go ahead and draw the name
		//

      //
      // Show name text
      //
      if (cUserOptions::ShowNamesOnSoldier.Is_True()) {

			WideStringClass text(0,true);
			text += p_player->Get_Name();

#ifdef WWDEBUG
			if (p_player->Invulnerable.Is_True()) {
				text += L"\n";
				text += TRANSLATE (IDS_MENU_GOD);
			}

			if (p_player->Get_Damage_Scale_Factor() < 100) {
				text += L"\n";
				text += TRANSLATE (IDS_MENU_VIP);
			}
#endif // WWDEBUG

			//
			// MVP carries over into next game
			//
			WWASSERT(The_Game() != NULL);
			WideStringClass mvp_name = The_Game()->Get_Mvp_Name();
			if (!p_player->Get_Name().Compare_No_Case(mvp_name.Peek_Buffer())) {
				text += L"\n";
				text += TRANSLATE(IDS_MP_MVP);
				if (The_Game()->Get_Mvp_Count() > 1) {
					WideStringClass consecutives_text;
					consecutives_text.Format(L" * %d", The_Game()->Get_Mvp_Count());
					text += consecutives_text;
				}
			}

			//
			// WOL game newbies get a "recruit" tag
			//
			if (GameModeManager::Find("WOL")->Is_Active() &&
				 COMBAT_STAR != NULL &&
				 p_soldier->Is_Teammate(COMBAT_STAR) &&
				 p_player->Get_Num_Wol_Games() <= cPlayer::NUM_NEWBIE_GAMES) {

				text += L"\n";
				text += TRANSLATE(IDS_MP_RECRUIT);
			}

			Vector2 textExtent = NameRenderer->Get_Text_Extents(text);
			float x = text_position_2d.X - textExtent.X / 2.0f;
			float y = text_position_2d.Y;

			float scale = (MAX_OVERLAY_DISTANCE_M - apparent_distance) / MAX_OVERLAY_DISTANCE_M;

			int color = (((int)(scale * 255) & 0xFF) << 24) |
				(VRGB_TO_INT32(p_player->Get_Color()) & 0x00FFFFFF);

			Render_Text(text, x, y, color);
      }
   }
}

#ifdef WWDEBUG
//-----------------------------------------------------------------------------
void MultiHUDClass::Render_Debug_Text(LPCSTR text, float x, float y, ULONG color)
{
	//
	// Text comes out blurry with the new text system if the text position
	// is non-integral.
	//

	WWASSERT(text != NULL);

	x = cMathUtil::Round(x);
	y = cMathUtil::Round(y);

	if (PTextRenderer != NULL) {
		WWASSERT(PTextRenderer != NULL);
		PTextRenderer->Set_Location(Vector2(x, y));
		PTextRenderer->Draw_Text(text, color);
	}
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Show_Import_State_Counts(NetworkObjectClass *object)
{
   WWASSERT(object != NULL);

	if (PTextRenderer == NULL) {
		return;
	}

	bool show = false;

	if (cDevOptions::ShowImportStates.Is_True())
	{
		show = true;
	}

	float z_offset = 0;
	if (cDevOptions::ShowImportStatesSV.Is_True() &&
		(object->Get_App_Packet_Type() == APPPACKETTYPE_SOLDIER ||
		 object->Get_App_Packet_Type() == APPPACKETTYPE_VEHICLE))
	{
		z_offset = 1.5f;
		show = true;
	}

   Vector3 text_position_3d;
	if (	show &&
			COMBAT_CAMERA != NULL &&
			object->Get_World_Position (text_position_3d))
	{
      text_position_3d.Z += z_offset;

      Vector3 text_position_2d;
      if (COMBAT_CAMERA->Project(text_position_2d, text_position_3d) == CameraClass::INSIDE_FRUSTUM) {

			text_position_2d.X = (text_position_2d.X + 1) * Render2DClass::Get_Screen_Resolution().Width() / 2;
			text_position_2d.Y = (1 - text_position_2d.Y) * Render2DClass::Get_Screen_Resolution().Height() / 2;

			StringClass text;
			StringClass sub_string;

         if (cNetwork::I_Am_Only_Client()) {
				sub_string.Format("ISC %d\n",  object->Get_Import_State_Count());
				text += sub_string;
         }

			/*
			if (cNetwork::I_Am_Server()) {
				sub_string.Format(" PRI %7.4f\n", object->Get_Cached_Priority ());
				text += sub_string;
			}
			*/

			float x = text_position_2d.X - PTextRenderer->Peek_Font()->String_Width("XXXX XXXXX") / 2.0f;
			float y = text_position_2d.Y;

			int color = 0xFFFFFFFF; // white
         if (object->Get_Import_State_Count() % 2 != 0) {
				color = 0xFF00FF00; // green
			}

			Render_Debug_Text(text, x, y, color);
      }
   }
}



void MultiHUDClass::Show_Distance_And_Priority(NetworkObjectClass *object)
{
   WWASSERT(object != NULL);

	if (PTextRenderer == NULL) {
		return;
	}

	bool show = false;

	if (cDevOptions::ShowPriorities.Is_True()) {
		show = true;
	}

   Vector3 text_position_3d;
	if (show && COMBAT_CAMERA != NULL && object->Get_World_Position (text_position_3d))
	{
      SmartGameObj * player_ptr = GameObjManager::Find_Soldier_Of_Client_ID(cNetwork::Get_My_Id());

		if (player_ptr) {
			Vector3 position;
			player_ptr->Get_Position(&position);
			float priority = cPriority::Compute_Object_Priority(cNetwork::Get_My_Id(), position, object, true);
			float distance = cPriority::Get_Object_Distance(position, object);

      	Vector3 text_position_2d;
      	if (COMBAT_CAMERA->Project(text_position_2d, text_position_3d) == CameraClass::INSIDE_FRUSTUM) {

				text_position_2d.X = (text_position_2d.X + 1) * Render2DClass::Get_Screen_Resolution().Width() / 2;
				text_position_2d.Y = (1 - text_position_2d.Y) * Render2DClass::Get_Screen_Resolution().Height() / 2;

				StringClass text;
				StringClass sub_string;

         	if (cNetwork::I_Am_Only_Client()) {
					sub_string.Format("DIS %.1f\n", distance);
					text += sub_string;
         	}

				StringClass text2;
				StringClass sub_string2;

         	if (cNetwork::I_Am_Only_Client()) {
					sub_string2.Format("PRI %.2f\n", priority);
					text2 += sub_string2;
         	}


				/*
				if (cNetwork::I_Am_Server()) {
					sub_string.Format(" PRI %7.4f\n", object->Get_Cached_Priority ());
					text += sub_string;
				}
				*/

				float x = text_position_2d.X - PTextRenderer->Peek_Font()->String_Width("XXXX XXXXX") / 2.0f;
				float y = text_position_2d.Y;

				int color = 0xFFFFFFFF; // white
         	if (distance < 300.0f) {
					color = 0xFF00FF00; // green
				}

				// Render down a bit so we don't overlap with ISC info.
				Render_Debug_Text(text, x, y+10, color);
				Render_Debug_Text(text2, x, y+20, color);
      	}
		}
   }
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Show_Player_Rhost_Data(SmartGameObj * smart_obj)
{
   WWASSERT(smart_obj != NULL);

	if (PTextRenderer == NULL) {
		return;
	}

	if (cDevOptions::ShowServerRhostData.Is_True() &&
		 cNetwork::I_Am_Server() &&
		 COMBAT_CAMERA != NULL &&
		 smart_obj->Is_Human_Controlled() &&
		 !smart_obj->Is_Delete_Pending()) {

		int controlling_client = smart_obj->Get_Control_Owner();
      cPlayer * p_player = cPlayerManager::Find_Player(controlling_client);
      WWASSERT(p_player != NULL);

		if (!The_Game() || The_Game()->IsDedicated.Is_False()) {
			Vector3 text_position_3d;
      	smart_obj->Get_Position(&text_position_3d);
      	text_position_3d.Z += 1.5f;

      	Vector3 text_position_2d;
      	if (COMBAT_CAMERA->Project(text_position_2d, text_position_3d) == CameraClass::INSIDE_FRUSTUM) {

				text_position_2d.X = (text_position_2d.X + 1) * Render2DClass::Get_Screen_Resolution().Width() / 2;
				text_position_2d.Y = (1 - text_position_2d.Y) * Render2DClass::Get_Screen_Resolution().Height() / 2;

				SoldierGameObj * p_soldier = smart_obj->As_SoldierGameObj();

				if (p_soldier != NULL) {

					cRemoteHost * p_rhost = cNetwork::Get_Server_Rhost(controlling_client);
					WWASSERT(p_rhost != NULL);

					StringClass text;
					StringClass sub_string;

					sub_string.Format( "Id:   %d\n", controlling_client);
					text += sub_string;

					sub_string.Format( "TP:   %-7.4f\n", p_rhost->Get_Threshold_Priority());
					text += sub_string;

					sub_string.Format( "TBps: %d\n", p_rhost->Get_Target_Bps());
					text += sub_string;

					sub_string.Format( "RTMs: %d\n", p_rhost->Get_Resend_Timeout_Ms());
					text += sub_string;

					float x = text_position_2d.X - PTextRenderer->Peek_Font()->String_Width("AAAA: AAAA") / 2.0f;
					float y = text_position_2d.Y;

					Render_Debug_Text(text, x, y);
				}
			}
		} else {

			cRemoteHost * p_rhost = cNetwork::Get_Server_Rhost(controlling_client);
			float x = 20;
			float y = 60 + controlling_client * 10;

			WideStringClass name(p_player->Get_Name(), true);
			StringClass short_name;
			name.Convert_To(short_name);
			int len = name.Get_Length();
			char temp_name[256];
			strcpy(temp_name, short_name.Peek_Buffer());
			strncat(temp_name, "                   ", 13-len);


			StringClass text(temp_name, true);
			StringClass sub_string;

			sub_string.Format( "Id: %03d    ", controlling_client);
			text += sub_string;

			sub_string.Format( "AP:%1.2f    ", p_rhost->Get_Average_Priority());
			text += sub_string;

			sub_string.Format( "BM:%05.2f    ", p_rhost->Get_Bandwidth_Multiplier());
			text += sub_string;

			sub_string.Format( "TBps:%08d  ", p_rhost->Get_Target_Bps());
			text += sub_string;

			sub_string.Format( "RTMs:%05d  ", p_rhost->Get_Resend_Timeout_Ms());
			text += sub_string;

			sub_string.Format( "%05d/%05d/%05d     ", p_rhost->Get_Min_Internal_Pingtime_Ms(), p_rhost->Get_Max_Internal_Pingtime_Ms(), p_rhost->Get_Average_Internal_Pingtime_Ms());
			text += sub_string;

			sub_string.Format( "Rs:%05d ", p_rhost->Get_Total_Resends());
			text += sub_string;

			unsigned long time = TIMEGETTIME() - p_rhost->Get_Creation_Time();
			time = time / 1000;
			sub_string.Format( " Con: %03d.%02d.%02d", time / (60*60), (time / 60) % 60, time % 60);
			text += sub_string;

			Render_Debug_Text(text, x, y);

			if (controlling_client == 1) {

				y = 50;

				StringClass text("Name         ", true);
				StringClass sub_string;

				sub_string.Format( "RHost ID   ");
				text += sub_string;

				sub_string.Format( "Ave Pri    ");
				text += sub_string;

				sub_string.Format( "Band Mult   ");
				text += sub_string;

				sub_string.Format( "Target BPS     ");
				text += sub_string;

				sub_string.Format( "Resend dly  ");
				text += sub_string;

				sub_string.Format( "Min/Max/Ave ping      ");
				text += sub_string;

				sub_string.Format( "Tot rsnds ");
				text += sub_string;

				sub_string.Format( "Duration");
				text += sub_string;

				Render_Debug_Text(text, x, y);
			}
		}
   }
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Show_Client_Rhost_Data(void)
{
	if (PTextRenderer == NULL) {
		return;
	}

   if (cDevOptions::ShowClientRhostData.Is_True() &&
		 cNetwork::I_Am_Client() &&
		 COMBAT_CAMERA != NULL) {

		cRemoteHost * p_rhost = cNetwork::Get_Client_Rhost();

		if (p_rhost != NULL) {

			StringClass text;
			StringClass sub_string;

			sub_string.Format("Id:   %d\n", 0);
			text += sub_string;

			sub_string.Format("TP:   %-7.4f\n", p_rhost->Get_Threshold_Priority());
			text += sub_string;

			sub_string.Format("TBps: %d\n", p_rhost->Get_Target_Bps());
			text += sub_string;

			sub_string.Format("RTMs: %d\n", p_rhost->Get_Resend_Timeout_Ms());
			text += sub_string;

			float x = 20;
			float y = 20;
			Render_Debug_Text(text, x, y);
		}
   }
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Show_Description(NetworkObjectClass * p_object, float height_offset, float max_distance)
{
   WWASSERT(p_object != NULL);
	WWASSERT(max_distance > 0);

	if (PTextRenderer == NULL) {
		return;
	}

   if (COMBAT_CAMERA != NULL &&
		 !p_object->Is_Delete_Pending()) {

      Vector3 text_position_3d;
      if (p_object->Get_World_Position(text_position_3d)) {
			text_position_3d.Z += height_offset;

			Vector3 ray_start = COMBAT_CAMERA->Get_Transform().Get_Translation();
			Vector3 delta = text_position_3d - ray_start;

			Vector3 text_position_2d;
			if (delta.Length() < max_distance &&
				COMBAT_CAMERA->Project(text_position_2d, text_position_3d) == CameraClass::INSIDE_FRUSTUM) {

				text_position_2d.X = (text_position_2d.X + 1) * Render2DClass::Get_Screen_Resolution().Width() / 2;
				text_position_2d.Y = (1 - text_position_2d.Y) * Render2DClass::Get_Screen_Resolution().Height() / 2;

				float x = text_position_2d.X;
				float y = text_position_2d.Y;

				StringClass description;
				p_object->Get_Description(description);

				if (!description.Is_Empty()) {
					float scale = (max_distance - delta.Length()) / max_distance;
					int color = (((int)(scale * 255) & 0xFF) << 24) | 0x00FFFFFF;

					Render_Debug_Text(description, x, y, color);
				}
			}
		}
   }
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Show_Spawner_Data(void)
{
	if (PTextRenderer == NULL) {
		return;
	}

	if (COMBAT_CAMERA != NULL && cDevOptions::ShowSpawnerData.Is_True()) {

		DynamicVectorClass<SpawnerClass*> spawner_list = SpawnManager::Get_Spawner_List();

		for (int i = 0; i < spawner_list.Count(); i++) {

			WWASSERT(spawner_list[i] != NULL);
			Vector3 text_position_3d;
			spawner_list[i]->Get_TM().Get_Translation(&text_position_3d);
			text_position_3d.Z += 1.0f;

			Vector3 text_position_2d;
			if (COMBAT_CAMERA->Project(text_position_2d, text_position_3d) == CameraClass::INSIDE_FRUSTUM) {

				char text[300];
				::strcpy(text, spawner_list[i]->Get_Definition().Get_Name());

				text_position_2d.X = (text_position_2d.X + 1) * Render2DClass::Get_Screen_Resolution().Width() / 2;
				text_position_2d.Y = (1 - text_position_2d.Y) * Render2DClass::Get_Screen_Resolution().Height() / 2;

				float x = text_position_2d.X - PTextRenderer->Peek_Font()->String_Width(text) / 2.0f;
				float y = text_position_2d.Y;

				Render_Debug_Text(text, x, y);
			}
		}
	}
}
#endif // WWDEBUG

//-----------------------------------------------------------------------------
void MultiHUDClass::Think(void)
{
#ifdef WWDEBUG
	if (PTextRenderer == NULL) {
		return;
	}
#endif

	if (NameRenderer == NULL) {
		return;
	}

	WWPROFILE("MultiHud Think");

#ifdef WWDEBUG
	PTextRenderer->Reset();
#endif

	NameRenderer->Reset();

	DEMO_SECURITY_CHECK;

	if (!GameModeManager::Find("Combat")->Is_Active() ||
		  GameModeManager::Find("Menu")->Is_Active()) {
		return;
	}

   Show_Player_Names();

//	BottomTextYPos = Render2DClass::Get_Screen_Resolution().Bottom - 15;

	//
	// From here down its all diagnostics
	//

#ifdef WWDEBUG

	//
	//	Loop over each network object
	//
	int count = NetworkObjectMgrClass::Get_Object_Count ();
	for (int index = 0; index < count; index ++) {
		NetworkObjectClass *object = NetworkObjectMgrClass::Get_Object (index);

		//
		//	Display the import state count and priority for each object
		//
		Show_Import_State_Counts (object);
		Show_Distance_And_Priority(object);

	}

	{
	int count = StaticNetworkObjectClass::Get_Static_Network_Object_Count ();
	for (int index = 0; index < count; index ++) {

		StaticNetworkObjectClass * p_object = (StaticNetworkObjectClass * ) StaticNetworkObjectClass::Get_Static_Network_Object (index);
		WWASSERT(p_object != NULL);

		if (
			(p_object->As_Door_Network_Object_Class() != NULL && cDevOptions::ShowDoorData.Is_True()) ||
			(p_object->As_Elevator_Network_Object_Class() != NULL && cDevOptions::ShowElevatorData.Is_True()) ||
			(p_object->As_DSAPO_Network_Object_Class() != NULL && cDevOptions::ShowDSAPOData.Is_True())) {

			Show_Description(p_object, 0, 20);
		}
	}
	}

	//
	// Traverse objects and show pertinent diagnostics
	//
	SLNode<BaseGameObj> * objnode;
	for (objnode = GameObjManager::Get_Game_Obj_List()->Head(); objnode; objnode = objnode->Next()) {
		WWASSERT(objnode->Data() != NULL);
      PhysicalGameObj * p_phys_obj = objnode->Data()->As_PhysicalGameObj();

		if (p_phys_obj != NULL) {

			SmartGameObj * p_smart_obj = p_phys_obj->As_SmartGameObj();

			if (p_smart_obj != NULL) {
				Show_Player_Rhost_Data(p_smart_obj);

            if (cDevOptions::ShowSoldierData.Is_True()) {
					SoldierGameObj * p_soldier = p_smart_obj->As_SoldierGameObj();
					if (p_soldier != NULL) {
						Show_Description(p_soldier, 1.5f, 20);
					}
				}

            if (cDevOptions::ShowVehicleData.Is_True()) {
					VehicleGameObj * p_vehicle = p_smart_obj->As_VehicleGameObj();
					if (p_vehicle != NULL) {
						Show_Description(p_vehicle, 1.5f, 20);
					}
				}
			}

         if (cDevOptions::ShowPowerupData.Is_True()) {
				if (p_phys_obj->As_SimpleGameObj() != NULL) {
					PowerUpGameObj * p_powerup = p_phys_obj->As_SimpleGameObj()->As_PowerUpGameObj();
					if (p_powerup != NULL) {
						Show_Description(p_powerup, 0, 20);
					}
				}
			}
		}

      if (cDevOptions::ShowBuildingData.Is_True()) {
			if (objnode->Data()->As_ScriptableGameObj() != NULL) {
				BuildingGameObj * p_building = objnode->Data()->As_ScriptableGameObj()->As_BuildingGameObj();
				if (p_building != NULL) {
					Show_Description(p_building, 0, 100);
				}
			}
		}
	}

	Show_Spawner_Data();

	Show_Client_Rhost_Data();

//#endif // WWDEBUG

	//BottomTextYPos = Render2DClass::Get_Screen_Resolution().Bottom - 15;

//#ifdef WWDEBUG
   cNetwork::Set_Graphing_Y(64);
	//cNetwork::Watch_Bandwidth(PTextRenderer);
	cNetwork::Watch_Latency(PTextRenderer);
	cNetwork::Watch_Last_Contact(PTextRenderer);
	cNetwork::Watch_Packets(PTextRenderer);
	cNetwork::Watch_Size_Lists(PTextRenderer);
	cNetwork::Watch_Time_Lists(PTextRenderer);
	cNetwork::Watch_Packet_Size_Lists(PTextRenderer);
	cNetwork::Simulation_Warnings(PTextRenderer);

	cBandwidthGraph::Think();
#endif
}

//-----------------------------------------------------------------------------
void MultiHUDClass::Next_Playerlist_Format(void)
{
	switch (PlayerlistFormat) {
		case PLAYERLIST_FORMAT_TINY:
			PlayerlistFormat = PLAYERLIST_FORMAT_MEDIUM;
			break;

		case PLAYERLIST_FORMAT_MEDIUM:
			PlayerlistFormat = PLAYERLIST_FORMAT_FULL;
			break;

		case PLAYERLIST_FORMAT_FULL:
			PlayerlistFormat = PLAYERLIST_FORMAT_TINY;
			break;

		default:
			DIE;
			break;
	}
}