mirror of
https://github.com/ENSL/NS.git
synced 2024-12-11 05:11:27 +00:00
d995257c31
git-svn-id: https://unknownworlds.svn.cloudforge.com/ns1@282 67975925-1194-0748-b3d5-c16f83f1a3a1
7049 lines
190 KiB
C++
7049 lines
190 KiB
C++
//======== (C) Copyright 2001 Charles G. Cleveland All rights reserved. =========
|
|
//
|
|
// The copyright to the contents herein is the property of Charles G. Cleveland.
|
|
// The contents may be used and/or copied only with the written permission of
|
|
// Charles G. Cleveland, or in accordance with the terms and conditions stipulated in
|
|
// the agreement/contract under which the contents have been supplied.
|
|
//
|
|
// Purpose: Main NS NUD, also interface to client network messages
|
|
//
|
|
// $Workfile: AvHHud.cpp $
|
|
// $Date: 2002/10/28 20:35:32 $
|
|
//
|
|
//-------------------------------------------------------------------------------
|
|
// $Log: AvHHud.cpp,v $
|
|
// Revision 1.70 2002/10/28 20:35:32 Flayra
|
|
// - Fix for gamma reset with VAC
|
|
// - Info location fix after changelevel
|
|
//
|
|
// Revision 1.69 2002/10/25 21:49:10 Flayra
|
|
// - Updated skin to sit in pev->skin
|
|
// - Reset components every tick to fix problem with disappearing team resource label
|
|
//
|
|
// Revision 1.68 2002/10/24 21:29:49 Flayra
|
|
// - Moved help client-side
|
|
// - Fixed particle/changelevel crash
|
|
// - Reworked marine upgrade drawing
|
|
// - Added lots of utility functions for help system (mirrors functions on server)
|
|
// - Removed gamma message unless it failed or if maxplayers is 1
|
|
// - Fixed alien hive sight crash
|
|
// - Show players under reticle while in ready room and spectating
|
|
// - Removed ugly/too-prevalent user3 icons
|
|
//
|
|
// Revision 1.67 2002/10/18 22:19:49 Flayra
|
|
// - Added alien easter egg sayings
|
|
//
|
|
// Revision 1.66 2002/10/16 20:53:41 Flayra
|
|
// - Draw scan model specially so it looks right
|
|
//
|
|
// Revision 1.65 2002/10/16 00:58:02 Flayra
|
|
// - Removed hotgroups
|
|
// - Added "need order" alert
|
|
//
|
|
// Revision 1.64 2002/10/03 20:24:39 Flayra
|
|
// - Changes for "more resources required"
|
|
//
|
|
// Revision 1.63 2002/10/03 18:54:30 Flayra
|
|
// - Allow right-click to cancel building placement
|
|
// - Fixed help icons
|
|
// - Added a couple utility functions
|
|
// - Reworked order notification
|
|
// - Reworked blip network messages to avoid hard-coded limit
|
|
// - Sent max resources down with current resources
|
|
// - Countdown sound no longer prevents other hud sounds
|
|
// - Alien trigger sounds
|
|
// - New order sounds
|
|
// - No longer disable nodes out of our cost range
|
|
//
|
|
// Revision 1.62 2002/09/25 20:47:19 Flayra
|
|
// - Don't draw elements on HUD when dead
|
|
// - UI refactoring
|
|
// - Split reticle help into help text and reticle text
|
|
// - Removed use order
|
|
// - Added separate select sound for alien
|
|
// - Multiple move sounds
|
|
// - Only draw entity build/health status when under reticle (no more scanning around you)
|
|
// - Added 3 new sayings
|
|
//
|
|
// Revision 1.61 2002/09/23 22:18:25 Flayra
|
|
// - Added alien build circles
|
|
// - Game status changes so particles aren't sent every time
|
|
// - Demo playback changes (save restore basic data that HUD already has)
|
|
// - New alert sounds
|
|
// - Skin support
|
|
//
|
|
// Revision 1.60 2002/09/09 19:55:24 Flayra
|
|
// - Added hive info indicator
|
|
// - Fixed bug where reticle tooltip help text wasn't being set until a weapon was selected
|
|
// - Fixed release mode bug where tooltips weren't expiring
|
|
// - Fixed bug where marine upgrades blinked
|
|
// - "No commander" indicator now blinks
|
|
//
|
|
// Revision 1.59 2002/08/31 18:01:01 Flayra
|
|
// - Work at VALVe
|
|
//
|
|
// Revision 1.58 2002/08/16 02:37:49 Flayra
|
|
// - HUD sounds no longer cut each other off (they won't play instead of cutting off another sound)
|
|
// - Tooltip sounds
|
|
// - Selection issues
|
|
// - Draw rings around buildings that need to be built
|
|
// - Removed old overwatch code
|
|
//
|
|
// Revision 1.57 2002/08/09 01:02:40 Flayra
|
|
// - Added hooks for demo playback, removed prediction selection
|
|
//
|
|
// Revision 1.56 2002/08/02 21:59:12 Flayra
|
|
// - Added reticle help, new tooltip system and much nicer order drawing! Refactored view model drawing a bit, hoping to make texture blending work for it.
|
|
//
|
|
// Revision 1.55 2002/07/26 23:05:01 Flayra
|
|
// - Generate numerical feedback for damage events
|
|
// - Refactoring for more info when looking at something (instead of bad-looking player names only)
|
|
//
|
|
// Revision 1.54 2002/07/24 18:45:41 Flayra
|
|
// - Linux and scripting changes
|
|
//
|
|
// Revision 1.53 2002/07/23 17:07:36 Flayra
|
|
// - Added visually-smooth energy level, added versatile location code, new hive sight info, refactored to remove extra sprites (128 HUD sprites bug), commander tech help fixes
|
|
//
|
|
// Revision 1.52 2002/07/10 14:41:55 Flayra
|
|
// - Fixed bug where non-sighted particle systems weren't being drawn for players on the ground (bug #127)
|
|
//
|
|
// Revision 1.51 2002/07/08 17:07:56 Flayra
|
|
// - Started to add display of marine upgrade sprite, fixed bug where building indicators aren't displayed after a map change, info_location drawing changes, primal scream color tweak, removed old hive drawing code
|
|
//
|
|
// Revision 1.50 2002/07/01 21:35:05 Flayra
|
|
// - Removed lots of outdated sprites and sprite code, added building ranges, fixed ghost building problem (bug #82)
|
|
//
|
|
// Revision 1.49 2002/06/25 18:03:09 Flayra
|
|
// - Added info_locations, removed old weapon help system, added smooth resource swelling, lots of alien UI usability changes, fixed problem with ghost building
|
|
//
|
|
// Revision 1.48 2002/06/10 19:55:36 Flayra
|
|
// - New commander UI (bindable via hotkeys, added REMOVE_SELECTION for when clicking menu options when no players selected)
|
|
//
|
|
// Revision 1.47 2002/06/03 16:48:45 Flayra
|
|
// - Help sprites moved into one animated sprite, select sound volume reduced (now that sound is normalized)
|
|
//
|
|
// Revision 1.46 2002/05/28 17:48:14 Flayra
|
|
// - Minimap refactoring, reinforcement refactoring, new hive sight fixes, recycling support
|
|
//
|
|
// Revision 1.45 2002/05/23 02:33:42 Flayra
|
|
// - Post-crash checkin. Restored @Backup from around 4/16. Contains changes for last four weeks of development.
|
|
//
|
|
//===============================================================================
|
|
#include "mod/AvHConstants.h"
|
|
#include "mod/AvHHud.h"
|
|
#include "cl_dll/hud.h"
|
|
#include "cl_dll/cl_util.h"
|
|
#include "vgui_label.h"
|
|
#include "ui/PieMenu.h"
|
|
#include "mod/AvHTeamHierarchy.h"
|
|
#include "mod/AvHPieMenuHandler.h"
|
|
#include "mod/AvHParticleTemplateClient.h"
|
|
#include "mod/AvHParticleSystemManager.h"
|
|
#include "mod/AvHClientVariables.h"
|
|
#include "mod/AvHSpecials.h"
|
|
#include "ui/FadingImageLabel.h"
|
|
#include "mod/AvHScrollHandler.h"
|
|
#include "mod/AvHEvents.h"
|
|
#include "pm_shared/pm_shared.h"
|
|
#include "common/cl_entity.h"
|
|
#include "mod/AvHCommanderModeHandler.h"
|
|
#include "mod/AvHParticleEditorHandler.h"
|
|
#include "mod/AvHTechTree.h"
|
|
#include "mod/AvHMovementUtil.h"
|
|
#include "mod/AvHTitles.h"
|
|
#include "mod/AvHSelectionHelper.h"
|
|
#include "mod/AvHActionButtons.h"
|
|
#include "pm_shared/pm_debug.h"
|
|
#include "util/MathUtil.h"
|
|
#include "util/STLUtil.h"
|
|
#include "mod/AvHSharedUtil.h"
|
|
#include "common/r_efx.h"
|
|
#include "cl_dll/eventscripts.h"
|
|
#include <stdlib.h>
|
|
#include "mod/AvHSprites.h"
|
|
#include "ui/UIUtil.h"
|
|
#include "mod/AvHMiniMap.h"
|
|
#include "types.h"
|
|
#include <signal.h>
|
|
#include "common/event_api.h"
|
|
#include "mod/AvHHulls.h"
|
|
#include "common/com_model.h"
|
|
#include "mod/AvHBasePlayerWeaponConstants.h"
|
|
#include "cl_dll/vgui_ScorePanel.h"
|
|
#include "mod/AvHAlienAbilityConstants.h"
|
|
#include "mod/AvHSharedUtil.h"
|
|
#include "mod/AvHScriptManager.h"
|
|
#include "mod/AvHHudConstants.h"
|
|
#include "cl_dll/demo.h"
|
|
#include "common/demo_api.h"
|
|
#include "cl_dll/ammohistory.h"
|
|
#include "mod/AvHTechImpulsePanel.h"
|
|
#include "mod/AvHServerVariables.h"
|
|
#include "mod/AvHPlayerUpgrade.h"
|
|
#include "mod/AvHCommandConstants.h"
|
|
#include "mod/AvHDebugUtil.h"
|
|
#include "engine/keydefs.h"
|
|
#include "ui/ChatPanel.h"
|
|
#include "cl_dll/r_studioint.h"
|
|
#include "util/Tokenizer.h"
|
|
#include <sstream>
|
|
#include "mod/AvHNetworkMessages.h"
|
|
|
|
// SCRIPTENGINE:
|
|
#include "scriptengine/AvHLUA.h"
|
|
#include "scriptengine/AvHLUAUtil.h"
|
|
// :SCRIPTENGINE
|
|
|
|
//#include "cl_dll/studio_util.h"
|
|
//#include "cl_dll/r_studioint.h"
|
|
|
|
void IN_GetMousePos( int *mx, int *my );
|
|
extern playermove_t *pmove;
|
|
void RemoveAllDecals();
|
|
void ScorePanel_InitializeDemoRecording();
|
|
|
|
// Include windows for GDI and gamma functions
|
|
#include "windows.h"
|
|
|
|
extern engine_studio_api_t IEngineStudio;
|
|
|
|
AvHPieMenuHandler gPieMenuHandler;
|
|
AvHScrollHandler gScrollHandler;
|
|
AvHCommanderModeHandler gCommanderHandler;
|
|
AvHParticleEditorHandler gParticleEditorHandler;
|
|
extern AvHParticleTemplateListClient gParticleTemplateList;
|
|
extern DebugPointListType gTriDebugLocations;
|
|
extern extra_player_info_t g_PlayerExtraInfo[MAX_PLAYERS+1];
|
|
extern WeaponsResource gWR;
|
|
|
|
extern double gClientTimeLastUpdate;
|
|
extern "C" Vector gPredictedPlayerOrigin;
|
|
extern "C" Vector gPredictedPlayerVOfs;
|
|
extern void __CmdFunc_Close(void);
|
|
extern int CL_ButtonBits(int);
|
|
extern int g_iVisibleMouse;
|
|
|
|
GammaTable AvHHud::sPregameGammaTable;
|
|
GammaTable AvHHud::sGameGammaTable;
|
|
|
|
bool AvHHud::sShowMap = false;
|
|
|
|
// Global because of global HUD complilation error
|
|
AvHMiniMap gMiniMap;
|
|
|
|
#include "VGUI_RepaintSignal.h"
|
|
|
|
//extern vec3_t v_origin;
|
|
//extern vec3_t v_angles;
|
|
//vec3_t gPlayerOrigin;
|
|
//vec3_t gPlayerAngles;
|
|
|
|
extern AvHSelectionHelper gSelectionHelper;
|
|
|
|
//#if defined( AVH_CLIENT )
|
|
//extern "C" float gOverwatchTargetRange;
|
|
extern float gOverwatchTargetRange;
|
|
//#endif
|
|
|
|
extern bool gResetViewAngles;
|
|
extern vec3_t gViewAngles;
|
|
extern char sDebugString[128];
|
|
|
|
float kOverwatchFlashInterval = 2.5f;
|
|
const float kReticleInfoMaxAlpha = 50;
|
|
int gVisibleMouse = 0;
|
|
|
|
//voogru: cvar pointers, these should always remain valid once they are set.
|
|
|
|
cvar_t *gl_monolights = NULL;
|
|
cvar_t *gl_overbright = NULL;
|
|
cvar_t *gl_clear = NULL;
|
|
cvar_t *hud_draw = NULL;
|
|
cvar_t *r_drawviewmodel = NULL;
|
|
extern cvar_t *cl_movespeedkey;
|
|
cvar_t *gl_d3dflip = NULL;
|
|
cvar_t *s_show = NULL;
|
|
cvar_t *lightgamma = NULL;
|
|
cvar_t *r_detailtextures = NULL;
|
|
|
|
const AvHMapExtents& GetMapExtents()
|
|
{
|
|
return gHUD.GetMapExtents();
|
|
}
|
|
|
|
NumericalInfoEffect::NumericalInfoEffect(float inPosition[3], float inNumber, int inEventType, float inTimeCreated)
|
|
{
|
|
this->mPosition[0] = inPosition[0];
|
|
this->mPosition[1] = inPosition[1];
|
|
this->mPosition[2] = inPosition[2];
|
|
|
|
this->mNumber = inNumber;
|
|
this->mEventType = inEventType;
|
|
|
|
this->mTimeCreated = inTimeCreated;
|
|
}
|
|
|
|
void NumericalInfoEffect::GetPosition(float* outPosition) const
|
|
{
|
|
outPosition[0] = this->mPosition[0];
|
|
outPosition[1] = this->mPosition[1];
|
|
outPosition[2] = this->mPosition[2];
|
|
}
|
|
|
|
float NumericalInfoEffect::GetNumber() const
|
|
{
|
|
return this->mNumber;
|
|
}
|
|
|
|
int NumericalInfoEffect::GetEventType() const
|
|
{
|
|
return this->mEventType;
|
|
}
|
|
|
|
float NumericalInfoEffect::GetTimeCreated() const
|
|
{
|
|
return this->mTimeCreated;
|
|
}
|
|
|
|
void NumericalInfoEffect::SetPosition(float inPosition[3])
|
|
{
|
|
this->mPosition[0] = inPosition[0];
|
|
this->mPosition[1] = inPosition[1];
|
|
this->mPosition[2] = inPosition[2];
|
|
}
|
|
|
|
void AvHHud::OnActivateSteamUI()
|
|
{
|
|
// Set the normal gamma so the Steam UI looks correct.
|
|
sPregameGammaTable.InitializeToVideoState();
|
|
mSteamUIActive = true;
|
|
}
|
|
|
|
void AvHHud::OnDeactivateSteamUI()
|
|
{
|
|
|
|
// Set the special NS gamma.
|
|
SetGamma(mDesiredGammaSlope);
|
|
mSteamUIActive = false;
|
|
|
|
// The Steam UI screws up the mouse cursor so reset it.
|
|
if (gViewPort != NULL)
|
|
{
|
|
gViewPort->UpdateCursorState();
|
|
}
|
|
|
|
}
|
|
|
|
void AvHHud::OnLostFocus()
|
|
{
|
|
sPregameGammaTable.InitializeToVideoState();
|
|
}
|
|
|
|
bool AvHHud::OnKeyEvent(int virtualKey, int scanCode, bool pressed)
|
|
{
|
|
|
|
if (gViewPort != NULL && !mSteamUIActive)
|
|
{
|
|
|
|
ChatPanel* theChatPanel = gViewPort->GetChatPanel();
|
|
|
|
if (theChatPanel && theChatPanel->isVisible())
|
|
{
|
|
if (pressed)
|
|
{
|
|
theChatPanel->KeyDown(virtualKey, scanCode);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// If the key wasn't pressed while the chat window was open,
|
|
// the key up needs to go to HL.
|
|
return theChatPanel->WasKeyPushed(virtualKey);
|
|
}
|
|
}
|
|
|
|
if (virtualKey == VK_ESCAPE && GetInTopDownMode() && mGhostBuilding != MESSAGE_NULL)
|
|
{
|
|
if (pressed)
|
|
{
|
|
CancelBuilding();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
int AvHHud::GetGameTime() const
|
|
{
|
|
int theGameTime = 0;
|
|
|
|
if(this->mGameTime > 0)
|
|
{
|
|
theGameTime = (int)(this->mGameTime);
|
|
}
|
|
|
|
return theGameTime;
|
|
}
|
|
|
|
int AvHHud::GetGameTimeLimit() const
|
|
{
|
|
return this->mTimeLimit;
|
|
}
|
|
|
|
int AvHHud::GetCombatAttackingTeamNumber() const
|
|
{
|
|
return this->mCombatAttackingTeamNumber;
|
|
}
|
|
|
|
bool AvHHud::GetShowingMap()
|
|
{
|
|
return sShowMap;
|
|
}
|
|
|
|
bool AvHHud::GetGameStarted() const
|
|
{
|
|
return (this->mGameTime >= 0) && !this->mGameEnded;
|
|
}
|
|
|
|
bool AvHHud::GetIsAlive(bool inIncludeSpectating) const
|
|
{
|
|
bool theIsAlive = false;
|
|
|
|
cl_entity_s* thePlayer = gEngfuncs.GetLocalPlayer();
|
|
if(inIncludeSpectating)
|
|
{
|
|
thePlayer = this->GetVisiblePlayer();
|
|
}
|
|
|
|
if(thePlayer)
|
|
{
|
|
int thePlayerIndex = thePlayer->index;
|
|
if((thePlayerIndex) && (thePlayerIndex <= MAX_PLAYERS))
|
|
{
|
|
int thePlayerClass = g_PlayerExtraInfo[thePlayerIndex].playerclass;
|
|
switch(thePlayerClass)
|
|
{
|
|
case PLAYERCLASS_ALIVE_MARINE:
|
|
case PLAYERCLASS_ALIVE_HEAVY_MARINE:
|
|
case PLAYERCLASS_ALIVE_JETPACK_MARINE:
|
|
case PLAYERCLASS_ALIVE_LEVEL1:
|
|
case PLAYERCLASS_ALIVE_LEVEL2:
|
|
case PLAYERCLASS_ALIVE_LEVEL3:
|
|
case PLAYERCLASS_ALIVE_LEVEL4:
|
|
case PLAYERCLASS_ALIVE_LEVEL5:
|
|
case PLAYERCLASS_ALIVE_DIGESTING:
|
|
case PLAYERCLASS_ALIVE_GESTATING:
|
|
case PLAYERCLASS_COMMANDER:
|
|
theIsAlive = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return theIsAlive;
|
|
}
|
|
|
|
bool GetIsWithinRegion(float inNormX, float inNormY, float inLowX, float inLowY, float inHighX, float inHighY)
|
|
{
|
|
bool inRegion = false;
|
|
|
|
if((inNormX >= inLowX) && (inNormY >= inLowY) && (inNormX <= inHighX) && (inNormY < inHighY))
|
|
{
|
|
inRegion = true;
|
|
}
|
|
|
|
return inRegion;
|
|
}
|
|
|
|
bool AvHHud::GetIsRegionBlockedByUI(float inNormX, float inNormY)
|
|
{
|
|
bool theIsBlocked = true;
|
|
|
|
if( GetIsWithinRegion(inNormX, inNormY, 0, .061, .3017, .6797) ||
|
|
GetIsWithinRegion(inNormX, inNormY, .248, .0791, .7753, .6823) ||
|
|
GetIsWithinRegion(inNormX, inNormY, .748, .092, 1, .6575) ||
|
|
GetIsWithinRegion(inNormX, inNormY, .751, .645, .870, .678) ||
|
|
GetIsWithinRegion(inNormX, inNormY, .337, .679, .729, .754) ||
|
|
GetIsWithinRegion(inNormX, inNormY, .337, .717, .703, .823) )
|
|
{
|
|
theIsBlocked = false;
|
|
|
|
// Now check pending requests (the only HUD element not drawn as part of the outlying frame
|
|
for(PendingRequestListType::const_iterator theIterator = this->mPendingRequests.begin(); theIterator != this->mPendingRequests.end(); theIterator++)
|
|
{
|
|
AvHMessageID theMessageID = theIterator->first;
|
|
char theComponentName[256];
|
|
sprintf(theComponentName, kPendingImpulseSpecifier, (int)theMessageID);
|
|
|
|
AvHTechImpulsePanel* theTechImpulsePanel = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(theComponentName, theTechImpulsePanel))
|
|
{
|
|
int thePosX, thePosY;
|
|
theTechImpulsePanel->getPos(thePosX, thePosY);
|
|
|
|
int theWidth, theHeight;
|
|
theTechImpulsePanel->getSize(theWidth, theHeight);
|
|
|
|
int theHighX = thePosX + theWidth;
|
|
int theHighY = thePosY + theHeight;
|
|
|
|
float theScreenWidth = ScreenWidth();
|
|
float theScreenHeight = ScreenHeight();
|
|
|
|
if(GetIsWithinRegion(inNormX, inNormY, thePosX/theScreenWidth, thePosY/theScreenHeight, theHighX/theScreenWidth, theHighY/theScreenHeight))
|
|
{
|
|
theIsBlocked = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return theIsBlocked;
|
|
}
|
|
|
|
bool AvHHud::GetIsShowingMap() const
|
|
{
|
|
return sShowMap;
|
|
}
|
|
|
|
void AvHHud::ClearSelection()
|
|
{
|
|
gSelectionHelper.ClearSelection();
|
|
this->mGroupEvent = COMMANDER_REMOVESELECTION;
|
|
}
|
|
|
|
|
|
void CLinkGhostBuildingCallback( struct tempent_s *ent, float frametime, float currenttime)
|
|
{
|
|
gHUD.GhostBuildingCallback(ent, frametime, currenttime);
|
|
}
|
|
|
|
// For easily adding message functions
|
|
#define BIND_MESSAGE(x) \
|
|
int __MsgFunc_##x(const char *pszName, int iSize, void *pbuf) \
|
|
{ \
|
|
return gHUD.##x(pszName, iSize, pbuf ); \
|
|
}
|
|
|
|
AvHHud::AvHHud(const string& inFilename, UIFactory* inFactory) : UIHud(inFilename, inFactory)
|
|
{
|
|
this->ClearData();
|
|
mSteamUIActive = false;
|
|
}
|
|
|
|
void AvHHud::AddNumericalInfoMessage(float inOrigin[3], float inNumber, int inEventType)
|
|
{
|
|
NumericalInfoEffect theEffect(inOrigin, inNumber, inEventType, this->mTimeOfLastUpdate);
|
|
this->mNumericalInfoEffects.push_back(theEffect);
|
|
}
|
|
|
|
void AvHHud::AddTooltip(const char* inMessageText, bool inIsToolTip, float inTooltipWidth)
|
|
{
|
|
if(!gEngfuncs.pDemoAPI->IsPlayingback() && (strlen(inMessageText) > 0))
|
|
{
|
|
if(gEngfuncs.pfnGetCvarFloat(kvAutoHelp) || !inIsToolTip)
|
|
{
|
|
AvHTooltip theNewTooltip;
|
|
|
|
theNewTooltip.SetText(string(inMessageText));
|
|
theNewTooltip.SetNormalizedScreenX(1.0f - inTooltipWidth - kHelpMessageLeftEdgeInset);
|
|
theNewTooltip.SetNormalizedScreenY(0.01f);
|
|
theNewTooltip.SetCentered(false);
|
|
theNewTooltip.SetIgnoreFadeForLifetime(true);
|
|
theNewTooltip.SetNormalizedMaxWidth(inTooltipWidth);
|
|
|
|
if(inIsToolTip)
|
|
{
|
|
this->PlayHUDSound(HUD_SOUND_TOOLTIP);
|
|
}
|
|
|
|
this->mTooltips.push_back(theNewTooltip);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool AvHHud::AddTooltipOnce(const char* inMessageText, bool inIsToolTip)
|
|
{
|
|
bool theAddedTooltip = false;
|
|
|
|
string theMessage(inMessageText);
|
|
|
|
// Check if message is in sent list
|
|
StringList::iterator theIter = std::find(this->mDisplayedToolTipList.begin(), this->mDisplayedToolTipList.end(), theMessage);
|
|
if(theIter == this->mDisplayedToolTipList.end())
|
|
{
|
|
// If not
|
|
// Call AddTooltip
|
|
this->AddTooltip(inMessageText, inIsToolTip);
|
|
theAddedTooltip = true;
|
|
|
|
// Add message to list
|
|
this->mDisplayedToolTipList.push_back(theMessage);
|
|
}
|
|
|
|
return theAddedTooltip;
|
|
}
|
|
|
|
|
|
void AvHHud::Cancel(void)
|
|
{
|
|
ASSERT(this->mInTopDownMode);
|
|
gCommanderHandler.CancelHit();
|
|
}
|
|
|
|
void AvHHud::ClearData()
|
|
{
|
|
this->mResources = 0;
|
|
|
|
this->mHierarchy = NULL;
|
|
this->mShowMapHierarchy = NULL;
|
|
|
|
this->mCommanderResourceLabel = NULL;
|
|
this->mGenericProgressBar = NULL;
|
|
this->mResearchProgressBar = NULL;
|
|
this->mAlienProgressBar = NULL;
|
|
this->mResearchLabel = NULL;
|
|
//this->mArmorLevel = ARMOR_BASE;
|
|
this->mTimeOfLastUpdate = 0.0;
|
|
this->mTimeOfNextHudSound = -1;
|
|
this->mLastHUDSoundPlayed = HUD_SOUND_INVALID;
|
|
this->mTimeOfLastEntityUpdate = -1;
|
|
this->mInTopDownMode = false;
|
|
this->mLeftMouseStarted = false;
|
|
this->mLeftMouseEnded = false;
|
|
this->mPlacingBuilding = false;
|
|
this->mRightMouseStarted = false;
|
|
this->mRightMouseEnded = false;
|
|
//this->mOrderMode = ORDERTYPE_UNDEFINED;
|
|
this->mTechEvent = MESSAGE_NULL;
|
|
this->mAlienAbility = MESSAGE_NULL;
|
|
this->mGroupEvent = MESSAGE_NULL;
|
|
this->mTrackingEntity = 0;
|
|
this->mNumLocalSelectEvents = 0;
|
|
|
|
this->mSelected.clear();
|
|
this->mSelectionJustChanged = false;
|
|
this->mMouseOneDown = false;
|
|
this->mMouseTwoDown = false;
|
|
this->mMouseOneStartX = 0;
|
|
this->mMouseOneStartY = 0;
|
|
this->mMouseTwoStartX = 0;
|
|
this->mMouseTwoStartY = 0;
|
|
|
|
this->mMouseCursorX = this->mMouseCursorY = 0;
|
|
this->mPieMenuControl = "";
|
|
|
|
this->mPreviousHelpText = "";
|
|
this->mTimeLastHelpTextChanged = -1;
|
|
this->mCurrentCursorFrame = 0;
|
|
|
|
this->mMapExtents.ResetMapExtents();
|
|
this->mMapName = "";
|
|
|
|
this->mGhostBuilding = MESSAGE_NULL;
|
|
this->mValidatedBuilding = MESSAGE_NULL;
|
|
this->mCreatedGhost = false;
|
|
this->mCurrentGhostIsValid = false;
|
|
|
|
this->mAmbientSounds.clear();
|
|
|
|
// tankefugl: 0000971
|
|
this->mTeammateOrder.clear();
|
|
this->mDisplayOrderIndex = 0;
|
|
this->mDisplayOrderTime = 0;
|
|
this->mDisplayOrderType = 0;
|
|
// :tankefugl
|
|
}
|
|
|
|
|
|
AvHHud::~AvHHud(void)
|
|
{
|
|
//this->ResetGamma();
|
|
//delete [] sOriginalGammaTable;
|
|
//delete [] sGammaTable;
|
|
AvHHud::ResetGammaAtExit();
|
|
}
|
|
|
|
void DummyFunction()
|
|
{
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
int gGlobalDebugAuth = 0;
|
|
void TestIcon()
|
|
{
|
|
gGlobalDebugAuth = rand() % 7;
|
|
}
|
|
|
|
typedef struct alias_t {
|
|
alias_t* next;
|
|
char name[32];
|
|
char* cmds;
|
|
} alias_s;
|
|
|
|
void TestAlias()
|
|
{
|
|
alias_s* alias = *(alias_s**)0x2D5929C;
|
|
while(alias)
|
|
{
|
|
gEngfuncs.Con_Printf("name: %s\n%x - %x\n", alias->name, alias->name, gEngfuncs);
|
|
alias = alias->next;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Used for console command
|
|
void AvHHud::PlayRandomSongHook()
|
|
{
|
|
gHUD.PlayRandomSong();
|
|
}
|
|
|
|
void AvHHud::AddCommands()
|
|
{
|
|
gEngfuncs.pfnAddCommand ("+popupmenu", AvHPieMenuHandler::OpenPieMenu);
|
|
gEngfuncs.pfnAddCommand ("-popupmenu", AvHPieMenuHandler::ClosePieMenu);
|
|
|
|
gEngfuncs.pfnAddCommand ("+mousepopupmenu", AvHPieMenuHandler::OpenPieMenu);
|
|
gEngfuncs.pfnAddCommand ("-mousepopupmenu", AvHPieMenuHandler::ClosePieMenu);
|
|
|
|
// Add scrolling commands
|
|
gEngfuncs.pfnAddCommand ("+scrollup", AvHScrollHandler::ScrollUp);
|
|
gEngfuncs.pfnAddCommand ("-scrollup", AvHScrollHandler::StopScroll);
|
|
|
|
gEngfuncs.pfnAddCommand ("+scrolldown", AvHScrollHandler::ScrollDown);
|
|
gEngfuncs.pfnAddCommand ("-scrolldown", AvHScrollHandler::StopScroll);
|
|
|
|
gEngfuncs.pfnAddCommand ("+scrollleft", AvHScrollHandler::ScrollLeft);
|
|
gEngfuncs.pfnAddCommand ("-scrollleft", AvHScrollHandler::StopScroll);
|
|
|
|
gEngfuncs.pfnAddCommand ("+scrollright", AvHScrollHandler::ScrollRight);
|
|
gEngfuncs.pfnAddCommand ("-scrollright", AvHScrollHandler::StopScroll);
|
|
|
|
gEngfuncs.pfnAddCommand ("toggleeditps", AvHParticleEditorHandler::ToggleEdit);
|
|
|
|
gEngfuncs.pfnAddCommand ("nexttrack", AvHHud::PlayRandomSongHook);
|
|
|
|
gEngfuncs.pfnAddCommand ("+showmap", AvHHud::ShowMap);
|
|
gEngfuncs.pfnAddCommand ("-showmap", AvHHud::HideMap);
|
|
|
|
gEngfuncs.pfnAddCommand ("playstream", AvHHud::PlayStream);
|
|
gEngfuncs.pfnAddCommand ("stopstream", AvHHud::StopStream);
|
|
|
|
#ifdef DEBUG
|
|
gEngfuncs.pfnAddCommand("testicon", TestIcon);
|
|
gEngfuncs.pfnAddCommand("testalias", TestAlias);
|
|
#endif
|
|
|
|
int i = 0;
|
|
char theBinding[128];
|
|
for(i = (int)(RESOURCE_UPGRADE); i <= (int)(BUILD_RECYCLE); i++)
|
|
{
|
|
sprintf(theBinding, "%s%d", kHotKeyPrefix, i);
|
|
gEngfuncs.pfnAddCommand(theBinding, DummyFunction);
|
|
}
|
|
|
|
for(i = (int)(MENU_BUILD); i <= (int)(MENU_EQUIP); i++)
|
|
{
|
|
sprintf(theBinding, "%s%d", kHotKeyPrefix, i);
|
|
gEngfuncs.pfnAddCommand(theBinding, DummyFunction);
|
|
}
|
|
}
|
|
|
|
void AvHHud::ClientProcessEntity(struct entity_state_s* inEntity)
|
|
{
|
|
// Check if we need to create or destroy particle systems
|
|
int theIndex = inEntity->number;
|
|
bool theParticleOn = inEntity->iuser3 == AVH_USER3_PARTICLE_ON;
|
|
bool theParticleOff = inEntity->iuser3 == AVH_USER3_PARTICLE_OFF;
|
|
if(theParticleOn || theParticleOff)
|
|
{
|
|
int theHandle = -1;
|
|
if(theParticleOn)
|
|
{
|
|
// Ent index and template index stored in fuser1
|
|
int theValue = (int)(inEntity->fuser1);
|
|
int theGenEntIndex = (0xFFFF0000 & theValue) >> 16;
|
|
//int theTemplateIndex = (0x0000FFFF & theValue);
|
|
int theTemplateIndex = (((int(inEntity->fuser1)) & 0x0000FF00) >> 8);
|
|
|
|
//int theTemplateIndex = theValue;
|
|
|
|
// Handle stored in fuser2
|
|
theHandle = (int)(inEntity->fuser2);
|
|
|
|
// Don't create particle systems marked as high-detail if we don't have that option set. Note, this could cause collision
|
|
// differences between the client and server if the particle system doesn't use this flag with care
|
|
const AvHParticleTemplate* theTemplate = gParticleTemplateList.GetTemplateAtIndex(theTemplateIndex);
|
|
if(theTemplate)
|
|
{
|
|
if(!theTemplate->GetHighDetailOnly() || gEngfuncs.pfnGetCvarFloat(kvHighDetail))
|
|
{
|
|
AvHParticleSystemManager::Instance()->CreateParticleSystemIfNotCreated(inEntity->number, theTemplateIndex, /*theEntIndex,*/ theHandle);
|
|
|
|
// Update postion and visibility
|
|
if(theGenEntIndex > 0)
|
|
{
|
|
cl_entity_s* theGenEntity = gEngfuncs.GetEntityByIndex(theGenEntIndex);
|
|
if(theGenEntity)
|
|
{
|
|
AvHParticleSystemManager::Instance()->SetParticleSystemGenerationEntityExtents(theGenEntity->curstate.mins, theGenEntity->curstate.maxs, theHandle);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AvHParticleSystemManager::Instance()->SetParticleSystemPosition(inEntity->origin, theHandle);
|
|
}
|
|
|
|
// Set the particle system custom data
|
|
//uint16 theCustomData = (uint16)(((int)inEntity->fuser3) >> 16);
|
|
//uint16 theCustomData = (uint16)(inEntity->fuser3);
|
|
uint16 theCustomData = (uint16)(inEntity->weaponmodel);
|
|
AvHParticleSystemManager::Instance()->SetParticleSystemCustomData(theCustomData, theHandle);
|
|
}
|
|
}
|
|
}
|
|
else if(theParticleOff)
|
|
{
|
|
theHandle = (int)(inEntity->fuser1);
|
|
//AvHParticleSystemManager::Instance()->DestroyParticleSystemIfNotDestroyed(inEntity->number, theHandle);
|
|
AvHParticleSystemManager::Instance()->MarkParticleSystemForDeletion(inEntity->number, theHandle);
|
|
}
|
|
|
|
// Always update visibility
|
|
bool theVisibilityState = false;
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
if(GetHasUpgrade(inEntity->iuser4, MASK_VIS_SIGHTED))
|
|
{
|
|
theVisibilityState = true;
|
|
}
|
|
else
|
|
{
|
|
theVisibilityState = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
theVisibilityState = true;
|
|
}
|
|
|
|
AvHParticleSystemManager::Instance()->SetParticleSystemVisibility(theVisibilityState, theHandle);
|
|
}
|
|
else if((inEntity->iuser3 == AVH_USER3_AUDIO_ON) || (inEntity->iuser3 == AVH_USER3_AUDIO_OFF))
|
|
{
|
|
// Read values
|
|
int theEntIndex = (int)(inEntity->fuser1) >> 16;
|
|
//int theSoundIndex = (int)(inEntity->fuser1) & 0x0000FFFF;
|
|
|
|
// memcpy so value isn't interpreted
|
|
//int theSoundIndex = 0;
|
|
//memcpy(&theSoundIndex, &inEntity->fuser1, sizeof(float));
|
|
//theSoundIndex = theSoundIndex & 0x0000FFFF;
|
|
int theSoundIndex = (((int(inEntity->fuser1)) & 0x0000FF00) >> 8);
|
|
|
|
// Top byte is flags, next byte is volume, bottom two bytes are fade distance
|
|
int theFlags = inEntity->iuser4 >> 24;
|
|
int theVolume = (inEntity->iuser4 >> 16) & 0x00FF;
|
|
int theFadeDistance = (inEntity->iuser4) & 0x0000FFFF;
|
|
|
|
float theTimeOfAction = inEntity->fuser2;
|
|
|
|
bool theSoundOn = (inEntity->iuser3 == AVH_USER3_AUDIO_ON);
|
|
|
|
this->ModifyAmbientSoundEntryIfChanged(theSoundOn, theSoundIndex, theEntIndex, theTimeOfAction, theVolume, theFadeDistance, theFlags, inEntity->origin);
|
|
}
|
|
}
|
|
|
|
string LookupAndTranslate(AvHMessageID inMessageID)
|
|
{
|
|
string theKey = string(kTechNodeLabelPrefix) + MakeStringFromInt((int)inMessageID);
|
|
|
|
string theTranslatedTechName;
|
|
LocalizeString(theKey.c_str(), theTranslatedTechName);
|
|
|
|
return theTranslatedTechName;
|
|
}
|
|
|
|
void AvHHud::DisplayCombatUpgradeMenu(bool inVisible)
|
|
{
|
|
if(inVisible)
|
|
{
|
|
// Parse current tech nodes and set text
|
|
const AvHTechID kLineStart[kNumUpgradeLines] = {TECH_ONE_LEVEL_ONE, TECH_TWO_LEVEL_ONE, TECH_THREE_LEVEL_ONE, TECH_FOUR_LEVEL_ONE, TECH_FIVE_LEVEL_ONE};
|
|
|
|
// Add "you are now x"!
|
|
string theYouAreNow;
|
|
LocalizeString(kYouAreNowA, theYouAreNow);
|
|
|
|
string theRankTitle = this->GetRankTitle(false);
|
|
|
|
string theExclamation;
|
|
LocalizeString(kExclamation, theExclamation);
|
|
|
|
string theChooseAnUpgrade;
|
|
LocalizeString(kChooseAnUpgrade, theChooseAnUpgrade);
|
|
|
|
string theFinalText = theYouAreNow + string(" ") + theRankTitle + theExclamation + string("\n");
|
|
theFinalText += theChooseAnUpgrade + string("\n\n");
|
|
|
|
// Set the lines
|
|
this->mCombatUpgradeMenu.SetText(theFinalText);
|
|
}
|
|
|
|
// Parse text above every time, but only set position once so it doesn't keep animating
|
|
if(inVisible && !this->mDrawCombatUpgradeMenu)
|
|
{
|
|
// Start off screen, and scroll right
|
|
const float kWidth = .4f;
|
|
this->mCombatUpgradeMenu.SetNormalizedScreenX(-kWidth);
|
|
this->mCombatUpgradeMenu.SetNormalizedScreenY(.25f);
|
|
this->mCombatUpgradeMenu.SetNormalizedMaxWidth(kWidth);
|
|
}
|
|
|
|
this->mDrawCombatUpgradeMenu = inVisible;
|
|
}
|
|
|
|
void AvHHud::DisplayMessage(const char* inMessage)
|
|
{
|
|
this->m_Message.MessageAdd(inMessage, this->m_flTime);
|
|
|
|
// Remember the time -- to fix up level transitions
|
|
//this->m_Message.m_parms.time = this->m_flTime;
|
|
|
|
// Turn on drawing
|
|
if ( !(this->m_Message.m_iFlags & HUD_ACTIVE) )
|
|
this->m_Message.m_iFlags |= HUD_ACTIVE;
|
|
}
|
|
|
|
//int AvHHud::GetArmorLevel(void) const
|
|
//{
|
|
// return this->mArmorLevel;
|
|
//}
|
|
|
|
int AvHHud::GetFrameForOrderType(AvHOrderType inOrderType) const
|
|
{
|
|
int theFrame = 0;
|
|
|
|
switch(inOrderType)
|
|
{
|
|
case ORDERTYPEL_DEFAULT:
|
|
theFrame = 2;
|
|
break;
|
|
|
|
case ORDERTYPEL_MOVE:
|
|
theFrame = 2;
|
|
break;
|
|
|
|
case ORDERTYPET_ATTACK:
|
|
theFrame = 4;
|
|
break;
|
|
|
|
case ORDERTYPET_BUILD:
|
|
theFrame = 5;
|
|
break;
|
|
|
|
case ORDERTYPET_GUARD:
|
|
theFrame = 6;
|
|
break;
|
|
|
|
case ORDERTYPET_WELD:
|
|
theFrame = 7;
|
|
break;
|
|
|
|
case ORDERTYPET_GET:
|
|
theFrame = 8;
|
|
break;
|
|
}
|
|
|
|
return theFrame;
|
|
}
|
|
|
|
AvHPlayMode AvHHud::GetPlayMode(void) const
|
|
{
|
|
AvHPlayMode thePlayMode = PLAYMODE_UNDEFINED;
|
|
|
|
cl_entity_s* thePlayer = gEngfuncs.GetLocalPlayer();
|
|
if(thePlayer)
|
|
{
|
|
if(gEngfuncs.IsSpectateOnly())
|
|
{
|
|
thePlayMode = PLAYMODE_OBSERVER;
|
|
}
|
|
else
|
|
{
|
|
thePlayMode = AvHPlayMode(thePlayer->curstate.playerclass);
|
|
}
|
|
}
|
|
|
|
return thePlayMode;
|
|
}
|
|
|
|
AvHPlayMode AvHHud::GetHUDPlayMode() const
|
|
{
|
|
AvHPlayMode thePlayMode = this->GetPlayMode();
|
|
|
|
cl_entity_s* thePlayer = this->GetVisiblePlayer();
|
|
if(thePlayer)
|
|
{
|
|
thePlayMode = AvHPlayMode(thePlayer->curstate.playerclass);
|
|
}
|
|
|
|
return thePlayMode;
|
|
}
|
|
|
|
cl_entity_s* AvHHud::GetVisiblePlayer() const
|
|
{
|
|
cl_entity_s* thePlayer = gEngfuncs.GetLocalPlayer();
|
|
if(g_iUser1 == OBS_IN_EYE)
|
|
{
|
|
cl_entity_t* theEnt = gEngfuncs.GetEntityByIndex(g_iUser2);
|
|
if(theEnt)
|
|
{
|
|
thePlayer = theEnt;
|
|
}
|
|
}
|
|
|
|
return thePlayer;
|
|
}
|
|
|
|
int AvHHud::GetLocalUpgrades() const
|
|
{
|
|
static int theUpgrades = 0;
|
|
|
|
cl_entity_s* thePlayer = this->GetVisiblePlayer();
|
|
if(thePlayer)
|
|
{
|
|
theUpgrades = thePlayer->curstate.iuser4;
|
|
}
|
|
|
|
return theUpgrades;
|
|
}
|
|
|
|
// Players could hack their client dll and see all the orders on their team. Minor cheat but definitely possible.
|
|
EntityListType AvHHud::GetDrawPlayerOrders() const
|
|
{
|
|
EntityListType theList;
|
|
|
|
cl_entity_s* theVisiblePlayer = this->GetVisiblePlayer();
|
|
if(theVisiblePlayer)
|
|
{
|
|
int theVisiblePlayerIndex = theVisiblePlayer->index;
|
|
|
|
if(this->GetHUDUser3() == AVH_USER3_MARINE_PLAYER)
|
|
{
|
|
// Only draw orders for us
|
|
theList.push_back(theVisiblePlayerIndex);
|
|
}
|
|
else if(this->GetHUDUser3() == AVH_USER3_COMMANDER_PLAYER)
|
|
{
|
|
// Add everyone that he has selected!
|
|
return this->mSelected;
|
|
}
|
|
}
|
|
|
|
return theList;
|
|
}
|
|
|
|
bool AvHHud::GetInTopDownMode() const
|
|
{
|
|
return this->mInTopDownMode;
|
|
}
|
|
|
|
bool AvHHud::GetIsSelecting() const
|
|
{
|
|
return mSelectionBoxVisible;
|
|
}
|
|
|
|
OrderListType AvHHud::GetOrderList() const
|
|
{
|
|
return this->mOrders;
|
|
}
|
|
|
|
//AvHOrderType AvHHud::GetOrderMode() const
|
|
//{
|
|
// return this->mOrderMode;
|
|
//}
|
|
|
|
bool AvHHud::GetCenterPositionForGroup(int inGroupNumber, vec3_t& outCenterPosition) const
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
if((inGroupNumber >= 1) && (inGroupNumber <= kNumHotkeyGroups))
|
|
{
|
|
vec3_t theCenterPosition;
|
|
VectorClear(theCenterPosition);
|
|
|
|
int theNumFound = 0;
|
|
|
|
const EntityListType& theGroup = this->mGroups[inGroupNumber - 1];
|
|
if(theGroup.size() > 0)
|
|
{
|
|
for(EntityListType::const_iterator theIter = theGroup.begin(); theIter != theGroup.end(); theIter++)
|
|
{
|
|
int theEntIndex = *theIter;
|
|
|
|
Vector thePosition;
|
|
cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(theEntIndex);
|
|
if(theEntity)
|
|
{
|
|
thePosition = theEntity->curstate.origin;
|
|
}
|
|
|
|
if(AvHSHUGetEntityLocation(theEntIndex, thePosition))
|
|
{
|
|
theCenterPosition.x += thePosition.x;
|
|
theCenterPosition.y += thePosition.y;
|
|
theNumFound++;
|
|
}
|
|
}
|
|
|
|
if(theNumFound > 0)
|
|
{
|
|
theCenterPosition.x /= theNumFound;
|
|
theCenterPosition.y /= theNumFound;
|
|
|
|
outCenterPosition = theCenterPosition;
|
|
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
void AvHHud::GetMousePos(int& outX, int& outY) const
|
|
{
|
|
gEngfuncs.GetMousePosition(&outX, &outY);
|
|
|
|
// Clip mouse to window (weird)
|
|
outX = min(max(0, outX), ScreenWidth());
|
|
outY = min(max(0, outY), ScreenHeight());
|
|
|
|
//char theMouseMessage[256];
|
|
//sprintf(theMouseMessage, "Mouse coords: %d, %d", outX, outY);
|
|
//CenterPrint(theMouseMessage);
|
|
}
|
|
|
|
bool AvHHud::GetAndClearTopDownScrollAmount(int& outX, int& outY, int& outZ)
|
|
{
|
|
bool theSuccess = false;
|
|
outX = 0;
|
|
outY = 0;
|
|
outZ = 0;
|
|
|
|
// Don't scroll if the the commander is dragging a selection box.
|
|
|
|
if(this->GetInTopDownMode() && !GetIsSelecting())
|
|
{
|
|
const int kScreenWidth = ScreenWidth();
|
|
const int kScreenHeight = ScreenHeight();
|
|
const kScrollHorizontal = .0152f*kScreenWidth;
|
|
const kScrollVertical = .015f*kScreenHeight;
|
|
|
|
// Left side
|
|
if(this->GetIsMouseInRegion(0, 0, kScrollHorizontal, kScreenHeight) || (gScrollHandler.GetXScroll() < 0))
|
|
{
|
|
outX = -1;
|
|
}
|
|
// Right side
|
|
else if(this->GetIsMouseInRegion(kScreenWidth - kScrollHorizontal, 0, kScrollHorizontal, kScreenHeight) || (gScrollHandler.GetXScroll() > 0))
|
|
{
|
|
outX = 1;
|
|
}
|
|
|
|
// Top edge
|
|
if(this->GetIsMouseInRegion(0, 0, kScreenWidth, kScrollVertical) || (gScrollHandler.GetYScroll() > 0))
|
|
{
|
|
outY = 1;
|
|
}
|
|
// Bottom edge
|
|
else if(this->GetIsMouseInRegion(0, kScreenHeight - kScrollVertical, kScreenWidth, kScrollVertical) || (gScrollHandler.GetYScroll() < 0))
|
|
{
|
|
outY = -1;
|
|
}
|
|
|
|
// Only clear z scroll because of the way events work (invnext/invprev vs. holding a key down)
|
|
//gScrollHandler.ClearScrollHeight();
|
|
|
|
theSuccess = true;
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
bool AvHHud::GetAndClearSelectionEvent(vec3_t& outSelection, AvHMessageID& outMessageID)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
// Return a build event if there is one, else return a COMMANDER_MOUSECOORD event
|
|
if(this->mLeftMouseStarted)
|
|
{
|
|
if(this->mValidatedBuilding == MESSAGE_NULL)
|
|
{
|
|
VectorCopy(this->mLeftMouseWorldStart, outSelection);
|
|
outMessageID = COMMANDER_MOUSECOORD;
|
|
}
|
|
else
|
|
{
|
|
VectorCopy(this->mNormBuildLocation, outSelection);
|
|
outMessageID = this->mValidatedBuilding;
|
|
this->mValidatedBuilding = this->mGhostBuilding = MESSAGE_NULL;
|
|
this->mPlacingBuilding = true;
|
|
}
|
|
theSuccess = true;
|
|
}
|
|
else if(this->mLeftMouseEnded)
|
|
{
|
|
if(!this->mPlacingBuilding)
|
|
{
|
|
outSelection = this->mLeftMouseWorldEnd;
|
|
outMessageID = COMMANDER_MOUSECOORD;
|
|
theSuccess = true;
|
|
}
|
|
this->mPlacingBuilding = false;
|
|
}
|
|
else if(this->mRightMouseStarted)
|
|
{
|
|
// Cancel building placement
|
|
if(this->mGhostBuilding != MESSAGE_NULL)
|
|
{
|
|
CancelBuilding();
|
|
}
|
|
else
|
|
{
|
|
outSelection = this->mRightMouseWorldStart;
|
|
outMessageID = COMMANDER_MOUSECOORD;
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else if(this->mRightMouseEnded)
|
|
{
|
|
outSelection = this->mRightMouseWorldEnd;
|
|
outMessageID = COMMANDER_MOUSECOORD;
|
|
theSuccess = true;
|
|
}
|
|
else
|
|
{
|
|
outSelection = this->mMouseWorldPosition;
|
|
outMessageID = COMMANDER_MOUSECOORD;
|
|
theSuccess = true;
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
EntityListType AvHHud::GetSelected() const
|
|
{
|
|
return this->mSelected;
|
|
}
|
|
|
|
const AvHTechSlotManager& AvHHud::GetTechSlotManager() const
|
|
{
|
|
return this->mTechSlotManager;
|
|
}
|
|
|
|
bool AvHHud::GetAndClearAlienAbility(AvHMessageID& outMessageID)
|
|
{
|
|
bool theAlienAbilityWaiting = false;
|
|
|
|
if(this->mAlienAbility != MESSAGE_NULL)
|
|
{
|
|
outMessageID = this->mAlienAbility;
|
|
theAlienAbilityWaiting = true;
|
|
this->mAlienAbility = MESSAGE_NULL;
|
|
}
|
|
|
|
return theAlienAbilityWaiting;
|
|
}
|
|
|
|
bool AvHHud::GetAndClearGroupEvent(AvHMessageID& outMessageID)
|
|
{
|
|
bool theGroupEventWaiting = false;
|
|
|
|
if(this->mGroupEvent != MESSAGE_NULL)
|
|
{
|
|
outMessageID = this->mGroupEvent;
|
|
theGroupEventWaiting = true;
|
|
|
|
// if(!this->mIsTracking)
|
|
// {
|
|
this->mGroupEvent = MESSAGE_NULL;
|
|
// }
|
|
}
|
|
|
|
return theGroupEventWaiting;
|
|
}
|
|
|
|
int AvHHud::GetTrackingEntity() const
|
|
{
|
|
return this->mTrackingEntity;
|
|
}
|
|
|
|
void AvHHud::ClearTrackingEntity()
|
|
{
|
|
this->mTrackingEntity = 0;
|
|
}
|
|
|
|
void AvHHud::SetSelectionEffects(EntityListType& inUnitList)
|
|
{
|
|
// Make sure we have an effect created for each unit in this list. If there are units that
|
|
// have selection effects that aren't in this list, delete them. This is called locally when the
|
|
// selection is predicted, then it's called again when the selection is confirmed.
|
|
this->mSelectionEffects.clear();
|
|
|
|
for(EntityListType::iterator theIter = inUnitList.begin(); theIter != inUnitList.end(); theIter++)
|
|
{
|
|
SelectionEffect theNewEffect;
|
|
theNewEffect.mEntIndex = *theIter;
|
|
theNewEffect.mAngleOffset = 0;
|
|
this->mSelectionEffects.push_back(theNewEffect);
|
|
}
|
|
}
|
|
|
|
UIMode AvHHud::GetUIMode() const
|
|
{
|
|
return this->mCurrentUIMode;
|
|
}
|
|
|
|
bool AvHHud::SwitchUIMode(UIMode inNewMode)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
// Only allow switching to a non-main mode when we're in main, always allow switching back to main mode
|
|
if((inNewMode == MAIN_MODE) || (this->mCurrentUIMode == MAIN_MODE))
|
|
{
|
|
if(inNewMode != this->mCurrentUIMode)
|
|
{
|
|
// Move pop-up menu components away or back so they don't block other compoments...ugh
|
|
if(inNewMode != MAIN_MODE)
|
|
{
|
|
gHUD.GetManager().TranslateComponent(kSoldierMenu, true);
|
|
gHUD.GetManager().TranslateComponent(kSoldierCombatMenu, true);
|
|
gHUD.GetManager().TranslateComponent(kAlienMenu, true);
|
|
gHUD.GetManager().TranslateComponent(kAlienCombatMenu, true);
|
|
gHUD.GetManager().TranslateComponent(kAlienMembrane, true);
|
|
gHUD.GetManager().TranslateComponent(kScroller, true);
|
|
gHUD.GetManager().TranslateComponent(kSelectionText, true);
|
|
//CenterPrint("Pop-up controls moved off screen");
|
|
}
|
|
else
|
|
{
|
|
gHUD.GetManager().TranslateComponent(kSoldierMenu, false);
|
|
gHUD.GetManager().TranslateComponent(kSoldierCombatMenu, false);
|
|
gHUD.GetManager().TranslateComponent(kAlienMenu, false);
|
|
gHUD.GetManager().TranslateComponent(kAlienCombatMenu, false);
|
|
gHUD.GetManager().TranslateComponent(kAlienMembrane, false);
|
|
gHUD.GetManager().TranslateComponent(kScroller, false);
|
|
gHUD.GetManager().TranslateComponent(kSelectionText, false);
|
|
//CenterPrint("Pop-up controls moved on screen");
|
|
}
|
|
|
|
this->mCurrentUIMode = inNewMode;
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
bool AvHHud::Update(float inCurrentTime, string& outErrorString)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
if(inCurrentTime > this->mTimeOfLastUpdate)
|
|
{
|
|
|
|
this->mTimeOfCurrentUpdate = inCurrentTime;
|
|
|
|
// Predict game time
|
|
if(this->GetGameStarted())
|
|
{
|
|
this->mGameTime += (inCurrentTime - this->mTimeOfLastUpdate);
|
|
}
|
|
|
|
AvHParticleSystemManager::Instance()->Start();
|
|
|
|
// This component must always be visible to allow us to hook mouse cursor sprite drawing
|
|
this->ResetComponentsForUser3();
|
|
|
|
this->UpdateDataFromVuser4(inCurrentTime);
|
|
|
|
this->UpdateSpectating();
|
|
|
|
this->GetManager().UnhideComponent(kLastComponent);
|
|
|
|
this->UpdateDemoRecordPlayback();
|
|
|
|
theSuccess = UIHud::Update(inCurrentTime, outErrorString);
|
|
if(!theSuccess)
|
|
{
|
|
this->AddTooltip(outErrorString.c_str());
|
|
}
|
|
|
|
this->UpdateProgressBar();
|
|
|
|
this->UpdateCommonUI();
|
|
|
|
this->UpdateAlienUI(inCurrentTime);
|
|
|
|
this->UpdateMarineUI(inCurrentTime);
|
|
|
|
this->UpdateCountdown(inCurrentTime);
|
|
|
|
this->UpdateExploitPrevention();
|
|
this->UpdateFromEntities(inCurrentTime);
|
|
|
|
this->UpdateEntityID(inCurrentTime);
|
|
|
|
this->UpdateHelpText();
|
|
|
|
this->UpdateTooltips(inCurrentTime);
|
|
|
|
this->UpdateStructureNotification(inCurrentTime);
|
|
|
|
this->UpdateMusic(inCurrentTime);
|
|
|
|
this->UpdatePieMenuControl();
|
|
|
|
// Reset cursor every tick, update selection may change it
|
|
// This cursor is used when we're on the ground for pie menus as well
|
|
this->SetCursor(ORDERTYPE_UNDEFINED);
|
|
|
|
this->UpdateHierarchy();
|
|
|
|
this->UpdateInfoLocation();
|
|
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
this->UpdateSelection();
|
|
gCommanderHandler.Update(this->mTechNodes, this->mResources);
|
|
|
|
// char theDebugString[128];
|
|
// sprintf(theDebugString, "norm X/Y: %f, %f", (float)this->mMouseCursorX/ScreenWidth, (float)this->mMouseCursorY/ScreenHeight);
|
|
// CenterPrint(theDebugString);
|
|
}
|
|
else
|
|
{
|
|
this->ResetTopDownUI();
|
|
}
|
|
|
|
// Update orders
|
|
//for(OrderListType::iterator theIter = this->mOrders.begin(); theIter != this->mOrders.end(); theIter++)
|
|
//{
|
|
// theIter->Update();
|
|
//}
|
|
|
|
this->UpdateTechNodes();
|
|
|
|
this->UpdateAmbientSounds();
|
|
|
|
this->UpdateViewModelEffects();
|
|
|
|
mOverviewMap.UpdateOrders(mOrders, GetDrawPlayerOrders());
|
|
mOverviewMap.Update(inCurrentTime);
|
|
|
|
float theTimePassed = inCurrentTime - this->mTimeOfLastUpdate;
|
|
|
|
AvHParticleSystemManager::Instance()->Update(theTimePassed);
|
|
|
|
AvHScriptManager::Instance()->ClientUpdate(theTimePassed);
|
|
|
|
this->UpdateResources(theTimePassed);
|
|
|
|
if((this->GetHUDPlayMode() == PLAYMODE_PLAYING) && !this->GetIsAlive())
|
|
{
|
|
this->mCommanderResourceLabel->setVisible(false);
|
|
this->mHierarchy->setVisible(false);
|
|
this->mShowMapHierarchy->setVisible(false);
|
|
}
|
|
|
|
if(cl_particleinfo->value)
|
|
{
|
|
char theDebugText[128];
|
|
int theNumVisible = AvHParticleSystemManager::Instance()->GetNumVisibleParticleSystems();
|
|
int theNum = AvHParticleSystemManager::Instance()->GetNumberParticleSystems();
|
|
int theNumTemplates = gParticleTemplateList.GetNumberTemplates();
|
|
sprintf(theDebugText, "(vis, total, list): %d, %d, %d", theNumVisible, theNum, theNumTemplates);
|
|
|
|
//sprintf(theDebugText, "step interval: %d", pmove->flTimeStepSound);
|
|
|
|
/*
|
|
if(this->mMarineResourceLabel)
|
|
{
|
|
this->mMarineResourceLabel->setText(theDebugText);
|
|
this->mMarineResourceLabel->setVisible(true);
|
|
}
|
|
*/
|
|
|
|
}
|
|
|
|
if(!gEngfuncs.pDemoAPI->IsPlayingback())
|
|
{
|
|
IN_GetMousePos(&this->mMouseCursorX, &this->mMouseCursorY);
|
|
}
|
|
|
|
// Update user3 and team
|
|
this->mLastUser3 = this->GetHUDUser3();
|
|
this->mLastTeamNumber = this->GetHUDTeam();
|
|
this->mLastPlayMode = this->GetPlayMode();
|
|
|
|
this->mTimeOfLastUpdate = inCurrentTime;
|
|
|
|
// Save view origin and angles before we do crazy viewport stuff
|
|
// gPlayerOrigin = v_origin;
|
|
// gPlayerAngles = v_angles;
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
//void AvHHud::UpdateSelectionEffects(float inTimePassed)
|
|
//{
|
|
// // Radians/sec
|
|
// const float kSpinRate = 1.5f;
|
|
// for(SelectionListType::iterator theIter = this->mSelectionEffects.begin(); theIter != this->mSelectionEffects.end(); theIter++)
|
|
// {
|
|
// theIter->mAngleOffset = (theIter->mAngleOffset += inTimePassed*kSpinRate) % 360;
|
|
// }
|
|
//}
|
|
|
|
bool AvHHud::GetAndClearTechEvent(AvHMessageID& outMessageID)
|
|
{
|
|
bool theTechEventWaiting = false;
|
|
|
|
if(this->mTechEvent != MESSAGE_NULL)
|
|
{
|
|
outMessageID = this->mTechEvent;
|
|
theTechEventWaiting = true;
|
|
this->mTechEvent = MESSAGE_NULL;
|
|
}
|
|
|
|
return theTechEventWaiting;
|
|
}
|
|
|
|
bool AvHHud::GetLastHotkeySelectionEvent(AvHMessageID& outMessageID)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
switch(this->mLastHotkeySelectionEvent)
|
|
{
|
|
case GROUP_SELECT_1:
|
|
case GROUP_SELECT_2:
|
|
case GROUP_SELECT_3:
|
|
case GROUP_SELECT_4:
|
|
case GROUP_SELECT_5:
|
|
outMessageID = this->mLastHotkeySelectionEvent;
|
|
theSuccess = true;
|
|
break;
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
void AvHHud::SetLastHotkeySelectionEvent(AvHMessageID inMessageID)
|
|
{
|
|
switch(inMessageID)
|
|
{
|
|
case MESSAGE_NULL:
|
|
case GROUP_CREATE_1:
|
|
case GROUP_CREATE_2:
|
|
case GROUP_CREATE_3:
|
|
case GROUP_CREATE_4:
|
|
case GROUP_CREATE_5:
|
|
case GROUP_SELECT_1:
|
|
case GROUP_SELECT_2:
|
|
case GROUP_SELECT_3:
|
|
case GROUP_SELECT_4:
|
|
case GROUP_SELECT_5:
|
|
case COMMANDER_REMOVESELECTION:
|
|
this->mLastHotkeySelectionEvent = inMessageID;
|
|
break;
|
|
|
|
default:
|
|
ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool AvHHud::GetIsAlien() const
|
|
{
|
|
bool theIsAlien = false;
|
|
|
|
AvHUser3 theUser3 = this->GetHUDUser3();
|
|
|
|
switch(theUser3)
|
|
{
|
|
case AVH_USER3_ALIEN_PLAYER1:
|
|
case AVH_USER3_ALIEN_PLAYER2:
|
|
case AVH_USER3_ALIEN_PLAYER3:
|
|
case AVH_USER3_ALIEN_PLAYER4:
|
|
case AVH_USER3_ALIEN_PLAYER5:
|
|
case AVH_USER3_ALIEN_EMBRYO:
|
|
theIsAlien = true;
|
|
break;
|
|
}
|
|
|
|
return theIsAlien;
|
|
}
|
|
|
|
bool AvHHud::GetIsBeingDigested() const
|
|
{
|
|
bool theIsBeingDigested = false;
|
|
|
|
int theUpgrades = this->GetHUDUpgrades();
|
|
|
|
if(GetHasUpgrade(theUpgrades, MASK_DIGESTING))
|
|
{
|
|
cl_entity_t* theVisiblePlayer = this->GetVisiblePlayer();
|
|
if(theVisiblePlayer && (theVisiblePlayer->curstate.effects & EF_NODRAW))
|
|
{
|
|
theIsBeingDigested = true;
|
|
}
|
|
}
|
|
|
|
return theIsBeingDigested;
|
|
}
|
|
|
|
bool AvHHud::GetIsEnsnared() const
|
|
{
|
|
int theUpgrades = this->GetHUDUpgrades();
|
|
return GetHasUpgrade(theUpgrades, MASK_ENSNARED);
|
|
}
|
|
|
|
bool AvHHud::GetIsStunned() const
|
|
{
|
|
int theUpgrades = this->GetHUDUpgrades();
|
|
return GetHasUpgrade(theUpgrades, MASK_PLAYER_STUNNED);
|
|
}
|
|
|
|
bool AvHHud::GetIsDigesting() const
|
|
{
|
|
bool theIsDigesting = false;
|
|
|
|
int theUpgrades = this->GetHUDUpgrades();
|
|
|
|
if(GetHasUpgrade(theUpgrades, MASK_DIGESTING))
|
|
{
|
|
cl_entity_t* theVisiblePlayer = this->GetVisiblePlayer();
|
|
if(theVisiblePlayer && !(theVisiblePlayer->curstate.effects & EF_NODRAW))
|
|
{
|
|
theIsDigesting = true;
|
|
}
|
|
}
|
|
|
|
return theIsDigesting;
|
|
}
|
|
|
|
bool AvHHud::GetIsNotInControl() const
|
|
{
|
|
return GetIsBeingDigested() || !IEngineStudio.IsHardware();
|
|
}
|
|
|
|
bool AvHHud::GetIsInTopDownMode() const
|
|
{
|
|
bool theIsInTopDownMode = false;
|
|
|
|
if(GetHasUpgrade(this->GetHUDUpgrades(), MASK_TOPDOWN))
|
|
{
|
|
theIsInTopDownMode = true;
|
|
}
|
|
|
|
return theIsInTopDownMode;
|
|
}
|
|
|
|
int AvHHud::GetCommanderIndex() const
|
|
{
|
|
int theCommanderIndex = -1;
|
|
|
|
for(int i = 1; i <= MAX_PLAYERS; i++)
|
|
{
|
|
extra_player_info_t* theExtraPlayerInfo = &g_PlayerExtraInfo[i];
|
|
ASSERT(theExtraPlayerInfo);
|
|
int thePlayerClass = theExtraPlayerInfo->playerclass;
|
|
if(thePlayerClass == PLAYERCLASS_COMMANDER)
|
|
{
|
|
theCommanderIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return theCommanderIndex;
|
|
}
|
|
|
|
|
|
bool AvHHud::GetHasJetpack() const
|
|
{
|
|
int theLocalUpgrades = this->GetHUDUpgrades();
|
|
bool theHasJetpackUpgrade = GetHasUpgrade(theLocalUpgrades, MASK_UPGRADE_7) && this->GetIsMarine();
|
|
|
|
return theHasJetpackUpgrade;
|
|
}
|
|
|
|
bool AvHHud::GetHasAlienUpgradesAvailable() const
|
|
{
|
|
bool theHasUpgradesAvailable = false;
|
|
|
|
if(this->GetIsAlien() && this->GetIsRelevant() && !this->GetIsBeingDigested())
|
|
{
|
|
int theUpgradeVar = this->GetLocalUpgrades();
|
|
bool theHasDefensiveUpgradesAvailable = AvHGetHasUpgradeChoiceInCategory(ALIEN_UPGRADE_CATEGORY_DEFENSE, this->mUpgrades, theUpgradeVar);
|
|
bool theHasMovementUpgradesAvailable = AvHGetHasUpgradeChoiceInCategory(ALIEN_UPGRADE_CATEGORY_MOVEMENT, this->mUpgrades, theUpgradeVar);
|
|
bool theHasSensoryUpgradesAvailable = AvHGetHasUpgradeChoiceInCategory(ALIEN_UPGRADE_CATEGORY_SENSORY, this->mUpgrades, theUpgradeVar);
|
|
|
|
theHasUpgradesAvailable = theHasDefensiveUpgradesAvailable || theHasMovementUpgradesAvailable || theHasSensoryUpgradesAvailable;
|
|
}
|
|
|
|
return theHasUpgradesAvailable;
|
|
}
|
|
|
|
bool AvHHud::GetIsMarine() const
|
|
{
|
|
bool theIsMarine = false;
|
|
|
|
AvHUser3 theUser3 = this->GetHUDUser3();
|
|
|
|
switch(theUser3)
|
|
{
|
|
case AVH_USER3_MARINE_PLAYER:
|
|
case AVH_USER3_COMMANDER_PLAYER:
|
|
theIsMarine = true;
|
|
break;
|
|
}
|
|
|
|
return theIsMarine;
|
|
}
|
|
|
|
bool AvHHud::GetIsRelevant() const
|
|
{
|
|
bool theIsRelevant = false;
|
|
|
|
if(this->GetIsAlive() && (this->GetPlayMode() == PLAYMODE_PLAYING) /*&& !this->GetIsSpectator()*/)
|
|
{
|
|
theIsRelevant = true;
|
|
}
|
|
|
|
return theIsRelevant;
|
|
}
|
|
|
|
vec3_t AvHHud::GetVisualOrigin() const
|
|
{
|
|
vec3_t theVisualOrigin = gPredictedPlayerOrigin;
|
|
|
|
theVisualOrigin.z += gPredictedPlayerVOfs[2];
|
|
|
|
return theVisualOrigin;
|
|
}
|
|
|
|
AvHMessageID AvHHud::HotKeyHit(char inChar)
|
|
{
|
|
return gCommanderHandler.HotKeyHit(inChar);
|
|
}
|
|
|
|
float AvHHud::GetGammaSlope() const
|
|
{
|
|
return sGameGammaTable.GetGammaSlope();
|
|
}
|
|
|
|
string AvHHud::GetMapName(bool inLocalOnly) const
|
|
{
|
|
string theMapName = this->mMapName;
|
|
|
|
if((theMapName == "") && !inLocalOnly )
|
|
{
|
|
const char* theLevelName = gEngfuncs.pfnGetLevelName();
|
|
if(theLevelName)
|
|
{
|
|
theMapName = string(theLevelName);
|
|
|
|
// Remove maps/ from the beginning and .bsp from the end.
|
|
StringVector theVector;
|
|
Tokenizer::split(theMapName, "/.", theVector);
|
|
if(theVector.size() >= 2)
|
|
{
|
|
theMapName = theVector[1];
|
|
}
|
|
}
|
|
}
|
|
|
|
return theMapName;
|
|
}
|
|
|
|
int AvHHud::GetNumActiveHives() const
|
|
{
|
|
int theNumActiveHives = 0;
|
|
|
|
if(this->GetIsAlien())
|
|
{
|
|
for(HiveInfoListType::const_iterator theIter = this->mHiveInfoList.begin(); theIter != this->mHiveInfoList.end(); theIter++)
|
|
{
|
|
if(theIter->mStatus == kHiveInfoStatusBuilt)
|
|
{
|
|
theNumActiveHives++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return theNumActiveHives;
|
|
}
|
|
|
|
int AvHHud::GetMaxAlienResources() const
|
|
{
|
|
int theMaxAlienResources = kMaxAlienResources;
|
|
|
|
if(this->mMaxResources >= 0)
|
|
{
|
|
theMaxAlienResources = this->mMaxResources;
|
|
}
|
|
|
|
return theMaxAlienResources;
|
|
}
|
|
|
|
bool AvHHud::SetGamma(float inSlope)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
// Disable gamma stuff in debug for sanity
|
|
// #ifndef DEBUG
|
|
|
|
HDC theDC = GetDC(NULL);
|
|
if(theDC != 0)
|
|
{
|
|
const float kGammaIncrement = 0.05f;
|
|
float theGammaToTry = inSlope + kGammaIncrement;
|
|
while(!theSuccess && (theGammaToTry > 1.0f))
|
|
{
|
|
theGammaToTry -= kGammaIncrement;
|
|
|
|
sGameGammaTable.ProcessSlope(theGammaToTry);
|
|
// tankefugl: fakes a successful gamma ramp change if cl_gammaramp is set to 0
|
|
if((CVAR_GET_FLOAT(kvGammaRamp) == 0) || sGameGammaTable.InitializeToVideoState())
|
|
{
|
|
// Tell UI components so they can change shading to look the same
|
|
this->GetManager().NotifyGammaChange(theGammaToTry);
|
|
|
|
// aww yeah
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
|
|
char theMessage[256];
|
|
if(theSuccess)
|
|
{
|
|
sprintf(theMessage, "Gamma set to %f.", theGammaToTry);
|
|
}
|
|
else
|
|
{
|
|
sprintf(theMessage, "Display doesn't support downloadable gamma ramps.");
|
|
}
|
|
|
|
if(!theSuccess || (gEngfuncs.GetMaxClients() == 1))
|
|
{
|
|
CenterPrint(theMessage);
|
|
}
|
|
|
|
if(!ReleaseDC(NULL, theDC))
|
|
{
|
|
// emit error about leak
|
|
}
|
|
}
|
|
|
|
//#endif
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
bool AvHHud::SlotInput(int inSlot)
|
|
{
|
|
bool theHandled = false;
|
|
|
|
if(this->mInTopDownMode)
|
|
{
|
|
if((inSlot >= 0) && (inSlot < kNumHotkeyGroups))
|
|
{
|
|
// TODO: Read state of control/duck here
|
|
bool theCreateGroup = false;
|
|
|
|
int theButtonBits = CL_ButtonBits(0);
|
|
if(theButtonBits & IN_DUCK)
|
|
{
|
|
theCreateGroup = true;
|
|
}
|
|
|
|
int theBaseOffset = theCreateGroup ? GROUP_CREATE_1 : GROUP_SELECT_1;
|
|
|
|
this->mGroupEvent = (AvHMessageID)(theBaseOffset + inSlot);
|
|
|
|
theHandled = true;
|
|
}
|
|
}
|
|
|
|
return theHandled;
|
|
}
|
|
|
|
int AvHHud::Redraw( float flTime, int intermission )
|
|
{
|
|
|
|
if (!gViewPort->IsOptionsMenuVisible() &&
|
|
!gParticleEditorHandler.GetInEditMode())
|
|
{
|
|
Render();
|
|
}
|
|
|
|
int theRC = UIHud::Redraw(flTime, intermission);
|
|
|
|
return theRC;
|
|
}
|
|
|
|
void AvHHud::ResetGammaAtExit()
|
|
{
|
|
sPregameGammaTable.InitializeToVideoState();
|
|
}
|
|
|
|
int AvHHud::ResetGammaAtExitForOnExit()
|
|
{
|
|
sPregameGammaTable.InitializeToVideoState();
|
|
return TRUE;
|
|
}
|
|
|
|
void AvHHud::ResetGammaAtExit(int inSig)
|
|
{
|
|
AvHHud::ResetGammaAtExit();
|
|
}
|
|
|
|
void AvHHud::ResetTopDownUI()
|
|
{
|
|
this->mGhostBuilding = MESSAGE_NULL;
|
|
this->mSelected.clear();
|
|
this->mSelectionEffects.clear();
|
|
|
|
gCommanderHandler.Reset();
|
|
|
|
for(int i = 0; i < kNumHotkeyGroups; i++)
|
|
{
|
|
this->mGroups[i].clear();
|
|
this->mGroupTypes[i] = AVH_USER3_NONE;
|
|
this->mGroupAlerts[i] = ALERT_NONE;
|
|
}
|
|
|
|
this->mSelectAllGroup.clear();
|
|
}
|
|
|
|
void AvHHud::SetSelectingWeaponID(int inWeaponID, int inR, int inG, int inB)
|
|
{
|
|
if(gEngfuncs.pfnGetCvarFloat(kvAutoHelp))
|
|
{
|
|
if(inR != -1)
|
|
{
|
|
this->mHelpMessage.SetR(inR);
|
|
}
|
|
if(inG != -1)
|
|
{
|
|
this->mHelpMessage.SetG(inG);
|
|
}
|
|
if(inB != -1)
|
|
{
|
|
this->mHelpMessage.SetB(inB);
|
|
}
|
|
|
|
this->mSelectingWeaponID = inWeaponID;
|
|
}
|
|
}
|
|
|
|
void AvHHud::SetTechHelpText(const string& inTechHelpText)
|
|
{
|
|
this->mTechHelpText = inTechHelpText;
|
|
}
|
|
|
|
BIND_MESSAGE(Countdown);
|
|
int AvHHud::Countdown(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
NetMsg_UpdateCountdown( pbuf, iSize, this->mNumTicksToPlay );
|
|
this->mLastTickPlayed = 1;
|
|
this->mCountDownClock = this->m_flTime;
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool AvHHud::GetAmbientSoundNameFromIndex(string& outSoundName, int inSoundIndex) const
|
|
{
|
|
bool theFoundName = false;
|
|
|
|
if(inSoundIndex < (int)(this->mSoundNameList.size()))
|
|
{
|
|
outSoundName = this->mSoundNameList[inSoundIndex];
|
|
theFoundName = true;
|
|
}
|
|
|
|
return theFoundName;
|
|
}
|
|
|
|
void AvHHud::ModifyAmbientSoundEntryIfChanged(bool inSoundOn, int inSoundIndex, int inEntIndex, float inTimeStarted, int inVolume, int inFadeDistance, int inFlags, Vector inOrigin)
|
|
{
|
|
bool theFoundSound = false;
|
|
|
|
// Look up sound using inSoundIndex
|
|
string theSoundName;
|
|
if(this->GetAmbientSoundNameFromIndex(theSoundName, inSoundIndex))
|
|
{
|
|
// Loop through current sounds
|
|
for(AmbientSoundListType::iterator theIter = this->mAmbientSounds.begin(); theIter != this->mAmbientSounds.end(); )
|
|
{
|
|
bool theErasedSound = false;
|
|
if(theIter->GetEntityIndex() == inEntIndex)
|
|
{
|
|
// If found, remember that we found it
|
|
theFoundSound = true;
|
|
|
|
// Set position
|
|
theIter->SetPosition(inOrigin);
|
|
|
|
// If we're turning off sound, kill the sound
|
|
if(!inSoundOn)
|
|
{
|
|
theIter->ClearData();
|
|
theIter = this->mAmbientSounds.erase(theIter);
|
|
theErasedSound = true;
|
|
}
|
|
}
|
|
if(!theErasedSound)
|
|
{
|
|
theIter++;
|
|
}
|
|
}
|
|
|
|
// If we're turning a sound on, and we didn't find one
|
|
if(inSoundOn && !theFoundSound)
|
|
{
|
|
bool theLooping = inFlags & 2;
|
|
float theTimeElapsed = this->mTimeOfLastUpdate - inTimeStarted;
|
|
|
|
// Add new entry with these values
|
|
this->mAmbientSounds.push_back(AvHAmbientSound(theSoundName, inVolume, inFadeDistance, theLooping, inOrigin, inEntIndex, theTimeElapsed));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We may not have the sound list yet, it's OK
|
|
//ASSERT(false);
|
|
}
|
|
}
|
|
|
|
// tankefugl:
|
|
void AvHHud::SetCenterText(const char* inText)
|
|
{
|
|
LocalizeString(inText, this->mCenterText);
|
|
this->mCenterTextTime = this->mTimeOfLastUpdate;
|
|
}
|
|
|
|
void AvHHud::ClearCenterText()
|
|
{
|
|
this->mCenterText.clear();
|
|
this->mCenterTextTime = -1;
|
|
}
|
|
|
|
// :tankefugl
|
|
|
|
// Look at incoming order. If we are one of the receivers, play a HUD sound
|
|
// indicating our new order
|
|
void AvHHud::OrderNotification(const AvHOrder& inOrder)
|
|
{
|
|
//if(!inOrder.GetOrderCompleted())
|
|
//{
|
|
// If we are commander, or we are in receiver list
|
|
int theLocalPlayer = gEngfuncs.GetLocalPlayer()->index;
|
|
if((this->GetHUDUser3() == AVH_USER3_COMMANDER_PLAYER) || (inOrder.GetHasReceiver(theLocalPlayer)))
|
|
{
|
|
// Do a switch on the order type
|
|
AvHOrderType theOrderType = inOrder.GetOrderType();
|
|
AvHHUDSound theSound = HUD_SOUND_INVALID;
|
|
|
|
// tankefugl: 0000992
|
|
// popup indicator for order
|
|
bool thePopup = false;
|
|
|
|
// Play HUD sound depending on order
|
|
switch(theOrderType)
|
|
{
|
|
case ORDERTYPEL_MOVE:
|
|
theSound = HUD_SOUND_ORDER_MOVE;
|
|
thePopup = true;
|
|
break;
|
|
|
|
case ORDERTYPET_ATTACK:
|
|
theSound = HUD_SOUND_ORDER_ATTACK;
|
|
thePopup = true;
|
|
break;
|
|
|
|
case ORDERTYPET_BUILD:
|
|
theSound = HUD_SOUND_ORDER_BUILD;
|
|
thePopup = true;
|
|
break;
|
|
|
|
case ORDERTYPET_GUARD:
|
|
theSound = HUD_SOUND_ORDER_GUARD;
|
|
thePopup = true;
|
|
break;
|
|
|
|
case ORDERTYPET_WELD:
|
|
theSound = HUD_SOUND_ORDER_WELD;
|
|
thePopup = true;
|
|
break;
|
|
|
|
case ORDERTYPET_GET:
|
|
theSound = HUD_SOUND_ORDER_GET;
|
|
thePopup = true;
|
|
break;
|
|
}
|
|
|
|
if((this->GetHUDUser3() == AVH_USER3_MARINE_PLAYER) && (inOrder.GetOrderCompleted()))
|
|
{
|
|
theSound = HUD_SOUND_ORDER_COMPLETE;
|
|
}
|
|
|
|
this->PlayHUDSound(theSound);
|
|
|
|
// tankefugl: 0000992 | 0001052
|
|
if (thePopup && (this->GetInTopDownMode() == false) && (inOrder.GetOrderActive()))
|
|
{
|
|
this->SetDisplayOrder(2, this->GetFrameForOrderType(theOrderType), "", "", "");
|
|
}
|
|
// :tankefugl
|
|
}
|
|
//}
|
|
}
|
|
|
|
void AvHHud::ResetComponentsForUser3()
|
|
{
|
|
|
|
this->mPieMenuControl = "";
|
|
|
|
this->GetManager().HideComponents();
|
|
|
|
if(gParticleEditorHandler.GetInEditMode())
|
|
{
|
|
gHUD.GetManager().UnhideComponent(kPSESizeSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSESizeLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEScaleSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEScaleLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEGenerationRateSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEGenerationRateLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEParticleLifetimeSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEParticleLifetimeLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEParticleSystemLifetimeSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEParticleSystemLifetimeLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEMaxParticlesSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEMaxParticlesLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEDrawModeSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEDrawModeLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(PSEGenVelToggleSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEGenVelToggleLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEGenVelShapeSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEGenVelShapeLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEGenVelParamNumSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEGenVelParamNumLabel);
|
|
|
|
gHUD.GetManager().UnhideComponent(kPSEGenVelParamValueSlider);
|
|
gHUD.GetManager().UnhideComponent(kPSEGenVelParamValueLabel);
|
|
}
|
|
else
|
|
{
|
|
bool theIsCombatMode = (this->mMapMode == MAP_MODE_CO);
|
|
bool theIsNSMode = (this->mMapMode == MAP_MODE_NS);
|
|
|
|
if((this->GetHUDPlayMode() == PLAYMODE_PLAYING) && !this->GetIsNotInControl() && !gViewPort->IsOptionsMenuVisible())
|
|
{
|
|
switch(this->GetHUDUser3())
|
|
{
|
|
case AVH_USER3_MARINE_PLAYER:
|
|
if(theIsCombatMode)
|
|
{
|
|
this->mPieMenuControl = kSoldierCombatMenu;
|
|
}
|
|
else if(theIsNSMode)
|
|
{
|
|
this->mPieMenuControl = kSoldierMenu;
|
|
}
|
|
|
|
if (g_iUser1 == OBS_NONE)
|
|
{
|
|
this->GetManager().UnhideComponent(mPieMenuControl.c_str());
|
|
}
|
|
|
|
// Removed these for recording footage until they look better
|
|
//this->GetManager().UnhideComponent(kReinforcementsLabel);
|
|
//this->GetManager().UnhideComponent(kResourceLabel);
|
|
//this->GetManager().UnhideComponent(kMouseCursorLabel);
|
|
//this->GetManager().UnhideComponent(kDebugCSPServerLabel);
|
|
//this->GetManager().UnhideComponent(kDebugCSPClientLabel);
|
|
break;
|
|
|
|
case AVH_USER3_COMMANDER_PLAYER:
|
|
if(this->mInTopDownMode)
|
|
{
|
|
this->GetManager().UnhideComponent(kSelectionBox);
|
|
this->GetManager().UnhideComponent(kCommanderResourceLabel);
|
|
//this->GetManager().UnhideComponent(kMouseCursorLabel);
|
|
this->GetManager().UnhideComponent(kLeaveCommanderButton);
|
|
this->GetManager().UnhideComponent(kScroller);
|
|
this->GetManager().UnhideComponent(kTechHelpText);
|
|
this->GetManager().UnhideComponent(kHierarchy);
|
|
this->GetManager().UnhideComponent(kResearchBackgroundPanel);
|
|
this->GetManager().UnhideComponent(kActionButtonsComponents);
|
|
this->GetManager().UnhideComponent(kSelectAllImpulsePanel);
|
|
//this->GetManager().UnhideComponent(kTopDownHUDTopSpritePanel);
|
|
//this->GetManager().UnhideComponent(kTopDownHUDBottomSpritePanel);
|
|
}
|
|
//this->GetManager().UnhideComponent(kReinforcementsLabel);
|
|
break;
|
|
|
|
case AVH_USER3_ALIEN_PLAYER1:
|
|
case AVH_USER3_ALIEN_PLAYER2:
|
|
case AVH_USER3_ALIEN_PLAYER3:
|
|
case AVH_USER3_ALIEN_PLAYER4:
|
|
case AVH_USER3_ALIEN_PLAYER5:
|
|
if(theIsCombatMode)
|
|
{
|
|
this->mPieMenuControl = kAlienCombatMenu;
|
|
}
|
|
else if(theIsNSMode)
|
|
{
|
|
this->mPieMenuControl = kAlienMenu;
|
|
}
|
|
|
|
if (g_iUser1 == OBS_NONE)
|
|
{
|
|
this->GetManager().UnhideComponent(mPieMenuControl.c_str());
|
|
}
|
|
|
|
//this->GetManager().UnhideComponent(kMouseCursorLabel);
|
|
//this->GetManager().UnhideComponent(kDebugCSPServerLabel);
|
|
//this->GetManager().UnhideComponent(kDebugCSPClientLabel);
|
|
break;
|
|
|
|
case AVH_USER3_ALIEN_EMBRYO:
|
|
//this->GetManager().UnhideComponent(kAlienMembrane);
|
|
break;
|
|
}
|
|
|
|
if(sShowMap)
|
|
{
|
|
this->GetManager().UnhideComponent(kShowMapHierarchy);
|
|
}
|
|
|
|
mOverviewMap.SetUser3(this->GetHUDUser3());
|
|
|
|
// Update command hierarchy so it can potentially display differently
|
|
if(this->mHierarchy)
|
|
{
|
|
this->mHierarchy->setPos(.0105f*ScreenWidth(), .728*ScreenHeight());
|
|
this->mHierarchy->setSize(.265*ScreenWidth(), .247*ScreenHeight());
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
BIND_MESSAGE(BalanceVar);
|
|
int AvHHud::BalanceVar(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
string name;
|
|
BalanceMessageAction action;
|
|
int ivalue;
|
|
float fvalue;
|
|
string svalue;
|
|
NetMsg_BalanceVar( pbuf, iSize, name, action, ivalue, fvalue, svalue );
|
|
BalanceValueContainer* container = BalanceValueContainerFactory::get();
|
|
|
|
switch( action )
|
|
{
|
|
case BALANCE_ACTION_INSERT_INT:
|
|
container->insert(name,ivalue);
|
|
break;
|
|
case BALANCE_ACTION_INSERT_FLOAT:
|
|
container->insert(name,fvalue);
|
|
break;
|
|
case BALANCE_ACTION_INSERT_STRING:
|
|
container->insert(name,svalue);
|
|
break;
|
|
case BALANCE_ACTION_REMOVE:
|
|
container->remove(name);
|
|
break;
|
|
case BALANCE_ACTION_CLEAR:
|
|
container->clear();
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(GameStatus);
|
|
int AvHHud::GameStatus(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
int status, game_time, timelimit, misc_data;
|
|
AvHMapMode map_mode;
|
|
NetMsg_GameStatus( pbuf, iSize, status, map_mode, game_time, timelimit, misc_data );
|
|
|
|
this->mMapMode = map_mode;
|
|
|
|
switch( status )
|
|
{
|
|
case kGameStatusReset:
|
|
case kGameStatusResetNewMap:
|
|
if(this->mInTopDownMode)
|
|
{
|
|
this->ToggleMouse();
|
|
}
|
|
|
|
this->ResetGame( status == kGameStatusResetNewMap ? true : false );
|
|
break;
|
|
case kGameStatusEnded: // Victor determined, but we are still in the cooldown time
|
|
this->mGameEnded = true; // Stop research
|
|
break;
|
|
case kGameStatusGameTime:
|
|
this->mGameTime = game_time;
|
|
this->mTimeLimit = timelimit;
|
|
this->mCombatAttackingTeamNumber = misc_data;
|
|
break;
|
|
case kGameStatusUnspentLevels:
|
|
this->mExperienceLevelSpent = misc_data;
|
|
break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(MiniMap);
|
|
int AvHHud::MiniMap(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
gMiniMap.ReceiveFromNetworkStream( pbuf, iSize );
|
|
return 1;
|
|
}
|
|
|
|
// tankefugl: 0000971
|
|
BIND_MESSAGE(IssueOrder);
|
|
int AvHHud::IssueOrder(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
int ordertype, ordersource, ordertarget;
|
|
NetMsg_IssueOrder( pbuf, iSize, ordertype, ordersource, ordertarget);
|
|
|
|
float now = this->GetTimeOfLastUpdate();
|
|
TeammateOrderListType::iterator theIter = this->mTeammateOrder.find(ordersource);
|
|
if (theIter == this->mTeammateOrder.end())
|
|
{
|
|
this->mTeammateOrder.insert(theIter, pair<int, TeammateOrderType>(ordersource, TeammateOrderType(ordertype, now)));
|
|
}
|
|
else
|
|
{
|
|
TeammateOrderType *theOrder = &((*theIter).second);
|
|
(*theOrder).first = ordertype;
|
|
(*theOrder).second = now;
|
|
}
|
|
|
|
if (this->GetInTopDownMode() == false)
|
|
{
|
|
cl_entity_s* theLocalPlayer = gEngfuncs.GetLocalPlayer();
|
|
if (theLocalPlayer->index == ordertarget)
|
|
{
|
|
hud_player_info_t info;
|
|
memset(&info, 0, sizeof(info));
|
|
GetPlayerInfo(ordersource, &info);
|
|
|
|
string temp;
|
|
string nameFormat;
|
|
// fetch from titles.txt
|
|
sprintf(temp, "TeammateOrder%d", ordertype);
|
|
LocalizeString(temp.c_str(), nameFormat);
|
|
sprintf(temp, nameFormat.c_str(), info.name);
|
|
|
|
this->SetDisplayOrder(1, ordertype, temp, "", "");
|
|
}
|
|
if (theLocalPlayer->index == ordersource)
|
|
{
|
|
this->mCurrentOrderTarget = ordertarget;
|
|
this->mCurrentOrderType = ordertype;
|
|
this->mCurrentOrderTime = now;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
// :tankefugl
|
|
|
|
BIND_MESSAGE(ServerVar);
|
|
int AvHHud::ServerVar(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
string name, value;
|
|
NetMsg_ServerVar( pbuf, iSize, name, value );
|
|
|
|
mServerVariableMap[name] = value;
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(Progress);
|
|
int AvHHud::Progress(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
NetMsg_ProgressBar( pbuf, iSize, this->mProgressBarEntityIndex, this->mProgressBarParam );
|
|
return 1;
|
|
}
|
|
|
|
// Start the game over. Called after the game ends and also after a map change
|
|
void AvHHud::ResetGame(bool inMapChanged)
|
|
{
|
|
UIHud::ResetGame();
|
|
|
|
this->mResources = 0;
|
|
this->mMaxResources = -1;
|
|
this->mVisualResources = 0;
|
|
this->mUser2OfLastResourceMessage = 0;
|
|
this->mTimeOfLastEntityUpdate = -1;
|
|
this->mVisualEnergyLevel = 0;
|
|
this->mUser2OfLastEnergyLevel = 0;
|
|
|
|
// Don't use a menu yet
|
|
//this->ResetUpgradeCosts();
|
|
|
|
// Reset armor as well.
|
|
//this->mArmorLevel = ARMOR_BASE;
|
|
|
|
// Clear out all particle systems and templates
|
|
if(inMapChanged)
|
|
{
|
|
gParticleTemplateList.Clear();
|
|
this->mTimeOfLastUpdate = 0.0f;
|
|
this->mInfoLocationList.clear();
|
|
}
|
|
|
|
// puzl: 1066 reset overview map on game restart
|
|
gHUD.GetOverviewMap().Clear();
|
|
|
|
AvHParticleSystemManager::Instance()->Reset();
|
|
|
|
this->mTechSlotManager.Clear();
|
|
|
|
this->mTechNodes.Clear();
|
|
|
|
this->mTimeOfCurrentUpdate = 0.0f;
|
|
|
|
// On game reset, clear blips (happens on server as well)
|
|
|
|
this->mEntityHierarchy.Clear();
|
|
|
|
// Clear selection effects
|
|
this->mSelectionEffects.clear();
|
|
|
|
// End any jetpack effects
|
|
//EndJetpackEffects();
|
|
|
|
// Clear client scripts
|
|
AvHScriptManager::Instance()->Reset();
|
|
|
|
// Selection and commander variables
|
|
this->mNumLocalSelectEvents = 0;
|
|
this->mMapMode = MAP_MODE_UNDEFINED;
|
|
this->mInTopDownMode = false;
|
|
this->mLeftMouseStarted = false;
|
|
this->mLeftMouseEnded = false;
|
|
this->mPlacingBuilding = false;
|
|
|
|
sShowMap = false;
|
|
|
|
this->StopMusic();
|
|
|
|
for(AmbientSoundListType::iterator theIter = this->mAmbientSounds.begin(); theIter != this->mAmbientSounds.end(); theIter++)
|
|
{
|
|
theIter->ClearData();
|
|
}
|
|
this->mAmbientSounds.clear();
|
|
|
|
this->SetReinforcements(0);
|
|
|
|
this->mOrders.clear();
|
|
|
|
this->mCurrentCursorFrame = 0;
|
|
this->mProgressBarEntityIndex = -1;
|
|
this->mProgressBarParam = -1;
|
|
|
|
this->mEnemyBlips.Clear();
|
|
this->mFriendlyBlips.Clear();
|
|
|
|
// Reset view angles (in case player was in commander mode)
|
|
gViewAngles.z = 0.0f;
|
|
gResetViewAngles = true;
|
|
|
|
// Clear location
|
|
this->mLocationText = "";
|
|
|
|
this->mUpgrades.clear();
|
|
|
|
this->mNumUpgradesAvailable = 0;
|
|
int i;
|
|
for(i = 0; i < ALIEN_UPGRADE_CATEGORY_MAX_PLUS_ONE; i++)
|
|
{
|
|
this->mCurrentUpgradeCategory[i] = ALIEN_UPGRADE_CATEGORY_INVALID;
|
|
}
|
|
|
|
// Remove all decals (no idea how to get the total decals)
|
|
//for(i = 0; i < 1024; i++)
|
|
//{
|
|
// gEngfuncs.pEfxAPI->R_DecalRemoveAll(i);
|
|
//}
|
|
RemoveAllDecals();
|
|
|
|
// Remove temp ghost building
|
|
if(this->mLastGhostBuilding)
|
|
{
|
|
this->mLastGhostBuilding->die = -1;
|
|
}
|
|
|
|
this->mNumericalInfoEffects.clear();
|
|
this->mTimeOfNextHudSound = -1;
|
|
this->mLastHUDSoundPlayed = HUD_SOUND_INVALID;
|
|
|
|
//this->mTooltips.clear();
|
|
|
|
this->mHiveInfoList.clear();
|
|
|
|
this->mDesiredGammaSlope = kDefaultMapGamma;
|
|
this->mRecordingLastFrame = false;
|
|
this->mTimeOfLastHelpText = -1;
|
|
this->mDisplayedToolTipList.clear();
|
|
this->mCurrentWeaponID = -1;
|
|
this->mCurrentWeaponEnabled = false;
|
|
|
|
// Is this needed?
|
|
//this->mCurrentUIMode = MAIN_MODE;
|
|
|
|
this->mMenuTechSlots = 0;
|
|
this->mPendingRequests.clear();
|
|
|
|
for(i = 0; i < kNumHotkeyGroups; i++)
|
|
{
|
|
this->mGroups[i].clear();
|
|
this->mGroupTypes[i] = AVH_USER3_NONE;
|
|
this->mGroupAlerts[i] = ALERT_NONE;
|
|
}
|
|
this->mSelectAllGroup.clear();
|
|
|
|
this->mCurrentSquad = 0;
|
|
this->mBlinkingAlertType = 0;
|
|
|
|
this->mLastTeamSpectated = TEAM_IND;
|
|
|
|
this->mStructureNotificationList.clear();
|
|
|
|
this->mGameTime = -1;
|
|
this->mTimeLimit = -1;
|
|
this->mCombatAttackingTeamNumber = 0;
|
|
this->mGameEnded = false;
|
|
|
|
this->mExperience = 0;
|
|
this->mExperienceLevel = 1;
|
|
this->mExperienceLevelLastDrawn = 1;
|
|
this->mExperienceLevelSpent = 0;
|
|
this->mTimeOfLastLevelUp = -1;
|
|
|
|
memset(this->mMenuImpulses, MESSAGE_NULL, sizeof(AvHMessageID)*kNumUpgradeLines);
|
|
|
|
// tankefugl: 0000992 & 0000971
|
|
this->mTeammateOrder.clear();
|
|
this->mCurrentOrderTarget = 0;
|
|
this->mCurrentOrderType = 0;
|
|
this->mCurrentOrderTime = 0.0f;
|
|
|
|
this->mDisplayOrderTime = 0.0f;
|
|
this->mDisplayOrderType = 0;
|
|
this->mDisplayOrderIndex = 0;
|
|
this->mDisplayOrderText1 = "";
|
|
this->mDisplayOrderText2 = "";
|
|
this->mDisplayOrderText3 = "";
|
|
|
|
this->mCenterText.clear();
|
|
this->mCenterTextTime = -1;
|
|
// :tankefugl
|
|
|
|
// SCRIPTENGINE:
|
|
if (inMapChanged)
|
|
{
|
|
gLUA->Init();
|
|
gLUA->LoadLUAForMap(this->GetMapName().c_str());
|
|
}
|
|
// :SCRIPTENGINE
|
|
}
|
|
|
|
// SCRIPTENGINE:
|
|
BIND_MESSAGE(LUAmsg);
|
|
int AvHHud::LUAmsg(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
int arguments;
|
|
lua_State *L = lua_newthread(gLUA->mGlobalContext);
|
|
|
|
NetMsg_LUAMessage(pbuf, iSize, L, arguments);
|
|
|
|
if (lua_resume(L, arguments))
|
|
{
|
|
AvHLUA_OnError(lua_tostring(L, -1));
|
|
}
|
|
return 1;
|
|
}
|
|
// :SCRIPTENGINE
|
|
|
|
BIND_MESSAGE(SetGmma);
|
|
int AvHHud::SetGmma(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
NetMsg_SetGammaRamp( pbuf, iSize, this->mDesiredGammaSlope );
|
|
if (!mSteamUIActive)
|
|
{
|
|
this->SetGamma(this->mDesiredGammaSlope);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(BlipList);
|
|
int AvHHud::BlipList(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
bool friendly_blips;
|
|
AvHVisibleBlipList list;
|
|
NetMsg_BlipList( pbuf, iSize, friendly_blips, list );
|
|
|
|
float theCurrentTime = gEngfuncs.GetClientTime();
|
|
|
|
if( friendly_blips )
|
|
{
|
|
this->mFriendlyBlips.Clear();
|
|
this->mFriendlyBlips.AddBlipList(list);
|
|
this->mFriendlyBlips.SetTimeBlipsReceived(theCurrentTime);
|
|
}
|
|
else
|
|
{
|
|
this->mEnemyBlips.Clear();
|
|
this->mEnemyBlips.AddBlipList(list);
|
|
this->mEnemyBlips.SetTimeBlipsReceived(theCurrentTime);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(ClScript);
|
|
int AvHHud::ClScript(const char *pszName, int iSize, void *pbuf)
|
|
{
|
|
StringList script_names;
|
|
NetMsg_ClientScripts( pbuf, iSize, script_names );
|
|
StringList::iterator current, end = script_names.end();
|
|
for( current = script_names.begin(); current != end; ++current )
|
|
{
|
|
AvHScriptManager::Instance()->RunScript(current->c_str());
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(Particles);
|
|
int AvHHud::Particles(const char *pszName, int iSize, void *pbuf)
|
|
{
|
|
AvHParticleTemplate particle_template;
|
|
NetMsg_SetParticleTemplate( pbuf, iSize, particle_template );
|
|
gParticleTemplateList.Insert( particle_template );
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(SoundNames);
|
|
int AvHHud::SoundNames(const char *pszName, int iSize, void *pbuf)
|
|
{
|
|
bool theClearSoundList;
|
|
string sound_name;
|
|
NetMsg_SetSoundNames( pbuf, iSize, theClearSoundList, sound_name );
|
|
|
|
if(theClearSoundList)
|
|
{
|
|
this->mSoundNameList.clear();
|
|
}
|
|
else
|
|
{
|
|
this->mSoundNameList.push_back(sound_name);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(SetSelect);
|
|
int AvHHud::SetSelect(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
Selection selection;
|
|
NetMsg_SetSelect( pbuf, iSize, selection );
|
|
|
|
EntityListType theGroup;
|
|
|
|
switch( selection.group_number )
|
|
{
|
|
case 0:
|
|
this->mTrackingEntity = selection.tracking_entity;
|
|
if( selection.selected_entities != this->mSelected )
|
|
{
|
|
this->mSelectionJustChanged = true;
|
|
this->mSelected = selection.selected_entities;
|
|
}
|
|
break;
|
|
case kSelectAllHotGroup:
|
|
this->mSelectAllGroup = selection.selected_entities;
|
|
break;
|
|
default:
|
|
this->mGroups[selection.group_number-1] = selection.selected_entities;
|
|
this->mGroupTypes[selection.group_number-1] = selection.group_type;
|
|
this->mGroupAlerts[selection.group_number-1] = selection.group_alert;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(SetRequest);
|
|
int AvHHud::SetRequest(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
int request_type, request_count;
|
|
NetMsg_SetRequest( pbuf, iSize, request_type, request_count );
|
|
this->mPendingRequests[(AvHMessageID)request_type] = request_count;
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(SetOrder);
|
|
int AvHHud::SetOrder(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
AvHOrder theNewOrder;
|
|
NetMsg_SetOrder( pbuf, iSize, theNewOrder );
|
|
|
|
AvHChangeOrder(this->mOrders, theNewOrder);
|
|
|
|
// Give feedback on order
|
|
this->OrderNotification(theNewOrder);
|
|
|
|
// Run through orders, deleting any that are complete
|
|
for(OrderListType::iterator theIter = this->mOrders.begin(); theIter != this->mOrders.end(); /* no inc */)
|
|
{
|
|
if(theIter->GetOrderCompleted())
|
|
{
|
|
this->mOrders.erase(theIter);
|
|
}
|
|
else
|
|
{
|
|
theIter++;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(SetupMap);
|
|
int AvHHud::SetupMap(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
bool is_location, draw_background;
|
|
float min_extents[3], max_extents[3];
|
|
string name;
|
|
NetMsg_SetupMap( pbuf, iSize, is_location, name, min_extents, max_extents, draw_background );
|
|
|
|
if( is_location )
|
|
{
|
|
vec3_t theMaxExtent;
|
|
theMaxExtent.x = max_extents[0];
|
|
theMaxExtent.y = max_extents[1];
|
|
theMaxExtent.z = max_extents[2];
|
|
vec3_t theMinExtent;
|
|
theMinExtent.x = min_extents[0];
|
|
theMinExtent.y = min_extents[1];
|
|
theMinExtent.z = min_extents[2];
|
|
|
|
this->mInfoLocationList.push_back( AvHBaseInfoLocation( name, theMaxExtent, theMinExtent ) );
|
|
}
|
|
else
|
|
{
|
|
this->mMapName = name;
|
|
this->mMapExtents.SetMaxMapX( max_extents[0] );
|
|
this->mMapExtents.SetMaxMapY( max_extents[1] );
|
|
this->mMapExtents.SetMaxViewHeight( max_extents[2] );
|
|
this->mMapExtents.SetMinMapX( min_extents[0] );
|
|
this->mMapExtents.SetMinMapY( min_extents[1] );
|
|
this->mMapExtents.SetMinViewHeight( min_extents[2] );
|
|
this->mMapExtents.SetDrawMapBG( draw_background );
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
BIND_MESSAGE(SetTopDown);
|
|
int AvHHud::SetTopDown(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
bool is_menu_tech, is_top_down;
|
|
float position[3];
|
|
int tech_slots;
|
|
NetMsg_SetTopDown( pbuf, iSize, is_menu_tech, is_top_down, position, tech_slots );
|
|
|
|
if(is_menu_tech)
|
|
{
|
|
this->mMenuTechSlots = tech_slots;
|
|
}
|
|
else
|
|
{
|
|
if(this->mInTopDownMode && !is_top_down)
|
|
{
|
|
// Switch away from top down mode
|
|
this->mInTopDownMode = false;
|
|
this->ToggleMouse();
|
|
|
|
// Reset angles
|
|
gViewAngles[0] = position[0];
|
|
gViewAngles[1] = position[1];
|
|
gViewAngles[2] = position[2];
|
|
|
|
gResetViewAngles = true;
|
|
|
|
this->mSelectionEffects.clear();
|
|
}
|
|
else if(!this->mInTopDownMode && is_top_down)
|
|
{
|
|
// Switch to top down mode!
|
|
this->mInTopDownMode = true;
|
|
this->ToggleMouse();
|
|
}
|
|
|
|
if(is_top_down)
|
|
{
|
|
// Read new PAS
|
|
this->mCommanderPAS.x = position[0];
|
|
this->mCommanderPAS.y = position[1];
|
|
this->mCommanderPAS.z = position[2];
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
BIND_MESSAGE(EntHier);
|
|
int AvHHud::EntHier(const char *pszName, int iSize, void *pbuf)
|
|
{
|
|
MapEntityMap new_items;
|
|
EntityListType old_items;
|
|
NetMsg_UpdateEntityHierarchy( pbuf, iSize, new_items, old_items );
|
|
|
|
MapEntityMap::iterator current, end = new_items.end();
|
|
for( current = new_items.begin(); current != end; ++current )
|
|
{
|
|
this->mEntityHierarchy.InsertEntity( current->first, current->second );
|
|
}
|
|
|
|
EntityListType::iterator d_current, d_end = old_items.end();
|
|
for( d_current = old_items.begin(); d_current != d_end; ++d_current )
|
|
{
|
|
this->mEntityHierarchy.DeleteEntity( *d_current );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
BIND_MESSAGE(EditPS);
|
|
int AvHHud::EditPS(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
int particle_index;
|
|
NetMsg_EditPS( pbuf, iSize, particle_index );
|
|
AvHParticleEditorHandler::SetEditIndex((uint32)particle_index);
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(Fog);
|
|
int AvHHud::Fog(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
bool enabled;
|
|
int R, G, B;
|
|
float start, end;
|
|
NetMsg_Fog( pbuf, iSize, enabled, R, G, B, start, end );
|
|
|
|
this->mFogActive = enabled;
|
|
if(enabled)
|
|
{
|
|
this->mFogColor.x = R;
|
|
this->mFogColor.y = G;
|
|
this->mFogColor.z = B;
|
|
this->mFogStart = start;
|
|
this->mFogEnd = end;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(ListPS);
|
|
int AvHHud::ListPS(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
string name;
|
|
NetMsg_ListPS( pbuf, iSize, name );
|
|
this->m_SayText.SayTextPrint(name.c_str(), 256, 0);
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(PlayHUDNot);
|
|
int AvHHud::PlayHUDNot(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
int message_id, sound;
|
|
float location_x, location_y;
|
|
NetMsg_PlayHUDNotification( pbuf, iSize, message_id, sound, location_x, location_y );
|
|
|
|
if(message_id == 0)
|
|
{
|
|
// Hack to avoid adding another network message (at max)
|
|
if(!this->GetInTopDownMode())
|
|
{
|
|
switch(sound)
|
|
{
|
|
case HUD_SOUND_SQUAD1:
|
|
this->mCurrentSquad = 1;
|
|
break;
|
|
case HUD_SOUND_SQUAD2:
|
|
this->mCurrentSquad = 2;
|
|
break;
|
|
case HUD_SOUND_SQUAD3:
|
|
this->mCurrentSquad = 3;
|
|
break;
|
|
case HUD_SOUND_SQUAD4:
|
|
this->mCurrentSquad = 4;
|
|
break;
|
|
case HUD_SOUND_SQUAD5:
|
|
this->mCurrentSquad = 5;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch((AvHHUDSound)sound)
|
|
{
|
|
// Danger
|
|
case HUD_SOUND_MARINE_SOLDIER_UNDER_ATTACK:
|
|
case HUD_SOUND_MARINE_BASE_UNDER_ATTACK:
|
|
case HUD_SOUND_MARINE_SENTRYDAMAGED:
|
|
case HUD_SOUND_MARINE_SOLDIERLOST:
|
|
case HUD_SOUND_MARINE_CCUNDERATTACK:
|
|
this->mBlinkingAlertType = 2;
|
|
AddMiniMapAlert(location_x, location_y);
|
|
break;
|
|
|
|
// Just research or something like that
|
|
case HUD_SOUND_MARINE_UPGRADE_COMPLETE:
|
|
case HUD_SOUND_MARINE_RESEARCHCOMPLETE:
|
|
this->mBlinkingAlertType = 1;
|
|
AddMiniMapAlert(location_x, location_y);
|
|
break;
|
|
}
|
|
}
|
|
|
|
this->PlayHUDSound((AvHHUDSound)sound);
|
|
}
|
|
else
|
|
{
|
|
// Push back icon
|
|
HUDNotificationType theNotification;
|
|
theNotification.mStructureID = (AvHMessageID)sound; //message_id;
|
|
theNotification.mTime = this->mTimeOfCurrentUpdate;
|
|
theNotification.mLocation = Vector(location_x, location_y, 0.0f);
|
|
|
|
if(CVAR_GET_FLOAT(kvBuildMessages))
|
|
{
|
|
this->mStructureNotificationList.push_back(theNotification);
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(AlienInfo);
|
|
int AvHHud::AlienInfo(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
bool was_hive_info;
|
|
AvHAlienUpgradeListType upgrades;
|
|
HiveInfoListType hives;
|
|
NetMsg_AlienInfo( pbuf, iSize, was_hive_info, this->mUpgrades, this->mHiveInfoList );
|
|
return 1;
|
|
}
|
|
|
|
void AvHHud::PlayHUDSound(const char *szSound, float vol, float inSoundLength)
|
|
{
|
|
if((this->mTimeOfNextHudSound == -1) || (this->mTimeOfCurrentUpdate > this->mTimeOfNextHudSound))
|
|
{
|
|
if(szSound)
|
|
{
|
|
char theSoundName[512];
|
|
strcpy(theSoundName, szSound);
|
|
gEngfuncs.pfnPlaySoundByName(theSoundName, vol);
|
|
this->mTimeOfNextHudSound = this->mTimeOfCurrentUpdate + inSoundLength;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::PlayHUDSound(int iSound, float vol, float inSoundLength)
|
|
{
|
|
if((this->mTimeOfNextHudSound == -1) || (this->mTimeOfCurrentUpdate > this->mTimeOfNextHudSound))
|
|
{
|
|
gEngfuncs.pfnPlaySoundByIndex(iSound, vol);
|
|
this->mTimeOfNextHudSound = this->mTimeOfCurrentUpdate + inSoundLength;
|
|
}
|
|
}
|
|
|
|
void AvHHud::PlayHUDSound(AvHHUDSound inSound)
|
|
{
|
|
char* theSoundPtr = NULL;
|
|
float theVolume = 1.0f;
|
|
|
|
// Some sounds are forced, but don't allow them to be spammed or cut themselves off
|
|
bool theForceSound = AvHSHUGetForceHUDSound(inSound) && (inSound != this->mLastHUDSoundPlayed);
|
|
|
|
// tankefugl: 0000407
|
|
bool theAutoHelpEnabled = gEngfuncs.pfnGetCvarFloat(kvAutoHelp);
|
|
// :tankefugl
|
|
|
|
if((this->mTimeOfNextHudSound == -1) || (this->mTimeOfCurrentUpdate >= this->mTimeOfNextHudSound) || theForceSound)
|
|
{
|
|
float theSoundLength = 2.0f;
|
|
|
|
switch(inSound)
|
|
{
|
|
case HUD_SOUND_POINTS_SPENT:
|
|
theSoundPtr = kPointsSpentSound;
|
|
theSoundLength = .2f;
|
|
break;
|
|
case HUD_SOUND_COUNTDOWN:
|
|
theSoundPtr = kCountdownSound;
|
|
theSoundLength = 0.0f;
|
|
break;
|
|
case HUD_SOUND_SELECT:
|
|
if(gHUD.GetIsAlien())
|
|
theSoundPtr = kSelectAlienSound;
|
|
else
|
|
theSoundPtr = kSelectSound;
|
|
|
|
// Set to 0 so it never blocks other sounds
|
|
theVolume = .2f;
|
|
theSoundLength = 0.0f;
|
|
break;
|
|
case HUD_SOUND_SQUAD1:
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
theSoundPtr = kSquad1Sound;
|
|
theSoundLength = 1.2f;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kMarineSquad1Sound;
|
|
theSoundLength = 2.0f;
|
|
}
|
|
break;
|
|
case HUD_SOUND_SQUAD2:
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
theSoundPtr = kSquad2Sound;
|
|
theSoundLength = 1.2f;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kMarineSquad2Sound;
|
|
theSoundLength = 2.0f;
|
|
}
|
|
break;
|
|
case HUD_SOUND_SQUAD3:
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
theSoundPtr = kSquad3Sound;
|
|
theSoundLength = 1.2f;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kMarineSquad3Sound;
|
|
theSoundLength = 2.0f;
|
|
}
|
|
break;
|
|
case HUD_SOUND_SQUAD4:
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
theSoundPtr = kSquad4Sound;
|
|
theSoundLength = 1.2f;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kMarineSquad4Sound;
|
|
theSoundLength = 2.0f;
|
|
}
|
|
break;
|
|
case HUD_SOUND_SQUAD5:
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
theSoundPtr = kSquad5Sound;
|
|
theSoundLength = 1.2f;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kMarineSquad5Sound;
|
|
theSoundLength = 2.0f;
|
|
}
|
|
break;
|
|
case HUD_SOUND_PLACE_BUILDING:
|
|
theSoundPtr = kPlaceBuildingSound;
|
|
theSoundLength = .2f;
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_POINTS_RECEIVED:
|
|
theSoundPtr = kMarinePointsReceivedSound;
|
|
theSoundLength = 1.42f;
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_RESEARCHCOMPLETE:
|
|
theSoundPtr = kMarineResearchComplete;
|
|
theSoundLength = 2.0f;
|
|
break;
|
|
case HUD_SOUND_MARINE_SOLDIER_UNDER_ATTACK:
|
|
theSoundPtr = kMarineSoldierUnderAttack;
|
|
theSoundLength = 3.0f;
|
|
break;
|
|
case HUD_SOUND_MARINE_CCONLINE:
|
|
if(rand() % 2)
|
|
{
|
|
theSoundPtr = kMarineCCOnline1;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kMarineCCOnline2;
|
|
}
|
|
theSoundLength = 2.3f;
|
|
break;
|
|
case HUD_SOUND_MARINE_CCUNDERATTACK:
|
|
if(rand() % 2)
|
|
{
|
|
theSoundPtr = kMarineCCUnderAttack1;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kMarineCCUnderAttack2;
|
|
}
|
|
theSoundLength = 3.0f;
|
|
break;
|
|
case HUD_SOUND_MARINE_COMMANDER_EJECTED:
|
|
theSoundPtr = kMarineCommanderEjected;
|
|
theSoundLength = 3.0f;
|
|
break;
|
|
case HUD_SOUND_MARINE_BASE_UNDER_ATTACK:
|
|
if(rand() % 2)
|
|
{
|
|
theSoundPtr = kMarineBaseUnderAttack1;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kMarineBaseUnderAttack2;
|
|
}
|
|
theSoundLength = 3.0f;
|
|
break;
|
|
case HUD_SOUND_MARINE_UPGRADE_COMPLETE:
|
|
theSoundPtr = kMarineUpgradeComplete;
|
|
theSoundLength = 1.0f;
|
|
break;
|
|
case HUD_SOUND_MARINE_MORE:
|
|
theSoundPtr = kMarineMoreResources;
|
|
theSoundLength = 1.8f;
|
|
break;
|
|
case HUD_SOUND_MARINE_RESOURCES_LOW:
|
|
theSoundPtr = kMarineLowResources;
|
|
theSoundLength = 2.0f;
|
|
break;
|
|
case HUD_SOUND_MARINE_NEEDS_AMMO:
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineNeedsAmmo1;
|
|
else
|
|
theSoundPtr = kMarineNeedsAmmo2;
|
|
theSoundLength = 1.5f;
|
|
break;
|
|
case HUD_SOUND_MARINE_NEEDS_HEALTH:
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineNeedsHealth1;
|
|
else
|
|
theSoundPtr = kMarineNeedsHealth2;
|
|
theSoundLength = 1.3f;
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_NEEDS_ORDER:
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineNeedsOrder1;
|
|
else
|
|
theSoundPtr = kMarineNeedsOrder2;
|
|
theSoundLength = 1.5f;
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_SOLDIER_LOST:
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineSoldierLost1;
|
|
else
|
|
theSoundPtr = kMarineSoldierLost2;
|
|
theSoundLength = 1.3f;
|
|
break;
|
|
case HUD_SOUND_MARINE_SENTRYFIRING:
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineSentryFiring1;
|
|
else
|
|
theSoundPtr = kMarineSentryFiring2;
|
|
theSoundLength = 1.3f;
|
|
break;
|
|
case HUD_SOUND_MARINE_SENTRYDAMAGED:
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineSentryTakingDamage1;
|
|
else
|
|
theSoundPtr = kMarineSentryTakingDamage2;
|
|
theSoundLength = 1.5f;
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_GIVEORDERS:
|
|
// tankefugl: 0000407
|
|
if (theAutoHelpEnabled)
|
|
{
|
|
theSoundPtr = kMarineGiveOrders;
|
|
theSoundLength = 2.2f;
|
|
}
|
|
// :tankefugl
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_NEEDPORTAL:
|
|
// tankefugl: 0000407
|
|
if (theAutoHelpEnabled)
|
|
{
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineNeedPortal1;
|
|
else
|
|
theSoundPtr = kMarineNeedPortal2;
|
|
theSoundLength = 1.8f;
|
|
}
|
|
// :tankefugl
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_GOTOALERT:
|
|
// tankefugl: 0000407
|
|
if (theAutoHelpEnabled)
|
|
{
|
|
theSoundPtr = kMarineGotoAlert;
|
|
theSoundLength = 2.2f;
|
|
}
|
|
// :tankefugl
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_COMMANDERIDLE:
|
|
// tankefugl: 0000407
|
|
if (theAutoHelpEnabled)
|
|
{
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineCommanderIdle1;
|
|
else
|
|
theSoundPtr = kMarineCommanderIdle2;
|
|
theSoundLength = 1.5f;
|
|
}
|
|
// :tankefugl
|
|
break;
|
|
|
|
case HUD_SOUND_MARINE_ARMORYUPGRADING:
|
|
theSoundPtr = kMarineArmoryUpgrading;
|
|
theSoundLength = 3.4;
|
|
break;
|
|
|
|
case HUD_SOUND_ALIEN_ENEMY_APPROACHES:
|
|
if(rand() %2)
|
|
theSoundPtr = kAlienEnemyApproaches1;
|
|
else
|
|
theSoundPtr = kAlienEnemyApproaches2;
|
|
theSoundLength = 1.6;
|
|
break;
|
|
|
|
case HUD_SOUND_ALIEN_GAMEOVERMAN:
|
|
theSoundPtr = kAlienGameOverMan;
|
|
theSoundLength = 2.2f;
|
|
break;
|
|
|
|
case HUD_SOUND_ALIEN_HIVE_ATTACK:
|
|
theSoundPtr = kAlienHiveAttack;
|
|
theSoundLength = 1.6f;
|
|
break;
|
|
case HUD_SOUND_ALIEN_HIVE_COMPLETE:
|
|
if(rand() % 2)
|
|
theSoundPtr = kAlienHiveComplete1;
|
|
else
|
|
theSoundPtr = kAlienHiveComplete2;
|
|
theSoundLength = 2.1f;
|
|
break;
|
|
case HUD_SOUND_ALIEN_HIVE_DYING:
|
|
if(rand() % 2)
|
|
{
|
|
theSoundPtr = kAlienHiveDying1;
|
|
theSoundLength = 1.7f;
|
|
}
|
|
else
|
|
{
|
|
theSoundPtr = kAlienHiveDying2;
|
|
theSoundLength = 2.4f;
|
|
}
|
|
break;
|
|
case HUD_SOUND_ALIEN_LIFEFORM_ATTACK:
|
|
if(rand() % 2)
|
|
theSoundPtr = kAlienLifeformAttack1;
|
|
else
|
|
theSoundPtr = kAlienLifeformAttack2;
|
|
theSoundLength = 1.8f;
|
|
break;
|
|
case HUD_SOUND_ALIEN_RESOURCES_LOW:
|
|
theSoundPtr = kAlienLowResources;
|
|
theSoundLength = 1.7f;
|
|
break;
|
|
case HUD_SOUND_ALIEN_MESS:
|
|
theSoundPtr = kAlienMess;
|
|
theSoundLength = 2.0f;
|
|
break;
|
|
case HUD_SOUND_ALIEN_MORE:
|
|
if(rand() % 2)
|
|
theSoundPtr = kAlienMoreResources1;
|
|
else
|
|
theSoundPtr = kAlienMoreResources2;
|
|
theSoundLength = 1.8f;
|
|
break;
|
|
case HUD_SOUND_ALIEN_NEED_BUILDERS:
|
|
if(rand() % 2)
|
|
theSoundPtr = kAlienNeedBuilders1;
|
|
else
|
|
theSoundPtr = kAlienNeedBuilders2;
|
|
theSoundLength = 1.4f;
|
|
break;
|
|
|
|
case HUD_SOUND_ALIEN_NEED_BETTER:
|
|
theSoundPtr = kAlienNeedBetter;
|
|
theSoundLength = 2.5f;
|
|
break;
|
|
|
|
case HUD_SOUND_ALIEN_NOW_DONCE:
|
|
theSoundPtr = kAlienNowDonce;
|
|
theSoundLength = 2.1f;
|
|
break;
|
|
|
|
case HUD_SOUND_ALIEN_NEW_TRAIT:
|
|
if(rand() % 2)
|
|
theSoundPtr = kAlienNewTrait1;
|
|
else
|
|
theSoundPtr = kAlienNewTrait2;
|
|
theSoundLength = 1.5f;
|
|
break;
|
|
|
|
case HUD_SOUND_ALIEN_POINTS_RECEIVED:
|
|
theSoundPtr = kAlienPointsReceivedSound;
|
|
theSoundLength = 1.57f;
|
|
break;
|
|
|
|
case HUD_SOUND_ALIEN_RESOURCES_ATTACK:
|
|
if(rand() % 2)
|
|
theSoundPtr = kAlienResourceAttack1;
|
|
else
|
|
theSoundPtr = kAlienResourceAttack2;
|
|
theSoundLength = 2.1f;
|
|
break;
|
|
case HUD_SOUND_ALIEN_STRUCTURE_ATTACK:
|
|
if(rand() % 2)
|
|
theSoundPtr = kAlienStructureAttack1;
|
|
else
|
|
theSoundPtr = kAlienStructureAttack2;
|
|
theSoundLength = 1.9f;
|
|
break;
|
|
case HUD_SOUND_ALIEN_UPGRADELOST:
|
|
theSoundPtr = kAlienUpgradeLost;
|
|
theSoundLength = 1.5f;
|
|
break;
|
|
|
|
case HUD_SOUND_ORDER_MOVE:
|
|
switch(rand() % 4)
|
|
{
|
|
case 0:
|
|
theSoundPtr = kSoundOrderMove1;
|
|
theSoundLength = 1.8f;
|
|
break;
|
|
case 1:
|
|
theSoundPtr = kSoundOrderMove2;
|
|
theSoundLength = 2.3f;
|
|
break;
|
|
case 2:
|
|
theSoundPtr = kSoundOrderMove3;
|
|
theSoundLength = 1.9f;
|
|
break;
|
|
case 3:
|
|
theSoundPtr = kSoundOrderMove4;
|
|
theSoundLength = 2.3f;
|
|
break;
|
|
}
|
|
break;
|
|
case HUD_SOUND_ORDER_ATTACK:
|
|
theSoundPtr = kSoundOrderAttack;
|
|
break;
|
|
case HUD_SOUND_ORDER_BUILD:
|
|
theSoundPtr = kSoundOrderBuild;
|
|
break;
|
|
case HUD_SOUND_ORDER_WELD:
|
|
theSoundPtr = kSoundOrderWeld;
|
|
break;
|
|
case HUD_SOUND_ORDER_GUARD:
|
|
theSoundPtr = kSoundOrderGuard;
|
|
break;
|
|
case HUD_SOUND_ORDER_GET:
|
|
theSoundPtr = kSoundOrderGet;
|
|
break;
|
|
|
|
case HUD_SOUND_ORDER_COMPLETE:
|
|
switch(rand() % 6)
|
|
{
|
|
case 0:
|
|
theSoundPtr = kSoundOrderComplete1;
|
|
theSoundLength = 1.6f;
|
|
break;
|
|
case 1:
|
|
theSoundPtr = kSoundOrderComplete2;
|
|
theSoundLength = 1.9f;
|
|
break;
|
|
case 2:
|
|
theSoundPtr = kSoundOrderComplete3;
|
|
theSoundLength = 1.9f;
|
|
break;
|
|
case 3:
|
|
theSoundPtr = kSoundOrderComplete4;
|
|
theSoundLength = 1.4f;
|
|
break;
|
|
case 4:
|
|
theSoundPtr = kSoundOrderComplete5;
|
|
theSoundLength = 1.6f;
|
|
break;
|
|
case 5:
|
|
theSoundPtr = kSoundOrderComplete6;
|
|
theSoundLength = 1.4f;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case HUD_SOUND_GAMESTART:
|
|
if(this->GetIsMarine())
|
|
{
|
|
if(rand() % 2)
|
|
theSoundPtr = kMarineGameStart1;
|
|
else
|
|
theSoundPtr = kMarineGameStart2;
|
|
theSoundLength = 1.9f;
|
|
}
|
|
else if(this->GetIsAlien())
|
|
{
|
|
if(rand() % 2)
|
|
theSoundPtr = kAlienGameStart1;
|
|
else
|
|
theSoundPtr = kAlienGameStart2;
|
|
theSoundLength = 2.2f;
|
|
}
|
|
break;
|
|
|
|
case HUD_SOUND_YOU_WIN:
|
|
theSoundPtr = kYouWinSound;
|
|
theSoundLength = 6.0f;
|
|
break;
|
|
case HUD_SOUND_YOU_LOSE:
|
|
theSoundPtr = kYouLoseSound;
|
|
theSoundLength = 6.0f;
|
|
break;
|
|
case HUD_SOUND_TOOLTIP:
|
|
theSoundPtr = kTooltipSound;
|
|
// Tooltip sounds should never stop other sounds
|
|
theSoundLength = -1.0f;
|
|
theVolume = .6f;
|
|
break;
|
|
// joev: bug 0000767
|
|
case HUD_SOUND_PLAYERJOIN:
|
|
theSoundPtr = kPlayerJoinedSound;
|
|
theSoundLength = 3.0f;
|
|
theVolume = 1.1;
|
|
break;
|
|
// :joev
|
|
}
|
|
|
|
if(theSoundPtr)
|
|
{
|
|
gEngfuncs.pfnPlaySoundByName(theSoundPtr, theVolume);
|
|
if(theSoundLength >= 0.0f)
|
|
{
|
|
this->mTimeOfNextHudSound = this->mTimeOfCurrentUpdate + theSoundLength;
|
|
}
|
|
this->mLastHUDSoundPlayed = inSound;
|
|
}
|
|
}
|
|
}
|
|
|
|
BIND_MESSAGE(SetTech);
|
|
int AvHHud::SetTech(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
AvHTechNode* theTechNode = NULL;
|
|
NetMsg_SetTechNode( pbuf, iSize, theTechNode );
|
|
this->mTechNodes.InsertNode(theTechNode);
|
|
delete theTechNode;
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(TechSlots);
|
|
int AvHHud::TechSlots(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
AvHTechSlots theNewTechSlots;
|
|
NetMsg_SetTechSlots( pbuf, iSize, theNewTechSlots );
|
|
|
|
this->mTechSlotManager.AddTechSlots(theNewTechSlots);
|
|
|
|
return 1;
|
|
}
|
|
|
|
BIND_MESSAGE(DebugCSP);
|
|
int AvHHud::DebugCSP(const char* pszName, int iSize, void* pbuf)
|
|
{
|
|
weapon_data_t weapon_data;
|
|
float next_attack;
|
|
NetMsg_DebugCSP( pbuf, iSize, weapon_data, next_attack );
|
|
|
|
char theServerInfoString[512];
|
|
sprintf(theServerInfoString, "Server: id: %d, clip: %d, prim attack: %f, idle: %f, next attack: %f",
|
|
weapon_data.m_iId,
|
|
weapon_data.m_iClip,
|
|
weapon_data.m_flNextPrimaryAttack,
|
|
weapon_data.m_flTimeWeaponIdle,
|
|
weapon_data.m_flNextSecondaryAttack,
|
|
next_attack
|
|
);
|
|
|
|
vgui::Label* theLabel = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(kDebugCSPServerLabel, theLabel))
|
|
{
|
|
theLabel->setText(theServerInfoString);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
AvHVisibleBlipList& AvHHud::GetEnemyBlipList()
|
|
{
|
|
return this->mEnemyBlips;
|
|
}
|
|
|
|
AvHEntityHierarchy& AvHHud::GetEntityHierarchy()
|
|
{
|
|
return this->mEntityHierarchy;
|
|
}
|
|
|
|
AvHVisibleBlipList& AvHHud::GetFriendlyBlipList()
|
|
{
|
|
return this->mFriendlyBlips;
|
|
}
|
|
|
|
bool AvHHud::GetMouseOneDown() const
|
|
{
|
|
return this->mMouseOneDown;
|
|
}
|
|
|
|
bool AvHHud::GetMouseTwoDown() const
|
|
{
|
|
return this->mMouseTwoDown;
|
|
}
|
|
|
|
void AvHHud::HideProgressStatus()
|
|
{
|
|
if(this->mGenericProgressBar)
|
|
{
|
|
this->mGenericProgressBar->setVisible(false);
|
|
}
|
|
|
|
if(this->mAlienProgressBar)
|
|
{
|
|
this->mAlienProgressBar->setVisible(false);
|
|
}
|
|
}
|
|
|
|
void AvHHud::HideResearchProgressStatus()
|
|
{
|
|
if(this->mResearchProgressBar)
|
|
{
|
|
this->mResearchProgressBar->setVisible(false);
|
|
this->mResearchLabel->setVisible(false);
|
|
}
|
|
}
|
|
|
|
void AvHHud::Init(void)
|
|
{
|
|
UIHud::Init();
|
|
|
|
HOOK_MESSAGE(EntHier);
|
|
HOOK_MESSAGE(Particles);
|
|
HOOK_MESSAGE(SoundNames);
|
|
HOOK_MESSAGE(PlayHUDNot);
|
|
HOOK_MESSAGE(BalanceVar);
|
|
HOOK_MESSAGE(GameStatus);
|
|
HOOK_MESSAGE(Progress);
|
|
HOOK_MESSAGE(Countdown);
|
|
HOOK_MESSAGE(MiniMap);
|
|
HOOK_MESSAGE(SetOrder);
|
|
HOOK_MESSAGE(SetSelect);
|
|
HOOK_MESSAGE(SetRequest);
|
|
HOOK_MESSAGE(SetupMap);
|
|
HOOK_MESSAGE(SetTopDown);
|
|
HOOK_MESSAGE(SetTech);
|
|
HOOK_MESSAGE(EditPS);
|
|
HOOK_MESSAGE(Fog);
|
|
HOOK_MESSAGE(ListPS);
|
|
HOOK_MESSAGE(SetGmma);
|
|
HOOK_MESSAGE(BlipList);
|
|
HOOK_MESSAGE(ClScript);
|
|
HOOK_MESSAGE(AlienInfo);
|
|
HOOK_MESSAGE(DebugCSP);
|
|
HOOK_MESSAGE(TechSlots);
|
|
// tankefugl: 0000971
|
|
HOOK_MESSAGE(IssueOrder);
|
|
// :tankefugl
|
|
|
|
HOOK_MESSAGE(ServerVar);
|
|
|
|
this->AddCommands();
|
|
|
|
this->mCountDownClock = -1;
|
|
|
|
mOverviewMap.Clear();
|
|
|
|
this->mEntityHierarchy.Clear();
|
|
//this->mUpgradeCosts.clear();
|
|
|
|
sPregameGammaTable.InitializeFromVideoState();
|
|
sGameGammaTable.InitializeFromVideoState();
|
|
|
|
int theRC = atexit(AvHHud::ResetGammaAtExit);
|
|
_onexit_t theExit = _onexit(AvHHud::ResetGammaAtExitForOnExit);
|
|
|
|
signal(SIGILL, AvHHud::ResetGammaAtExit);
|
|
signal(SIGFPE, AvHHud::ResetGammaAtExit);
|
|
signal(SIGSEGV, AvHHud::ResetGammaAtExit);
|
|
signal(SIGTERM, AvHHud::ResetGammaAtExit);
|
|
signal(SIGBREAK, AvHHud::ResetGammaAtExit);
|
|
signal(SIGABRT, AvHHud::ResetGammaAtExit);
|
|
|
|
//memset(this->mAlienUILifeforms, 0, sizeof(HSPRITE)*kNumAlienLifeforms);
|
|
this->mAlienUIUpgrades = 0;
|
|
this->mAlienUIUpgradeCategories = 0;
|
|
this->mOrderSprite = 0;
|
|
this->mCursorSprite = 0;
|
|
this->mMarineCursor = 0;
|
|
this->mAlienCursor = 0;
|
|
|
|
this->mMarineUIJetpackSprite = 0;
|
|
this->mMembraneSprite = 0;
|
|
this->mBackgroundSprite = 0;
|
|
|
|
this->mProgressBarEntityIndex = -1;
|
|
this->mProgressBarParam = -1;
|
|
this->mSelectedNodeResourceCost = -1;
|
|
this->mCurrentUseableEnergyLevel = 0;
|
|
this->mVisualEnergyLevel = 0.0f;
|
|
|
|
this->mFogActive = false;
|
|
this->mFogColor.x = this->mFogColor.y = this->mFogColor.z = 0;
|
|
this->mFogStart = 0;
|
|
this->mFogEnd = 0;
|
|
|
|
this->mLocationText = "";
|
|
this->mInfoLocationList.clear();
|
|
|
|
this->mLastHotkeySelectionEvent = MESSAGE_NULL;
|
|
this->mUpgrades.clear();
|
|
|
|
this->mLastGhostBuilding = NULL;
|
|
this->mReticleInfoText = "";
|
|
this->mSelectingWeaponID = -1;
|
|
this->mSelectingNodeID = MESSAGE_NULL;
|
|
this->mDesiredGammaSlope = 1;
|
|
this->mTimeOfLastHelpText = -1;
|
|
this->mCurrentWeaponID = -1;
|
|
this->mCurrentWeaponEnabled = false;
|
|
this->mCurrentUIMode = MAIN_MODE;
|
|
this->mMenuTechSlots = 0;
|
|
this->mBlinkingAlertType = 0;
|
|
this->mLastUser3 = AVH_USER3_NONE;
|
|
this->mLastTeamNumber = TEAM_IND;
|
|
this->mLastPlayMode = PLAYMODE_UNDEFINED;
|
|
|
|
this->mCrosshairShowCount = 1;
|
|
this->mCrosshairSprite = 0;
|
|
this->mCrosshairR = 0;
|
|
this->mCrosshairG = 0;
|
|
this->mCrosshairB = 0;
|
|
|
|
this->mDrawCombatUpgradeMenu = false;
|
|
|
|
// Initialize viewport
|
|
this->mViewport[0] = this->mViewport[1] = this->mViewport[2] = this->mViewport[3] = 0;
|
|
|
|
gl_monolights = gEngfuncs.pfnGetCvarPointer("gl_monolights");
|
|
gl_overbright = gEngfuncs.pfnGetCvarPointer("gl_overbright");
|
|
gl_clear = gEngfuncs.pfnGetCvarPointer("gl_clear");
|
|
hud_draw = gEngfuncs.pfnGetCvarPointer("hud_draw");
|
|
r_drawviewmodel = gEngfuncs.pfnGetCvarPointer("r_drawviewmodel");
|
|
gl_d3dflip = gEngfuncs.pfnGetCvarPointer("gl_d3dflip");
|
|
s_show = gEngfuncs.pfnGetCvarPointer("s_show");
|
|
lightgamma = gEngfuncs.pfnGetCvarPointer("lightgamma");
|
|
r_detailtextures = gEngfuncs.pfnGetCvarPointer("r_detailtextures");
|
|
}
|
|
|
|
// This gives the HUD a chance to draw after the VGUI. A component must allow itself to be hooked by calling this function
|
|
// at the end of it's paint() routine. This is done so the mouse cursor can draw on top of the other components.
|
|
void AvHHud::ComponentJustPainted(Panel* inPanel)
|
|
{
|
|
// if(this->GetInTopDownMode())
|
|
// {
|
|
// AvHTeamHierarchy* theComponent = dynamic_cast<AvHTeamHierarchy*>(inPanel);
|
|
// if(theComponent)
|
|
// {
|
|
// int theBasePosX;
|
|
// int theBasePosY;
|
|
// theComponent->getPos(theBasePosX, theBasePosY);
|
|
// this->DrawMouseCursor(theBasePosX, theBasePosY);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// PieMenu* theComponent = dynamic_cast<PieMenu*>(inPanel);
|
|
// if(theComponent)
|
|
// {
|
|
// int theBasePosX;
|
|
// int theBasePosY;
|
|
// theComponent->getPos(theBasePosX, theBasePosY);
|
|
// this->DrawMouseCursor(theBasePosX, theBasePosY);
|
|
// }
|
|
// }
|
|
|
|
|
|
DummyPanel* theComponent = dynamic_cast<DummyPanel*>(inPanel);
|
|
if(theComponent)
|
|
{
|
|
int theBasePosX;
|
|
int theBasePosY;
|
|
theComponent->getPos(theBasePosX, theBasePosY);
|
|
this->DrawMouseCursor(theBasePosX, theBasePosY);
|
|
}
|
|
|
|
}
|
|
|
|
bool AvHHud::SetCursor(AvHOrderType inOrderType)
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
if(!this->GetIsAlien())
|
|
{
|
|
this->mCursorSprite = this->mMarineCursor;
|
|
|
|
if((inOrderType >= 0) && (inOrderType < ORDERTYPE_MAX))
|
|
{
|
|
this->mCurrentCursorFrame = (int)(inOrderType);
|
|
theSuccess = true;
|
|
}
|
|
// Change cursor when over a valid choice
|
|
if(this->mSelectingNodeID > 0)
|
|
{
|
|
this->mCurrentCursorFrame = 1;
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this->mCursorSprite = this->mAlienCursor;
|
|
this->mCurrentCursorFrame = 0;
|
|
|
|
if(this->mSelectingNodeID > 0)
|
|
{
|
|
// Set cursor to lifeform to evolve to
|
|
switch(this->mSelectingNodeID)
|
|
{
|
|
case ALIEN_LIFEFORM_ONE:
|
|
case ALIEN_LIFEFORM_TWO:
|
|
case ALIEN_LIFEFORM_THREE:
|
|
case ALIEN_LIFEFORM_FOUR:
|
|
case ALIEN_LIFEFORM_FIVE:
|
|
this->mCurrentCursorFrame = 2 + (int)this->mSelectingNodeID - (int)ALIEN_LIFEFORM_ONE;
|
|
break;
|
|
|
|
default:
|
|
this->mCurrentCursorFrame = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
theSuccess = true;
|
|
}
|
|
|
|
// Scheme::SchemeCursor theSchemeCursor = Scheme::SchemeCursor::scu_arrow;
|
|
// //Scheme::SchemeCursor theSchemeCursor = Scheme::SchemeCursor::scu_no;
|
|
//
|
|
// switch(inOrderType)
|
|
// {
|
|
//// case ORDERTYPE_UNDEFINED:
|
|
//// theSchemeCursor = Scheme::SchemeCursor::scu_no;
|
|
//// theSuccess = true;
|
|
//// break;
|
|
//
|
|
// //case ORDERTYPEL_MOVE:
|
|
//
|
|
// case ORDERTYPET_ATTACK:
|
|
// case ORDERTYPET_GUARD:
|
|
// case ORDERTYPET_WELD:
|
|
// case ORDERTYPET_BUILD:
|
|
// case ORDERTYPEL_USE:
|
|
// case ORDERTYPET_GET:
|
|
// theSchemeCursor = Scheme::SchemeCursor::scu_hand;
|
|
// theSuccess = true;
|
|
// break;
|
|
// }
|
|
//
|
|
// App::getInstance()->setCursorOveride( App::getInstance()->getScheme()->getCursor(theSchemeCursor));
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
void AvHHud::GetCursor(HSPRITE& outSprite, int& outFrame)
|
|
{
|
|
|
|
if (g_iUser1 == 0)
|
|
{
|
|
outSprite = mCursorSprite;
|
|
outFrame = mCurrentCursorFrame;
|
|
}
|
|
else
|
|
{
|
|
// Always use the marine cursor in spectator mode.
|
|
outSprite = mMarineCursor;
|
|
outFrame = 0;
|
|
}
|
|
|
|
}
|
|
|
|
void AvHHud::SetHelpMessage(const string& inHelpText, bool inForce, float inNormX, float inNormY)
|
|
{
|
|
if(inForce || gEngfuncs.pfnGetCvarFloat(kvAutoHelp))
|
|
{
|
|
float theReticleX = kHelpMessageLeftEdgeInset;
|
|
float theReticleY = kHelpMessageTopEdgeInset - 0.03f; // + 0.15f;
|
|
bool theCentered = false;
|
|
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
int theMouseX, theMouseY;
|
|
this->GetMousePos(theMouseX, theMouseY);
|
|
theReticleX = theMouseX/(float)ScreenWidth();
|
|
theReticleY = theMouseY/(float)ScreenHeight();
|
|
|
|
// Move text up a bit so it doesn't obscure
|
|
theReticleY -= .1f;
|
|
|
|
theCentered = true;
|
|
}
|
|
// Alien HUD forces this to be inset a bit
|
|
else
|
|
{
|
|
if(this->GetIsAlien())
|
|
{
|
|
theReticleX = kHelpMessageAlienLeftedgeInset;
|
|
theReticleY = kHelpMessageAlienTopEdgeInset - 0.15f;
|
|
}
|
|
|
|
if(inNormX != -1)
|
|
{
|
|
theReticleX = inNormX;
|
|
}
|
|
if(inNormY != -1)
|
|
{
|
|
theReticleY = inNormY;
|
|
}
|
|
}
|
|
|
|
this->mHelpMessage.SetText(inHelpText);
|
|
|
|
this->mHelpMessage.SetNormalizedScreenX(theReticleX);
|
|
this->mHelpMessage.SetNormalizedScreenY(theReticleY);
|
|
this->mHelpMessage.SetCentered(theCentered);
|
|
this->mHelpMessage.SetNormalizedMaxWidth(kReticleMaxWidth);
|
|
//this->mHelpMessage.SetIgnoreFadeForLifetime(true);
|
|
|
|
float theTimePassed = (this->mTimeOfCurrentUpdate - this->mTimeOfLastUpdate);
|
|
this->mHelpMessage.FadeText(theTimePassed, false);
|
|
|
|
// Set color
|
|
int theR, theG, theB;
|
|
this->GetPrimaryHudColor(theR, theG, theB, true, false);
|
|
this->mHelpMessage.SetRGB(theR, theG, theB);
|
|
}
|
|
}
|
|
|
|
void AvHHud::SetActionButtonHelpMessage(const string& inHelpText)
|
|
{
|
|
this->mTopDownActionButtonHelp.SetText(inHelpText);
|
|
|
|
const float kNormX = .73f;
|
|
this->mTopDownActionButtonHelp.SetNormalizedScreenX(kNormX);
|
|
|
|
// Treat this as the bottom of the tooltip. Scale the tooltip so it's bottom is here.
|
|
const float kNormY = .68f;
|
|
int theHeight = this->mTopDownActionButtonHelp.GetScreenHeight();
|
|
float theNormalizedHeight = (float)theHeight/ScreenHeight();
|
|
this->mTopDownActionButtonHelp.SetNormalizedScreenY(kNormY - theNormalizedHeight);
|
|
|
|
this->mTopDownActionButtonHelp.SetBackgroundA(128);
|
|
|
|
this->mTopDownActionButtonHelp.SetCentered(false);
|
|
this->mTopDownActionButtonHelp.SetNormalizedMaxWidth(1.0f - kNormX - .01f);
|
|
//this->mTopDownActionButtonHelp.SetIgnoreFadeForLifetime(true);
|
|
|
|
float theTimePassed = (this->mTimeOfCurrentUpdate - this->mTimeOfLastUpdate);
|
|
this->mTopDownActionButtonHelp.FadeText(theTimePassed, false);
|
|
|
|
// Set color
|
|
int theR, theG, theB;
|
|
this->GetPrimaryHudColor(theR, theG, theB, true, false);
|
|
this->mTopDownActionButtonHelp.SetRGB(theR, theG, theB);
|
|
}
|
|
|
|
void AvHHud::SetReticleMessage(const string& inHelpText)
|
|
{
|
|
float theReticleX;
|
|
float theReticleY;
|
|
bool theIsCentered;
|
|
this->GetReticleTextDrawingInfo(theReticleX, theReticleY, theIsCentered);
|
|
|
|
this->mReticleMessage.SetText(inHelpText);
|
|
|
|
this->mReticleMessage.SetNormalizedScreenX(theReticleX);
|
|
this->mReticleMessage.SetNormalizedScreenY(theReticleY);
|
|
this->mReticleMessage.SetCentered(theIsCentered);
|
|
this->mReticleMessage.SetNormalizedMaxWidth(kReticleMaxWidth);
|
|
|
|
// Need instant fade-in and slow fade down for player names and info
|
|
this->mReticleMessage.SetFadeDownSpeed(-100);
|
|
this->mReticleMessage.SetFadeUpSpeed(10000);
|
|
//this->mReticleMessage.SetIgnoreFadeForLifetime(true);
|
|
|
|
float theTimePassed = (this->mTimeOfCurrentUpdate - this->mTimeOfLastUpdate);
|
|
this->mReticleMessage.FadeText(theTimePassed, false);
|
|
}
|
|
|
|
void AvHHud::SetCurrentUseableEnergyLevel(float inEnergyLevel)
|
|
{
|
|
this->mCurrentUseableEnergyLevel = inEnergyLevel;
|
|
}
|
|
|
|
const AvHMapExtents& AvHHud::GetMapExtents()
|
|
{
|
|
return this->mMapExtents;
|
|
}
|
|
|
|
void AvHHud::InitCommanderMode()
|
|
{
|
|
Panel* thePanel = NULL;
|
|
|
|
if(this->GetManager().GetVGUIComponentNamed(kLeaveCommanderButton, thePanel))
|
|
{
|
|
thePanel->addInputSignal(&gCommanderHandler);
|
|
}
|
|
|
|
if(this->GetManager().GetVGUIComponentNamed(kHierarchy, thePanel))
|
|
{
|
|
thePanel->addInputSignal(&gCommanderHandler);
|
|
}
|
|
|
|
if(this->GetManager().GetVGUIComponentNamed(kActionButtonsComponents, thePanel))
|
|
{
|
|
thePanel->addInputSignal(&gCommanderHandler);
|
|
}
|
|
|
|
if(this->GetManager().GetVGUIComponentNamed(kSelectAllImpulsePanel, thePanel))
|
|
{
|
|
thePanel->addInputSignal(&gCommanderHandler);
|
|
}
|
|
|
|
// Add handler for all pending request buttons
|
|
for(int i = 0; i < MESSAGE_LAST; i++)
|
|
{
|
|
AvHMessageID theMessageID = AvHMessageID(i);
|
|
|
|
char theComponentName[256];
|
|
sprintf(theComponentName, kPendingImpulseSpecifier, (int)theMessageID);
|
|
|
|
AvHTechImpulsePanel* theTechImpulsePanel = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(theComponentName, theTechImpulsePanel))
|
|
{
|
|
theTechImpulsePanel->addInputSignal(&gCommanderHandler);
|
|
}
|
|
}
|
|
|
|
//this->GetManager().GetVGUIComponentNamed(kScroller, thePanel);
|
|
//if(thePanel)
|
|
//{
|
|
// thePanel->addInputSignal(&gScrollHandler);
|
|
//}
|
|
|
|
// Get input from every control
|
|
this->GetManager().AddInputSignal(&gScrollHandler);
|
|
|
|
// TODO: Add others here
|
|
}
|
|
|
|
// Read in base state from stream (called by Demo_ReadBuffer)
|
|
int AvHHud::InitializeDemoPlayback(int inSize, unsigned char* inBuffer)
|
|
{
|
|
// Read in base state
|
|
int theBytesRead = 0;
|
|
|
|
// Read in num upgrades
|
|
int theNumUpgrades = 0;
|
|
//this->mUpgradeCosts.clear();
|
|
LoadData(&theNumUpgrades, inBuffer, sizeof(int), theBytesRead);
|
|
|
|
for(int i = 0; i < theNumUpgrades; i++)
|
|
{
|
|
// Read in upgrades (for backwards-compatibility)
|
|
int theFirst = 0;
|
|
LoadData(&theFirst, inBuffer, sizeof(int), theBytesRead);
|
|
|
|
int theSecond = 0;
|
|
LoadData(&theSecond, inBuffer, sizeof(int), theBytesRead);
|
|
}
|
|
|
|
// Read in gamma
|
|
LoadData(&this->mDesiredGammaSlope, inBuffer, sizeof(this->mDesiredGammaSlope), theBytesRead);
|
|
|
|
if (!mSteamUIActive)
|
|
{
|
|
this->SetGamma(this->mDesiredGammaSlope);
|
|
}
|
|
|
|
// Read in resources
|
|
LoadData(&this->mResources, inBuffer, sizeof(this->mResources), theBytesRead);
|
|
|
|
// Read in commander (TODO: REMOVE)
|
|
int theCommander;
|
|
LoadData(&theCommander, inBuffer, sizeof(theCommander), theBytesRead);
|
|
|
|
// Read in number of hive infos
|
|
this->mHiveInfoList.clear();
|
|
|
|
int theNumHiveInfos = 0;
|
|
LoadData(&theNumHiveInfos, inBuffer, sizeof(int), theBytesRead);
|
|
|
|
// For each one, add a new hive info
|
|
for(i = 0; i < theNumHiveInfos; i++)
|
|
{
|
|
AvHHiveInfo theHiveInfo;
|
|
LoadData(&theHiveInfo, inBuffer, sizeof(AvHHiveInfo), theBytesRead);
|
|
this->mHiveInfoList.push_back(theHiveInfo);
|
|
}
|
|
|
|
// Load and set current pie menu control
|
|
int thePieMenuControlLength = 0;
|
|
LoadData(&thePieMenuControlLength, inBuffer, sizeof(int), theBytesRead);
|
|
|
|
char thePieMenuControl[256];
|
|
memset(thePieMenuControl, 0, 256);
|
|
LoadData(thePieMenuControl, inBuffer, thePieMenuControlLength, theBytesRead);
|
|
this->mPieMenuControl = string(thePieMenuControl);
|
|
|
|
// Read in selected units size
|
|
this->mSelected.clear();
|
|
int theNumSelected = 0;
|
|
LoadData(&theNumSelected, inBuffer, sizeof(theNumSelected), theBytesRead);
|
|
|
|
for(i = 0; i < theNumSelected; i++)
|
|
{
|
|
// Read in selected units
|
|
EntityInfo theSelectedEntity = 0;
|
|
LoadData(&theSelectedEntity, inBuffer, sizeof(theSelectedEntity), theBytesRead);
|
|
}
|
|
|
|
ASSERT((theBytesRead + (int)sizeof(int)) == inSize);
|
|
|
|
// Clear existing particle system templates
|
|
gParticleTemplateList.Clear();
|
|
AvHParticleSystemManager::Instance()->Reset();
|
|
|
|
// Clear weapon info
|
|
gWR.Reset();
|
|
|
|
return theBytesRead;
|
|
}
|
|
|
|
int AvHHud::InitializeDemoPlayback2(int inSize, unsigned char* inBuffer)
|
|
{
|
|
// Read in base state 2
|
|
int theBytesRead = 0;
|
|
|
|
LOAD_DATA(this->mTimeOfLastUpdate);
|
|
LOAD_DATA(this->mTimeOfNextHudSound);
|
|
LOAD_DATA(this->mTimeOfCurrentUpdate);
|
|
LOAD_DATA(this->mCountDownClock);
|
|
LOAD_DATA(this->mLastTickPlayed);
|
|
LOAD_DATA(this->mNumTicksToPlay);
|
|
LoadStringData(this->mMapName, inBuffer, theBytesRead);
|
|
|
|
float theMinViewHeight;
|
|
LOAD_DATA(theMinViewHeight);
|
|
this->mMapExtents.SetMinViewHeight(theMinViewHeight);
|
|
|
|
float theMaxViewHeight;
|
|
LOAD_DATA(theMaxViewHeight);
|
|
this->mMapExtents.SetMaxViewHeight(theMaxViewHeight);
|
|
|
|
float theMinMapX;
|
|
LOAD_DATA(theMinMapX);
|
|
this->mMapExtents.SetMinMapX(theMinMapX);
|
|
|
|
float theMaxMapX;
|
|
LOAD_DATA(theMaxMapX);
|
|
this->mMapExtents.SetMaxMapX(theMaxMapX);
|
|
|
|
float theMinMapY;
|
|
LOAD_DATA(theMinMapY);
|
|
this->mMapExtents.SetMinMapY(theMinMapY);
|
|
|
|
float theMaxMapY;
|
|
LOAD_DATA(theMaxMapY);
|
|
this->mMapExtents.SetMaxMapY(theMaxMapY);
|
|
|
|
bool theDrawMapBG;
|
|
LOAD_DATA(theDrawMapBG);
|
|
this->mMapExtents.SetDrawMapBG(theDrawMapBG);
|
|
|
|
// Clear then load sound names
|
|
int theSoundNameListSize;
|
|
LOAD_DATA(theSoundNameListSize);
|
|
this->mSoundNameList.clear();
|
|
|
|
for(int i = 0; i < theSoundNameListSize; i++)
|
|
{
|
|
string theCurrentSoundName;
|
|
LoadStringData(theCurrentSoundName, inBuffer, theBytesRead);
|
|
this->mSoundNameList.push_back(theCurrentSoundName);
|
|
}
|
|
|
|
ASSERT((theBytesRead + (int)sizeof(int)) == inSize);
|
|
|
|
return theBytesRead;
|
|
}
|
|
|
|
// Write out base HUD data to stream
|
|
void AvHHud::InitializeDemoRecording()
|
|
{
|
|
// Figure out total size of buffer needed
|
|
|
|
// Write number of upgrades, then each upgrade
|
|
// No longer done, but need to add in upgrades for backwards compatibility
|
|
int theUpgrades = 0;
|
|
int theUpgradesSize = sizeof(theUpgrades);
|
|
|
|
// Gamma, resources
|
|
int theGammaSize = sizeof(this->mDesiredGammaSlope);
|
|
int theResourcesSizes = sizeof(this->mResources);
|
|
|
|
// Save commander index (TODO: REMOVE)
|
|
int theCommanderIndex = this->GetCommanderIndex();
|
|
int theCommanderSize = sizeof(theCommanderIndex);
|
|
|
|
int theNumHiveInfoRecords = (int)this->mHiveInfoList.size();
|
|
int theHiveInfoSize = sizeof(int) + theNumHiveInfoRecords*sizeof(AvHHiveInfo);
|
|
|
|
string thePieMenuControl = gPieMenuHandler.GetPieMenuControl();
|
|
int theCurrentPieMenuControlSize = sizeof(int) + (int)thePieMenuControl.size();
|
|
|
|
int theSelectedSize = sizeof(int) + (int)this->mSelected.size()*sizeof(EntityInfo);
|
|
|
|
int theTotalSize = theUpgradesSize + theGammaSize + theResourcesSizes + theCommanderSize + theHiveInfoSize + theCurrentPieMenuControlSize + theSelectedSize;
|
|
|
|
// New a char array of this size
|
|
int theCounter = 0;
|
|
|
|
unsigned char* theCharArray = new unsigned char[theTotalSize];
|
|
if(theCharArray)
|
|
{
|
|
// Write out number of upgrades (for backwards-compatibility)
|
|
int theNumUpgradeCosts = 0;
|
|
SaveData(theCharArray, &theNumUpgradeCosts, sizeof(theNumUpgradeCosts), theCounter);
|
|
|
|
// Write out gamma
|
|
SaveData(theCharArray, &this->mDesiredGammaSlope, theGammaSize, theCounter);
|
|
SaveData(theCharArray, &this->mResources, theResourcesSizes, theCounter);
|
|
SaveData(theCharArray, &theCommanderIndex, theCommanderSize, theCounter);
|
|
|
|
// Write out num hive info records
|
|
SaveData(theCharArray, &theNumHiveInfoRecords, sizeof(int), theCounter);
|
|
for(HiveInfoListType::iterator theHiveInfoIter = this->mHiveInfoList.begin(); theHiveInfoIter != this->mHiveInfoList.end(); theHiveInfoIter++)
|
|
{
|
|
SaveData(theCharArray, &(*theHiveInfoIter), sizeof(AvHHiveInfo), theCounter);
|
|
}
|
|
|
|
// Save length of pie menu control name
|
|
int thePieMenuControlNameLength = (int)thePieMenuControl.size();
|
|
SaveData(theCharArray, &thePieMenuControlNameLength, sizeof(int), theCounter);
|
|
SaveData(theCharArray, thePieMenuControl.c_str(), thePieMenuControlNameLength, theCounter);
|
|
|
|
// Save out size of selected
|
|
int theNumSelected = (int)this->mSelected.size();
|
|
SaveData(theCharArray, &theNumSelected, sizeof(theNumSelected), theCounter);
|
|
|
|
for(EntityListType::const_iterator theSelectedIter = this->mSelected.begin(); theSelectedIter != this->mSelected.end(); theSelectedIter++)
|
|
{
|
|
EntityInfo theCurrentInfo = *theSelectedIter;
|
|
SaveData(theCharArray, &theCurrentInfo, sizeof(EntityInfo), theCounter);
|
|
}
|
|
|
|
ASSERT(theCounter == theTotalSize);
|
|
|
|
// Write it out
|
|
Demo_WriteBuffer(TYPE_BASESTATE, theTotalSize, theCharArray);
|
|
|
|
// Delete char array
|
|
delete [] theCharArray;
|
|
theCharArray = NULL;
|
|
|
|
// Save out particle templates
|
|
gParticleTemplateList.InitializeDemoRecording();
|
|
}
|
|
|
|
theTotalSize = theCounter = 0;
|
|
theTotalSize += sizeof(this->mTimeOfLastUpdate);
|
|
theTotalSize += sizeof(this->mTimeOfNextHudSound);
|
|
theTotalSize += sizeof(this->mTimeOfCurrentUpdate);
|
|
theTotalSize += sizeof(this->mCountDownClock);
|
|
theTotalSize += sizeof(this->mLastTickPlayed);
|
|
theTotalSize += sizeof(this->mNumTicksToPlay);
|
|
theTotalSize += GetDataSize(this->mMapName);
|
|
theTotalSize += sizeof(this->mMapExtents.GetMinViewHeight());
|
|
theTotalSize += sizeof(this->mMapExtents.GetMaxViewHeight());
|
|
theTotalSize += sizeof(this->mMapExtents.GetMinMapX());
|
|
theTotalSize += sizeof(this->mMapExtents.GetMaxMapX());
|
|
theTotalSize += sizeof(this->mMapExtents.GetMinMapY());
|
|
theTotalSize += sizeof(this->mMapExtents.GetMaxMapY());
|
|
theTotalSize += sizeof(this->mMapExtents.GetDrawMapBG());
|
|
|
|
// Save sound names
|
|
int theSoundNameListSize = (int)this->mSoundNameList.size();
|
|
theTotalSize += sizeof(theSoundNameListSize);
|
|
|
|
for(int i = 0; i < theSoundNameListSize; i++)
|
|
{
|
|
string theCurrentSoundName = this->mSoundNameList[i];
|
|
theTotalSize += GetDataSize(theCurrentSoundName);
|
|
}
|
|
|
|
theCharArray = new unsigned char[theTotalSize];
|
|
if(theCharArray)
|
|
{
|
|
SAVE_DATA(this->mTimeOfLastUpdate);
|
|
SAVE_DATA(this->mTimeOfNextHudSound);
|
|
SAVE_DATA(this->mTimeOfCurrentUpdate);
|
|
SAVE_DATA(this->mCountDownClock);
|
|
SAVE_DATA(this->mLastTickPlayed);
|
|
SAVE_DATA(this->mNumTicksToPlay);
|
|
SaveStringData(theCharArray, this->mMapName, theCounter);
|
|
|
|
float theMinViewHeight = this->mMapExtents.GetMinViewHeight();
|
|
SAVE_DATA(theMinViewHeight);
|
|
float theMaxViewHeight = this->mMapExtents.GetMaxViewHeight();
|
|
SAVE_DATA(theMaxViewHeight);
|
|
float theMinMapX = this->mMapExtents.GetMinMapX();
|
|
SAVE_DATA(theMinMapX);
|
|
float theMaxMapX = this->mMapExtents.GetMaxMapX();
|
|
SAVE_DATA(theMaxMapX);
|
|
float theMinMapY = this->mMapExtents.GetMinMapY();
|
|
SAVE_DATA(theMinMapY);
|
|
float theMaxMapY = this->mMapExtents.GetMaxMapY();
|
|
SAVE_DATA(theMaxMapY);
|
|
bool theDrawMapBG = this->mMapExtents.GetDrawMapBG();
|
|
SAVE_DATA(theDrawMapBG);
|
|
|
|
SAVE_DATA(theSoundNameListSize);
|
|
for(int i = 0; i < theSoundNameListSize; i++)
|
|
{
|
|
string theCurrentSoundName = this->mSoundNameList[i];
|
|
SaveStringData(theCharArray, theCurrentSoundName, theCounter);
|
|
}
|
|
|
|
// TODO: Save out locations?
|
|
|
|
ASSERT(theCounter == theTotalSize);
|
|
|
|
// Write out TYPE_BASESTATE2 chunk separately for backwards-compatibility
|
|
Demo_WriteBuffer(TYPE_BASESTATE2, theTotalSize, theCharArray);
|
|
|
|
delete [] theCharArray;
|
|
theCharArray = NULL;
|
|
}
|
|
|
|
ScorePanel_InitializeDemoRecording();
|
|
|
|
// Write out weapon info
|
|
for(i = 0; i < MAX_WEAPONS; i++)
|
|
{
|
|
WEAPON* theWeapon = gWR.GetWeapon(i);
|
|
if( theWeapon )
|
|
{
|
|
theTotalSize = sizeof(theWeapon->szName) + sizeof(theWeapon->iAmmoType) + sizeof(theWeapon->iAmmo2Type) + sizeof(theWeapon->iMax1) + sizeof(theWeapon->iMax2) + sizeof(theWeapon->iSlot) + sizeof(theWeapon->iSlotPos) + sizeof(theWeapon->iFlags) + sizeof(theWeapon->iId) + sizeof(theWeapon->iClip) + sizeof(theWeapon->iCount);// + sizeof(int); // last one is for ammo
|
|
theCharArray = new unsigned char[theTotalSize];
|
|
|
|
int theWeaponCoreDataLength = theTotalSize;// - sizeof(int);
|
|
memcpy(theCharArray, theWeapon, theWeaponCoreDataLength); // Everything but ammo
|
|
//int theAmmo = gWR.GetAmmo(theWeapon->iId);
|
|
//memcpy(theCharArray + theWeaponCoreDataLength, &theAmmo, sizeof(int));
|
|
|
|
Demo_WriteBuffer(TYPE_WEAPONINFO, theTotalSize, (unsigned char*)theWeapon);
|
|
|
|
delete [] theCharArray;
|
|
theCharArray = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
int AvHHud::InitializeWeaponInfoPlayback(int inSize, unsigned char* inBuffer)
|
|
{
|
|
// Make sure weapons are cleared out first
|
|
WEAPON theWeapon;
|
|
memset(&theWeapon, 0, sizeof(theWeapon));
|
|
|
|
int theWeaponCoreDataLength = inSize;// - sizeof(int);
|
|
memcpy(&theWeapon, inBuffer, theWeaponCoreDataLength);
|
|
|
|
if(theWeapon.iId)
|
|
{
|
|
gWR.AddWeapon( &theWeapon );
|
|
//int theAmmo = 0;
|
|
//memcpy(&theAmmo, inBuffer + theWeaponCoreDataLength, sizeof(int));
|
|
//gWR.SetAmmo(theWeapon.iId, theAmmo);
|
|
}
|
|
|
|
return inSize;
|
|
}
|
|
|
|
void AvHHud::InitMenu(const string& inMenuName)
|
|
{
|
|
PieMenu* theMenu = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(inMenuName, theMenu))
|
|
{
|
|
theMenu->AddInputSignalForNodes(&gPieMenuHandler);
|
|
//outMenu->DisableNodesGreaterThanCost(this->mResources);
|
|
this->GetManager().HideComponent(inMenuName);
|
|
}
|
|
}
|
|
|
|
void AvHHud::PostUIInit(void)
|
|
{
|
|
this->InitMenu(kSoldierMenu);
|
|
this->InitMenu(kSoldierCombatMenu);
|
|
this->InitMenu(kAlienMenu);
|
|
this->InitMenu(kAlienCombatMenu);
|
|
|
|
this->InitCommanderMode();
|
|
|
|
this->GetManager().GetVGUIComponentNamed(kCommanderResourceLabel, this->mCommanderResourceLabel);
|
|
this->GetManager().GetVGUIComponentNamed(kGenericProgress, this->mGenericProgressBar);
|
|
this->GetManager().GetVGUIComponentNamed(kResearchProgress, this->mResearchProgressBar);
|
|
this->GetManager().GetVGUIComponentNamed(kAlienProgress, this->mAlienProgressBar);
|
|
this->GetManager().GetVGUIComponentNamed(kSelectionBox, this->mSelectionBox);
|
|
this->GetManager().GetVGUIComponentNamed(kResearchingLabel, this->mResearchLabel);
|
|
|
|
// Init particle editor
|
|
gParticleEditorHandler.Setup();
|
|
|
|
if(this->GetManager().GetVGUIComponentNamed(kHierarchy, this->mHierarchy))
|
|
{
|
|
this->mHierarchy->setEnabled(false);
|
|
}
|
|
if(this->GetManager().GetVGUIComponentNamed(kShowMapHierarchy, this->mShowMapHierarchy))
|
|
{
|
|
this->mShowMapHierarchy->setEnabled(false);
|
|
}
|
|
|
|
// Don't turn on gamma by default, it is annoying for testing
|
|
//this->SetGamma();
|
|
}
|
|
|
|
AvHMessageID AvHHud::GetGhostBuilding() const
|
|
{
|
|
return this->mGhostBuilding;
|
|
}
|
|
|
|
void AvHHud::SetGhostBuildingMode(AvHMessageID inGhostBuilding)
|
|
{
|
|
this->mGhostBuilding = inGhostBuilding;
|
|
this->mCreatedGhost = false;
|
|
}
|
|
|
|
void AvHHud::SetClientDebugCSP(weapon_data_t* inWeaponData, float inNextPlayerAttack)
|
|
{
|
|
char theClientInfoString[512];
|
|
sprintf(theClientInfoString, "Client: id: %d, clip: %d, prim attack: %f, idle: %f, next attack: %f", inWeaponData->m_iId, inWeaponData->m_iClip, inWeaponData->m_flNextPrimaryAttack, inWeaponData->m_flTimeWeaponIdle, inNextPlayerAttack);
|
|
|
|
vgui::Label* theLabel = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(kDebugCSPClientLabel, theLabel))
|
|
{
|
|
theLabel->setText(theClientInfoString);
|
|
}
|
|
}
|
|
|
|
void AvHHud::SetCurrentWeaponData(int inCurrentWeaponID, bool inEnabled)
|
|
{
|
|
this->mCurrentWeaponID = inCurrentWeaponID;
|
|
this->mCurrentWeaponEnabled = inEnabled;
|
|
}
|
|
|
|
int AvHHud::GetCurrentWeaponID(void)
|
|
{
|
|
return this->mCurrentWeaponID;
|
|
}
|
|
|
|
void AvHHud::SetAlienAbility(AvHMessageID inAlienAbility)
|
|
{
|
|
this->mAlienAbility = inAlienAbility;
|
|
}
|
|
|
|
void AvHHud::SetProgressStatus(float inPercentage)
|
|
{
|
|
if(this->mGenericProgressBar)
|
|
{
|
|
this->mGenericProgressBar->setVisible(false);
|
|
}
|
|
|
|
if(this->mAlienProgressBar)
|
|
{
|
|
this->mAlienProgressBar->setVisible(false);
|
|
}
|
|
|
|
ProgressBar* theProgressBar = this->mGenericProgressBar;
|
|
if(this->GetIsAlien())
|
|
{
|
|
theProgressBar = this->mAlienProgressBar;
|
|
}
|
|
|
|
if(theProgressBar)
|
|
{
|
|
theProgressBar->setVisible(true);
|
|
|
|
int theNumSegments = theProgressBar->getSegmentCount();
|
|
int theSegment = inPercentage*theNumSegments;
|
|
theProgressBar->setProgress(theSegment);
|
|
}
|
|
}
|
|
|
|
void AvHHud::SetReinforcements(int inReinforcements)
|
|
{
|
|
Label* theLabel = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(kReinforcementsLabel, theLabel))
|
|
{
|
|
string thePrefix;
|
|
if(LocalizeString(kReinforcementsText, thePrefix))
|
|
{
|
|
string theText = thePrefix + string(" ") + MakeStringFromInt(inReinforcements);
|
|
theLabel->setText(theText.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::SetResearchProgressStatus(float inPercentage)
|
|
{
|
|
if(this->mResearchProgressBar)
|
|
{
|
|
this->mResearchProgressBar->setVisible(true);
|
|
|
|
int theNumSegments = this->mResearchProgressBar->getSegmentCount();
|
|
int theSegment = inPercentage*theNumSegments;
|
|
this->mResearchProgressBar->setProgress(theSegment);
|
|
|
|
this->mResearchLabel->setVisible(true);
|
|
|
|
// Center research label
|
|
int theX, theY;
|
|
this->mResearchLabel->getPos(theX, theY);
|
|
int theTextWidth, theTextHeight;
|
|
this->mResearchLabel->getTextSize(theTextWidth, theTextHeight);
|
|
this->mResearchLabel->setPos(ScreenWidth()/2 - theTextWidth/2, theY);
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateDemoRecordPlayback()
|
|
{
|
|
// If the mouse is visible, allow it to work with demos
|
|
if(gEngfuncs.pDemoAPI->IsRecording())
|
|
{
|
|
// Write out first frame if needed
|
|
if(!this->mRecordingLastFrame)
|
|
{
|
|
this->InitializeDemoRecording();
|
|
this->mRecordingLastFrame = true;
|
|
}
|
|
|
|
// Write view origin (and angles?)
|
|
//Demo_WriteVector(TYPE_VIEWANGLES, v_angles);
|
|
//Demo_WriteVector(TYPE_VIEWORIGIN, v_origin);
|
|
// Demo_WriteByte(TYPE_MOUSEVIS, g_iVisibleMouse);
|
|
//
|
|
// if(g_iVisibleMouse)
|
|
// {
|
|
// int theMouseScreenX, theMouseScreenY;
|
|
//
|
|
// IN_GetMousePos(&theMouseScreenX, &theMouseScreenY);
|
|
//
|
|
// //theMouseScreenX += ScreenWidth/2;
|
|
// //theMouseScreenY += ScreenHeight/2;
|
|
//
|
|
// // Write mouse position
|
|
// float theNormX = (float)theMouseScreenX/ScreenWidth;
|
|
// float theNormY = (float)theMouseScreenY/ScreenHeight;
|
|
//
|
|
// Demo_WriteFloat(TYPE_MOUSEX, theNormX);
|
|
// Demo_WriteFloat(TYPE_MOUSEY, theNormY);
|
|
//
|
|
// //char theBuffer[256];
|
|
// //sprintf(theBuffer, "Saving mouse coords %f %f\n", theNormX, theNormY);
|
|
// //CenterPrint(theBuffer);
|
|
// }
|
|
}
|
|
else if(gEngfuncs.pDemoAPI->IsPlayingback())
|
|
{
|
|
//char theBuffer[256];
|
|
//sprintf(theBuffer, "Restoring mouse coords %f %f\n", gNormMouseX, gNormMouseY);
|
|
//CenterPrint(theBuffer);
|
|
|
|
//int theCurrentMouseX = gNormMouseX*ScreenWidth;
|
|
//int theCurrentMouseY = gNormMouseY*ScreenHeight;
|
|
//
|
|
////App::getInstance()->setCursorPos(theCurrentMouseX, theCurrentMouseY);
|
|
//
|
|
//SetCursorPos(theCurrentMouseX, theCurrentMouseY);
|
|
//
|
|
//this->mMouseCursorX = theCurrentMouseX;
|
|
//this->mMouseCursorY = theCurrentMouseY;
|
|
|
|
this->mRecordingLastFrame = false;
|
|
}
|
|
else
|
|
{
|
|
this->mRecordingLastFrame = false;
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateDataFromVuser4(float inCurrentTime)
|
|
{
|
|
cl_entity_s* theLocalPlayer = gEngfuncs.GetLocalPlayer();
|
|
if(theLocalPlayer)
|
|
{
|
|
// Fetch data from vuser4
|
|
vec3_t theVUser = theLocalPlayer->curstate.vuser4;
|
|
|
|
//int theVUserVar0 = 0;
|
|
//int theVUserVar1 = 0;
|
|
//int theVUserVar2 = 0;
|
|
//
|
|
//memcpy(&theVUserVar0, (int*)(&theVUser.x), 4);
|
|
//memcpy(&theVUserVar1, (int*)(&theVUser.y), 4);
|
|
//memcpy(&theVUserVar2, (int*)(&theVUser.z), 4);
|
|
|
|
// Fetch new resource level
|
|
//theVUserVar2;// & 0x0000FFFF;
|
|
|
|
if(this->GetIsCombatMode())
|
|
{
|
|
this->mExperience = (int)ceil(theVUser.z/kNumericNetworkConstant);
|
|
this->mExperienceLevel = AvHPlayerUpgrade::GetPlayerLevel(this->mExperience);
|
|
|
|
const float kShowMenuInterval = 5.0f;
|
|
|
|
// If we are at a level greater then we've drawn, set visible again to reparse
|
|
if(this->mExperienceLevel > this->mExperienceLevelLastDrawn)
|
|
{
|
|
this->DisplayCombatUpgradeMenu(true);
|
|
this->mTimeOfLastLevelUp = inCurrentTime;
|
|
this->mExperienceLevelLastDrawn = this->mExperienceLevel;
|
|
}
|
|
// else if we have no more levels to spend or if we've been displaying it longer then the time out (+1 because we start at level 1)
|
|
else if((this->mExperienceLevel == (this->mExperienceLevelSpent + 1)) || (inCurrentTime > (this->mTimeOfLastLevelUp + kShowMenuInterval)))
|
|
{
|
|
// stop displaying it
|
|
this->DisplayCombatUpgradeMenu(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int theNewValue = (int)ceil(theVUser.z/kNumericNetworkConstant);
|
|
|
|
if(theNewValue != this->mResources)
|
|
{
|
|
this->mResources = theNewValue;
|
|
}
|
|
|
|
// Don't smooth resources nicely when switching targets
|
|
if((g_iUser1 == OBS_IN_EYE) && (g_iUser2 != this->mUser2OfLastResourceMessage))
|
|
{
|
|
this->mVisualResources = this->mResources;
|
|
}
|
|
}
|
|
this->mUser2OfLastResourceMessage = g_iUser2;
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateSpectating()
|
|
{
|
|
// If we're spectating and the team of our target switched, delete all blips
|
|
if((this->GetPlayMode() == PLAYMODE_AWAITINGREINFORCEMENT) || (this->GetPlayMode() == PLAYMODE_OBSERVER))
|
|
{
|
|
AvHTeamNumber theCurrentTargetTeam = TEAM_IND;
|
|
|
|
int theCurrentTarget = g_iUser2;//thePlayer->curstate.iuser2;
|
|
cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(theCurrentTarget);
|
|
if(theEntity)
|
|
{
|
|
theCurrentTargetTeam = AvHTeamNumber(theEntity->curstate.team);
|
|
}
|
|
|
|
if((theCurrentTargetTeam != this->mLastTeamSpectated) && (theCurrentTargetTeam != TEAM_IND))
|
|
{
|
|
this->mEnemyBlips.Clear();
|
|
this->mFriendlyBlips.Clear();
|
|
this->mLastTeamSpectated = theCurrentTargetTeam;
|
|
//CenterPrint("Clearing blips.");
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateCommonUI()
|
|
{
|
|
// Find currently selected node and draw help text if it's been open for a little bit
|
|
PieMenu* thePieMenu = NULL;
|
|
AvHMessageID theCurrentNodeID = MESSAGE_NULL;
|
|
|
|
this->mSelectingNodeID = MESSAGE_NULL;
|
|
|
|
if(this->GetManager().GetVGUIComponentNamed(this->mPieMenuControl, thePieMenu))
|
|
{
|
|
// tankefugl: Added check to ensure that it is only updated when a menu is visible
|
|
if (thePieMenu->getChildCount() > 0)
|
|
{
|
|
vgui::Panel *rootMenu = thePieMenu->getChild(0);
|
|
if (rootMenu && rootMenu->isVisible())
|
|
{
|
|
this->UpdateUpgradeCosts();
|
|
}
|
|
}
|
|
|
|
PieNode* theCurrentNode = NULL;
|
|
if(thePieMenu && thePieMenu->GetSelectedNode(theCurrentNode))
|
|
{
|
|
theCurrentNodeID = (AvHMessageID)theCurrentNode->GetMessageID();
|
|
|
|
if(theCurrentNodeID > 0)
|
|
{
|
|
this->mSelectingNodeID = theCurrentNodeID;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clear squad on team change
|
|
if(!this->GetIsMarine())
|
|
{
|
|
this->mCurrentSquad = 0;
|
|
}
|
|
}
|
|
|
|
#define FORCE_CVAR(a,b) if(a)a->value = b;
|
|
|
|
void AvHHud::UpdateExploitPrevention()
|
|
{
|
|
//Note: Sometimes some clients will not have these cvars, so be sure to check that they are not null.
|
|
FORCE_CVAR(gl_monolights, 0.0f);
|
|
FORCE_CVAR(gl_overbright, 0.0f);
|
|
FORCE_CVAR(gl_clear, 0.0f);
|
|
FORCE_CVAR(hud_draw, 1.0f);
|
|
FORCE_CVAR(r_drawviewmodel, 1.0f);
|
|
FORCE_CVAR(cl_movespeedkey, AvHMUGetWalkSpeedFactor(this->GetHUDUser3()));
|
|
FORCE_CVAR(gl_d3dflip, 1.0f);
|
|
FORCE_CVAR(s_show, 0.0f);
|
|
FORCE_CVAR(r_detailtextures, 0.0f);
|
|
|
|
if(lightgamma && lightgamma->value < 2.0)
|
|
lightgamma->value = 2.0f;
|
|
}
|
|
|
|
void AvHHud::UpdateAlienUI(float inCurrentTime)
|
|
{
|
|
// Always hide it by default
|
|
this->GetManager().HideComponent(kPieHelpText);
|
|
|
|
if(this->GetIsAlien() && this->GetIsAlive())
|
|
{
|
|
float theTimePassed = inCurrentTime - this->mTimeOfLastUpdate;
|
|
// int theNumFrames = SPR_Frames(this->mAlienUIHiveSprite);
|
|
//
|
|
// for(AnimatedSpriteListType::iterator theIter = this->mAlienUIHiveList.begin(); theIter != this->mAlienUIHiveList.end(); theIter++)
|
|
// {
|
|
// const float kAnimationSpeed = 16.0f;
|
|
//
|
|
// float theCurrentFrame = theIter->mCurrentFrame + theTimePassed*kAnimationSpeed;
|
|
// if(theCurrentFrame >= theNumFrames)
|
|
// {
|
|
// theCurrentFrame -= theNumFrames;
|
|
// }
|
|
// theIter->mCurrentFrame = theCurrentFrame;
|
|
// }
|
|
|
|
// Check to see if we have any unspent upgrades. If so, change the pie menu and HUD state to reflect this
|
|
this->mNumUpgradesAvailable = 0;
|
|
for(int i = 0; i < ALIEN_UPGRADE_CATEGORY_MAX_PLUS_ONE; i++)
|
|
{
|
|
this->mCurrentUpgradeCategory[i] = ALIEN_UPGRADE_CATEGORY_INVALID;
|
|
}
|
|
|
|
int theUpgradeVar = this->GetLocalUpgrades();
|
|
|
|
if(AvHGetHasUpgradeChoiceInCategory(ALIEN_UPGRADE_CATEGORY_SENSORY, this->mUpgrades, theUpgradeVar))
|
|
{
|
|
this->mCurrentUpgradeCategory[this->mNumUpgradesAvailable] = ALIEN_UPGRADE_CATEGORY_SENSORY;
|
|
this->mNumUpgradesAvailable += 1;
|
|
}
|
|
if(AvHGetHasUpgradeChoiceInCategory(ALIEN_UPGRADE_CATEGORY_MOVEMENT, this->mUpgrades, theUpgradeVar))
|
|
{
|
|
this->mCurrentUpgradeCategory[this->mNumUpgradesAvailable] = ALIEN_UPGRADE_CATEGORY_MOVEMENT;
|
|
this->mNumUpgradesAvailable += 1;
|
|
}
|
|
if(AvHGetHasUpgradeChoiceInCategory(ALIEN_UPGRADE_CATEGORY_OFFENSE, this->mUpgrades, theUpgradeVar))
|
|
{
|
|
this->mCurrentUpgradeCategory[this->mNumUpgradesAvailable] = ALIEN_UPGRADE_CATEGORY_OFFENSE;
|
|
this->mNumUpgradesAvailable += 1;
|
|
}
|
|
if(AvHGetHasUpgradeChoiceInCategory(ALIEN_UPGRADE_CATEGORY_DEFENSE, this->mUpgrades, theUpgradeVar))
|
|
{
|
|
this->mCurrentUpgradeCategory[this->mNumUpgradesAvailable] = ALIEN_UPGRADE_CATEGORY_DEFENSE;
|
|
this->mNumUpgradesAvailable += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool AvHHud::GetCommanderLabelText(std::string& outCommanderName) const
|
|
{
|
|
|
|
int theCommander = this->GetCommanderIndex();
|
|
bool theHasCommander = (theCommander > 0) && (theCommander <= gEngfuncs.GetMaxClients());
|
|
|
|
if(!theHasCommander)
|
|
{
|
|
LocalizeString(kNoCommander, outCommanderName);
|
|
return false; // No commander
|
|
}
|
|
else
|
|
{
|
|
|
|
std::stringstream theStream;
|
|
|
|
string theCommanderText;
|
|
LocalizeString(kCommander, theCommanderText);
|
|
|
|
theStream << theCommanderText;
|
|
theStream << ": ";
|
|
|
|
hud_player_info_t thePlayerInfo;
|
|
gEngfuncs.pfnGetPlayerInfo(theCommander, &thePlayerInfo);
|
|
|
|
if(thePlayerInfo.name)
|
|
{
|
|
const int kMaxCommNameLen = 8;
|
|
theStream << string(thePlayerInfo.name).substr(0, kMaxCommNameLen);
|
|
}
|
|
|
|
outCommanderName = theStream.str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void AvHHud::UpdateMarineUI(float inCurrentTime)
|
|
{
|
|
// Find commander label
|
|
Label* theCommanderStatusLabel = NULL;
|
|
|
|
|
|
if(this->mMapMode == MAP_MODE_NS)
|
|
{
|
|
|
|
// Add handler for all pending request buttons (this does hotgroups too)
|
|
for(int i = 0; i < MESSAGE_LAST; i++)
|
|
{
|
|
AvHMessageID theMessageID = AvHMessageID(i);
|
|
|
|
char theComponentName[256];
|
|
sprintf(theComponentName, kPendingImpulseSpecifier, (int)theMessageID);
|
|
|
|
AvHTechImpulsePanel* theTechImpulsePanel = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(theComponentName, theTechImpulsePanel))
|
|
{
|
|
bool theVisibility = false;
|
|
|
|
// Do we have any requests pending?
|
|
if(this->GetIsInTopDownMode())
|
|
{
|
|
PendingRequestListType::iterator theIterator;
|
|
for(theIterator = this->mPendingRequests.begin(); theIterator != this->mPendingRequests.end(); theIterator++)
|
|
{
|
|
if(theIterator->first == theMessageID)
|
|
{
|
|
if(theIterator->second > 0)
|
|
{
|
|
theVisibility = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch(theMessageID)
|
|
{
|
|
case GROUP_SELECT_1:
|
|
case GROUP_SELECT_2:
|
|
case GROUP_SELECT_3:
|
|
case GROUP_SELECT_4:
|
|
case GROUP_SELECT_5:
|
|
case COMMANDER_SELECTALL:
|
|
theVisibility = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
theTechImpulsePanel->setVisible(theVisibility);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void AvHHud::UpdateCountdown(float inCurrentTime)
|
|
{
|
|
if(this->mCountDownClock != -1)
|
|
{
|
|
if(inCurrentTime - this->mCountDownClock > this->mLastTickPlayed)
|
|
{
|
|
// Play tick
|
|
this->PlayHUDSound(HUD_SOUND_COUNTDOWN);
|
|
this->mLastTickPlayed++;
|
|
}
|
|
|
|
if(this->mLastTickPlayed > this->mNumTicksToPlay)
|
|
{
|
|
this->AddTooltip(kGameBegun, false);
|
|
this->mCountDownClock = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateHierarchy()
|
|
{
|
|
|
|
// Start the starting point on the map to our local position
|
|
this->mOverviewMap.SetMapExtents(this->GetMapName(), this->mMapExtents);
|
|
this->mOverviewMap.SetWorldPosition(gPredictedPlayerOrigin[0], gPredictedPlayerOrigin[1]);
|
|
|
|
if(this->mHierarchy)
|
|
{
|
|
this->mHierarchy->SetFullScreen(this->GetHUDUser3() == AVH_USER3_COMMANDER_PLAYER);
|
|
}
|
|
if(this->mShowMapHierarchy)
|
|
{
|
|
this->mShowMapHierarchy->SetFullScreen(true);
|
|
}
|
|
|
|
}
|
|
|
|
string AvHHud::GetNameOfLocation(vec3_t inLocation) const
|
|
{
|
|
string theLocationName;
|
|
|
|
AvHSHUGetNameOfLocation(this->mInfoLocationList, inLocation, theLocationName);
|
|
|
|
return theLocationName;
|
|
}
|
|
|
|
|
|
void AvHHud::UpdateInfoLocation()
|
|
{
|
|
if(this->GetIsAlive() && this->GetHUDUser3() != AVH_USER3_ALIEN_EMBRYO)
|
|
{
|
|
// Don't clear our location, disconcerting to see our location disappear
|
|
//this->mLocationText = "";
|
|
|
|
this->mLocationText = this->GetNameOfLocation(gPredictedPlayerOrigin);
|
|
}
|
|
else
|
|
{
|
|
this->mLocationText = "";
|
|
}
|
|
}
|
|
|
|
bool AvHHud::GetIsCombatMode() const
|
|
{
|
|
return (this->mMapMode == MAP_MODE_CO);
|
|
}
|
|
|
|
bool AvHHud::GetIsNSMode() const
|
|
{
|
|
return (this->mMapMode == MAP_MODE_NS);
|
|
}
|
|
|
|
bool AvHHud::GetIsScriptedMode() const
|
|
{
|
|
return (this->mMapMode == MAP_MODE_NSC);
|
|
}
|
|
|
|
bool AvHHud::GetIsMouseInRegion(int inX, int inY, int inWidth, int inHeight)
|
|
{
|
|
bool theMouseIsInRegion = false;
|
|
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
int theMouseX, theMouseY;
|
|
this->GetMousePos(theMouseX, theMouseY);
|
|
|
|
if((theMouseX >= inX) && (theMouseX <= (inX + inWidth)))
|
|
{
|
|
if((theMouseY >= inY) && (theMouseY <= (inY + inHeight)))
|
|
{
|
|
theMouseIsInRegion = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return theMouseIsInRegion;
|
|
}
|
|
|
|
void AvHHud::TraceEntityID(int& outEntityID)
|
|
{
|
|
pmtrace_t tr;
|
|
vec3_t up, right, forward;
|
|
|
|
// Trace forward to see if we see a player
|
|
gEngfuncs.pEventAPI->EV_PushPMStates();
|
|
|
|
// Now add in all of the players.
|
|
gEngfuncs.pEventAPI->EV_SetSolidPlayers (-1);
|
|
|
|
gEngfuncs.pEventAPI->EV_SetTraceHull(2);
|
|
|
|
cl_entity_s* theLocalPlayer = gEngfuncs.GetLocalPlayer();
|
|
int theLocalPlayerIndex = theLocalPlayer->index;
|
|
//AngleVectors(theLocalPlayer->curstate.angles, forward, right, up);
|
|
|
|
pVector theRealView;
|
|
gEngfuncs.pfnAngleVectors(pmove->angles, forward, right, up);
|
|
|
|
Vector theStartTrace;
|
|
//VectorMA(gPredictedPlayerOrigin, kMaxPlayerHullWidth, forward, theStartTrace);
|
|
VectorCopy(gPredictedPlayerOrigin, theStartTrace);
|
|
|
|
Vector theEndTrace;
|
|
VectorMA(gPredictedPlayerOrigin, 8192, forward, theEndTrace);
|
|
bool theDone = false;
|
|
|
|
do
|
|
{
|
|
gEngfuncs.pEventAPI->EV_PlayerTrace(theStartTrace, theEndTrace, PM_NORMAL, -1, &tr);
|
|
|
|
// Ignore local player, and ignore the player we're spectating
|
|
int theHit = gEngfuncs.pEventAPI->EV_IndexFromTrace(&tr);
|
|
if(theHit == theLocalPlayerIndex)
|
|
{
|
|
VectorMA(tr.endpos, kHitOffsetAmount, forward, theStartTrace);
|
|
}
|
|
// We hit something
|
|
else if(tr.fraction < 1.0)
|
|
{
|
|
physent_t* pe = gEngfuncs.pEventAPI->EV_GetPhysent( tr.ent );
|
|
if(pe)
|
|
{
|
|
int thePotentialEntity = pe->info;
|
|
//if((thePotentialEntity >= 1) && (thePotentialEntity < gEngfuncs.GetMaxClients()))
|
|
//{
|
|
outEntityID = pe->info;
|
|
//}
|
|
}
|
|
theDone = true;
|
|
}
|
|
} while(!theDone);
|
|
|
|
gEngfuncs.pEventAPI->EV_PopPMStates();
|
|
}
|
|
|
|
bool AvHHud::GetAlienHelpForMessage(int inMessageID, string& outHelpText, int& outPointCost) const
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
char theNumber[8];
|
|
sprintf(theNumber, "%d", inMessageID);
|
|
string theNumberString(theNumber);
|
|
|
|
string theTechHelpText;
|
|
string theKey = string(kTechNodeHelpPrefix) + theNumberString;
|
|
if(LocalizeString(theKey.c_str(), theTechHelpText))
|
|
{
|
|
string thePointString;
|
|
if(LocalizeString(kPointsSuffix, thePointString))
|
|
{
|
|
/*
|
|
// Lookup point cost
|
|
for(UpgradeCostListType::const_iterator theIter = this->mPersonalUpgradeCosts.begin(); theIter != this->mPersonalUpgradeCosts.end(); theIter++)
|
|
{
|
|
if(theIter->first == inMessageID)
|
|
{
|
|
char theCostSuffix[128];
|
|
sprintf(theCostSuffix, " (%d %s)", theIter->second, thePointString.c_str());
|
|
outPointCost = theIter->second;
|
|
theTechHelpText += string(theCostSuffix);
|
|
outHelpText = theTechHelpText;
|
|
theSuccess = true;
|
|
break;
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
return theSuccess;
|
|
}
|
|
|
|
bool AvHHud::GetDoesPlayerHaveOrder() const
|
|
{
|
|
bool thePlayerHasOrder = false;
|
|
|
|
for(OrderListType::const_iterator theIter = this->mOrders.begin(); theIter != this->mOrders.end(); theIter++)
|
|
{
|
|
// Draw the order if the order is for any plays that are in our draw player list
|
|
EntityInfo theReceiverPlayer = theIter->GetReceiver();
|
|
|
|
cl_entity_s* thePlayer = gEngfuncs.GetLocalPlayer();
|
|
if(thePlayer)
|
|
{
|
|
int thePlayerIndex = thePlayer->index;
|
|
if (thePlayerIndex == theReceiverPlayer )
|
|
{
|
|
thePlayerHasOrder = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return thePlayerHasOrder;
|
|
}
|
|
|
|
|
|
bool AvHHud::GetHelpForMessage(int inMessageID, string& outHelpText) const
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
char theNumber[8];
|
|
sprintf(theNumber, "%d", (int)inMessageID);
|
|
string theNumberString(theNumber);
|
|
|
|
string theKey = string(kTechNodeLabelPrefix) + theNumberString;
|
|
string theTechNodeLabel;
|
|
if(LocalizeString(theKey.c_str(), theTechNodeLabel))
|
|
{
|
|
theKey = string(kTechNodeHelpPrefix) + theNumberString;
|
|
string theTechNodeHelp;
|
|
if(LocalizeString(theKey.c_str(), theTechNodeHelp))
|
|
{
|
|
outHelpText = /*theTechNodeLabel + " " +*/ theTechNodeLabel;
|
|
theSuccess = true;
|
|
|
|
int theCost;
|
|
bool theResearchable;
|
|
float theTime;
|
|
this->mTechNodes.GetResearchInfo((AvHMessageID)(inMessageID), theResearchable, theCost, theTime);
|
|
|
|
// Add cost
|
|
if(theCost > 0)
|
|
{
|
|
string theCostString;
|
|
if(AvHSHUGetDoesTechCostEnergy((AvHMessageID)inMessageID))
|
|
{
|
|
LocalizeString(kEnergyPrefix, theCostString);
|
|
}
|
|
else
|
|
{
|
|
LocalizeString(kMessageButtonCost, theCostString);
|
|
}
|
|
|
|
outHelpText += " ";
|
|
outHelpText += theCostString;
|
|
outHelpText += " ";
|
|
outHelpText += MakeStringFromInt(theCost);
|
|
|
|
// Draw description below
|
|
//outHelpText += "\n";
|
|
//outHelpText += theTechNodeHelp;
|
|
}
|
|
}
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
void AvHHud::UpdateMusic(float inCurrentTime)
|
|
{
|
|
bool theMusicEnabled = false;
|
|
|
|
if(this->GetGameStarted())
|
|
{
|
|
// If we're entering play mode and music is enabled, allow playing of music
|
|
if(this->GetHUDPlayMode() != PLAYMODE_READYROOM && (cl_musicenabled->value == 1.0f) && (cl_musicvolume->value > 0))
|
|
{
|
|
theMusicEnabled = true;
|
|
}
|
|
}
|
|
|
|
this->SetMusicAllowed(theMusicEnabled);
|
|
|
|
UIHud::UpdateMusic(inCurrentTime);
|
|
}
|
|
|
|
void AvHHud::UpdatePieMenuControl()
|
|
{
|
|
// Set which pie menu to use ("" for none)
|
|
bool theScoreBoardIsOpen = false;
|
|
|
|
ScorePanel* theScoreBoard = gViewPort->GetScoreBoard();
|
|
if(theScoreBoard && theScoreBoard->isVisible())
|
|
{
|
|
theScoreBoardIsOpen = true;
|
|
}
|
|
|
|
if(theScoreBoardIsOpen)
|
|
{
|
|
AvHPieMenuHandler::SetPieMenuControl("");
|
|
}
|
|
else
|
|
{
|
|
AvHPieMenuHandler::SetPieMenuControl(this->mPieMenuControl);
|
|
}
|
|
|
|
// Clear all nodes in case VGUI didn't catch events (seems to happen with lag)
|
|
if(!gPieMenuHandler.GetIsPieMenuOpen())
|
|
{
|
|
PieMenu* theCurrentPieMenu = gPieMenuHandler.GetActivePieMenu();
|
|
if(theCurrentPieMenu)
|
|
{
|
|
theCurrentPieMenu->SetFadeState(false);
|
|
}
|
|
}
|
|
|
|
// If we're dead, make sure the popup menu is closed
|
|
if(!this->GetIsAlive(false))
|
|
{
|
|
gPieMenuHandler.ClosePieMenu();
|
|
}
|
|
}
|
|
|
|
bool AvHHud::GetEntityInfoString(int inEntityID, string& outEntityInfoString, bool& outIsEnemy)
|
|
{
|
|
bool theSuccess = false;
|
|
bool theIsEnemy = false;
|
|
|
|
cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(inEntityID);
|
|
if(theEntity)
|
|
{
|
|
AvHTeamNumber theTeam = this->GetHUDTeam();
|
|
|
|
if((inEntityID >= 1) && (inEntityID <= gEngfuncs.GetMaxClients()))
|
|
{
|
|
hud_player_info_t thePlayerInfo;
|
|
gEngfuncs.pfnGetPlayerInfo(inEntityID, &thePlayerInfo);
|
|
|
|
string thePrePendString;
|
|
|
|
// Don't show cloaked enemies
|
|
if((theTeam != TEAM_IND) && !this->GetInTopDownMode() && ((theEntity->curstate.team == theTeam) || (theEntity->curstate.rendermode == kRenderNormal)))
|
|
{
|
|
//string thePostPendString;
|
|
if((theEntity->curstate.team == theTeam))
|
|
{
|
|
//LocalizeString(kFriendText, thePrePendString);
|
|
//sprintf(thePostPendString, " (health: %d)", theEntity->curstate.health);
|
|
}
|
|
else
|
|
{
|
|
LocalizeString(kEnemyText, thePrePendString);
|
|
theIsEnemy = true;
|
|
}
|
|
|
|
if(thePrePendString != "")
|
|
{
|
|
outEntityInfoString = thePrePendString + " - ";
|
|
}
|
|
}
|
|
|
|
if(thePlayerInfo.name)
|
|
{
|
|
outEntityInfoString += thePlayerInfo.name;// + thePostPendString;
|
|
|
|
// Get string from status bar and append it
|
|
const char* theStatusCStr = this->m_StatusBar.GetStatusString();
|
|
if(strlen(theStatusCStr) > 0)
|
|
{
|
|
outEntityInfoString += string(theStatusCStr);
|
|
}
|
|
|
|
outIsEnemy = theIsEnemy;
|
|
theSuccess = true;
|
|
}
|
|
|
|
// sprintf(thePlayerName, "%s (health: %d)", thePlayerInfo.name, thePlayer->curstate.health);
|
|
//}
|
|
}
|
|
else
|
|
{
|
|
bool theAutoHelpEnabled = gEngfuncs.pfnGetCvarFloat(kvAutoHelp);
|
|
|
|
// Return the type of thing it is
|
|
AvHUser3 theUser3 = (AvHUser3)(theEntity->curstate.iuser3);
|
|
|
|
if(this->GetTranslatedUser3Name(theUser3, outEntityInfoString))
|
|
{
|
|
if((theEntity->curstate.team != TEAM_IND) && (theEntity->curstate.team != theTeam))
|
|
{
|
|
outIsEnemy = true;
|
|
}
|
|
|
|
// Upper case first character
|
|
if(outEntityInfoString.length() > 0)
|
|
{
|
|
int theFirstChar = outEntityInfoString[0];
|
|
int theUpperFirstChar = toupper(theFirstChar);
|
|
outEntityInfoString[0] = theUpperFirstChar;
|
|
}
|
|
|
|
// Assume status bar set to health/armor/info data
|
|
const char* theStatusCStr = this->m_StatusBar.GetStatusString();
|
|
bool theHasStatusString = (strlen(theStatusCStr) > 0);
|
|
if(theHasStatusString)
|
|
{
|
|
outEntityInfoString += string(theStatusCStr);
|
|
}
|
|
|
|
if(theAutoHelpEnabled)
|
|
{
|
|
string theDescription;
|
|
bool theIsFriendly = (this->GetHUDTeam() == theEntity->curstate.team);
|
|
if(this->GetTranslatedUser3Description(theUser3, theIsFriendly, theDescription))
|
|
{
|
|
outEntityInfoString += " - " + theDescription;
|
|
}
|
|
}
|
|
|
|
// Only display help when asked for or important
|
|
if(theAutoHelpEnabled || theHasStatusString)
|
|
{
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
void AvHHud::UpdateEntityID(float inCurrentTime)
|
|
{
|
|
this->mBuildingEffectsEntityList.clear();
|
|
|
|
bool theSetHelpMessage = false;
|
|
bool theSetReticleMessage = false;
|
|
|
|
//char* theNewPlayerName = NULL;
|
|
int theEntityIndex = -1;
|
|
|
|
if(this->GetHUDUser3() == AVH_USER3_COMMANDER_PLAYER)
|
|
{
|
|
int theCurrentX, theCurrentY;
|
|
this->GetMousePos(theCurrentX, theCurrentY);
|
|
|
|
// Don't show help when mouse is over the UI
|
|
float theNormX = ((float)theCurrentX)/(ScreenWidth());
|
|
float theNormY = ((float)theCurrentY)/(ScreenHeight());
|
|
if(!this->GetIsRegionBlockedByUI(theNormX, theNormY))
|
|
{
|
|
Vector theNormRay;
|
|
|
|
CreatePickingRay(theCurrentX, theCurrentY, theNormRay);
|
|
|
|
// Look for player and entities under/near the mouse
|
|
AvHSHUGetEntityAtRay(this->GetVisualOrigin(), theNormRay, theEntityIndex);
|
|
}
|
|
}
|
|
else if(g_iUser1 != OBS_IN_EYE)
|
|
{
|
|
// Trace entity id in front of us
|
|
this->TraceEntityID(theEntityIndex);
|
|
}
|
|
|
|
if(this->mSelectingWeaponID != -1)
|
|
{
|
|
// Look up help, set our current help to it
|
|
string theWeaponHelpKey;
|
|
sprintf(theWeaponHelpKey, kWeaponHelpText, this->mSelectingWeaponID);
|
|
|
|
string theHelpText;
|
|
if(LocalizeString(theWeaponHelpKey.c_str(), theHelpText))
|
|
{
|
|
// Get damage amount from weapon
|
|
ASSERT(this->mSelectingWeaponID >= 0);
|
|
ASSERT(this->mSelectingWeaponID < 32);
|
|
WEAPON* theWeapon = gWR.GetWeapon(this->mSelectingWeaponID);
|
|
if( theWeapon )
|
|
{
|
|
int theDamage = theWeapon->iMax2;
|
|
|
|
char theHelpTextWithDamage[1024];
|
|
sprintf(theHelpTextWithDamage, theHelpText.c_str(), theDamage);
|
|
|
|
this->SetHelpMessage(theHelpTextWithDamage);
|
|
theSetHelpMessage = true;
|
|
}
|
|
}
|
|
}
|
|
else if(this->mTechHelpText != "")
|
|
{
|
|
this->SetHelpMessage(this->mTechHelpText, false, .8f, .6f);
|
|
theSetHelpMessage = true;
|
|
}
|
|
else if(this->mSelectingNodeID > 0)
|
|
{
|
|
char theNumber[8];
|
|
sprintf(theNumber, "%d", this->mSelectingNodeID);
|
|
string theNumberString(theNumber);
|
|
|
|
string theKey = string(kTechNodeHelpPrefix) + theNumberString;
|
|
if(LocalizeString(theKey.c_str(), this->mReticleInfoText))
|
|
{
|
|
string theCostString;
|
|
if(LocalizeString(kCostMarker, theCostString))
|
|
{
|
|
string thePointsString;
|
|
if(LocalizeString(kPointsSuffix, thePointsString))
|
|
{
|
|
}
|
|
|
|
// Don't draw marine sayings, as they are printed on the controls and the aliens are using the titles.txt entries
|
|
if(this->GetIsMarine())
|
|
{
|
|
switch(this->mSelectingNodeID)
|
|
{
|
|
case SAYING_1:
|
|
case SAYING_2:
|
|
case SAYING_3:
|
|
case SAYING_4:
|
|
case SAYING_5:
|
|
case SAYING_6:
|
|
case SAYING_7:
|
|
case SAYING_8:
|
|
case SAYING_9:
|
|
this->mReticleInfoText = "";
|
|
break;
|
|
}
|
|
}
|
|
|
|
this->SetHelpMessage(this->mReticleInfoText);
|
|
theSetHelpMessage = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(theEntityIndex > 0)
|
|
{
|
|
// Don't draw info for cloaked structures
|
|
cl_entity_s* theProgressEntity = gEngfuncs.GetEntityByIndex(theEntityIndex);
|
|
if(theProgressEntity)
|
|
{
|
|
if((theProgressEntity->curstate.rendermode != kRenderTransTexture) || (theProgressEntity->curstate.renderamt > kAlienStructureCloakAmount))
|
|
{
|
|
if(std::find(this->mBuildingEffectsEntityList.begin(), this->mBuildingEffectsEntityList.end(), theEntityIndex) == this->mBuildingEffectsEntityList.end())
|
|
{
|
|
this->mBuildingEffectsEntityList.push_back(theEntityIndex);
|
|
}
|
|
|
|
bool theEntityIsPlayer = ((theEntityIndex > 0) && (theEntityIndex <= gEngfuncs.GetMaxClients()));
|
|
|
|
string theHelpText;
|
|
bool theIsEnemy = false;
|
|
|
|
if(this->GetEntityInfoString(theEntityIndex, theHelpText, theIsEnemy))
|
|
{
|
|
// Set color to red if enemy, otherise to our HUD color
|
|
int theR, theG, theB;
|
|
if(theIsEnemy)
|
|
{
|
|
theR = 255;
|
|
theG = theB = 0;
|
|
}
|
|
else
|
|
{
|
|
this->GetPrimaryHudColor(theR, theG, theB, true, false);
|
|
}
|
|
|
|
// If we have auto help on, or we're in top down mode, display as help
|
|
if(gEngfuncs.pfnGetCvarFloat(kvAutoHelp) || this->GetInTopDownMode())
|
|
{
|
|
this->SetHelpMessage(theHelpText);
|
|
|
|
this->mHelpMessage.SetRGB(theR, theG, theB);
|
|
|
|
theSetHelpMessage = true;
|
|
}
|
|
// else, display as reticle message
|
|
else
|
|
{
|
|
this->SetReticleMessage(theHelpText);
|
|
|
|
this->mReticleMessage.SetRGB(theR, theG, theB);
|
|
|
|
theSetReticleMessage = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//char theMessage[128];
|
|
//sprintf(theMessage, "Entity %d cloaked, not drawing circle.", theProgressEntity->curstate.iuser3);
|
|
//CenterPrint(theMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
float theTimePassed = (inCurrentTime - this->mTimeOfLastUpdate);
|
|
if(!theSetHelpMessage)
|
|
{
|
|
this->mHelpMessage.FadeText(theTimePassed, true);
|
|
}
|
|
if(!theSetReticleMessage)
|
|
{
|
|
this->mReticleMessage.FadeText(theTimePassed, true);
|
|
}
|
|
}
|
|
|
|
int AvHHud::GetMenuTechSlots() const
|
|
{
|
|
return this->mMenuTechSlots;
|
|
}
|
|
|
|
const AvHTechTree& AvHHud::GetTechNodes() const
|
|
{
|
|
return this->mTechNodes;
|
|
}
|
|
|
|
void AvHHud::GetTooltipDrawingInfo(float& outNormX, float& outNormY) const
|
|
{
|
|
outNormX = kHelpMessageLeftEdgeInset;
|
|
outNormY = kHelpMessageTopEdgeInset;
|
|
|
|
if(this->GetPlayMode() == PLAYMODE_READYROOM)
|
|
{
|
|
outNormY = 1.0f;
|
|
}
|
|
else if(this->GetInTopDownMode())
|
|
{
|
|
outNormY = kHelpMessageCommanderTopEdgeInset;
|
|
}
|
|
else if(this->GetIsAlien())
|
|
{
|
|
outNormY = kHelpMessageAlienTopEdgeInset;
|
|
}
|
|
|
|
outNormY -= kToolTipVerticalSpacing;
|
|
}
|
|
|
|
string AvHHud::GetRankTitle(bool inShowUnspentLevels) const
|
|
{
|
|
string theText;
|
|
|
|
char* theTeamName = this->GetIsMarine() ? "Marine" : "Alien";
|
|
int theCurrentLevel = this->GetHUDExperienceLevel();
|
|
|
|
char theCharArray[512];
|
|
sprintf(theCharArray, kRankText, theTeamName, theCurrentLevel);
|
|
LocalizeString(theCharArray, theText);
|
|
|
|
// Add unspent levels, if any
|
|
int theUnspentLevels = (this->mExperienceLevel - this->mExperienceLevelSpent - 1);
|
|
if(inShowUnspentLevels && (theUnspentLevels > 0))
|
|
{
|
|
// We can't accurately draw player's unspent levels when we're dead, as we only know our own
|
|
if(this->GetIsAlive(false))
|
|
{
|
|
string theUnspentLevelText = "(+" + MakeStringFromInt(theUnspentLevels) + ")";
|
|
theText += theUnspentLevelText;
|
|
}
|
|
}
|
|
|
|
return theText;
|
|
}
|
|
|
|
void AvHHud::GetReticleTextDrawingInfo(float& outNormX, float& outNormY, bool& outCentered) const
|
|
{
|
|
outCentered = false;
|
|
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
int theCurrentX, theCurrentY;
|
|
this->GetMousePos(theCurrentX, theCurrentY);
|
|
outNormX = theCurrentX/(float)ScreenWidth();
|
|
outNormY = theCurrentY/(float)ScreenHeight();
|
|
|
|
// Move text up a bit so it doesn't obscure
|
|
outNormY -= .1f;
|
|
|
|
outCentered = true;
|
|
}
|
|
else
|
|
{
|
|
if(gEngfuncs.pfnGetCvarFloat(kvCenterEntityID))
|
|
{
|
|
outNormX = .5f;
|
|
outNormY = .5f;
|
|
outCentered = true;
|
|
}
|
|
else
|
|
{
|
|
outNormX = kHelpMessageLeftEdgeInset;
|
|
outNormY = kHelpMessageTopEdgeInset - kReticleMessageHeight;
|
|
|
|
// Alien HUD forces this to be inset a bit
|
|
if(this->GetIsAlien())
|
|
{
|
|
outNormX = kHelpMessageAlienLeftedgeInset + kReticleMessageAlienLeftInset;
|
|
outNormY = kHelpMessageAlienTopEdgeInset - kReticleMessageHeight;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Assumes that the tooltips aren't centered
|
|
void AvHHud::UpdateTooltips(float inCurrentTime)
|
|
{
|
|
float theReticleX;
|
|
float theReticleY;
|
|
this->GetTooltipDrawingInfo(theReticleX, theReticleY);
|
|
|
|
float theBottomMostY = theReticleY;
|
|
|
|
float theTimePassed = inCurrentTime - this->mTimeOfLastUpdate;
|
|
float kMovement = 1.0f*theTimePassed;
|
|
|
|
int theBottomScreenY = theBottomMostY*ScreenHeight();
|
|
|
|
// Clear all tooltips on a role change, or on a playmode change
|
|
AvHUser3 theCurrentUser3 = this->GetHUDUser3();
|
|
AvHTeamNumber theCurrentTeam = this->GetHUDTeam();
|
|
AvHPlayMode thePlayMode = this->GetPlayMode();
|
|
|
|
if((theCurrentUser3 != this->mLastUser3) || (this->mLastTeamNumber != theCurrentTeam) || ((thePlayMode != this->mLastPlayMode) && (this->mLastPlayMode != PLAYMODE_UNDEFINED)) )
|
|
{
|
|
this->mTooltips.clear();
|
|
}
|
|
|
|
// Stuff to get reset on a team change
|
|
if(this->mLastTeamNumber != theCurrentTeam)
|
|
{
|
|
this->mExperienceLevelLastDrawn = 1;
|
|
}
|
|
|
|
// Run through list, dropping them down as far as they can go. Assumes the first one in the list is the bottommost one
|
|
for(AvHTooltipListType::iterator theIter = this->mTooltips.begin(); theIter != this->mTooltips.end(); /* no inc */)
|
|
{
|
|
// Recompute settings, if it hasn't been updated before
|
|
theIter->RecomputeIfNeccessary();
|
|
|
|
// Get height of current tool tip
|
|
int theTooltipScreenHeight = theIter->GetScreenHeight();
|
|
|
|
// Move it down towards the current limit
|
|
float theCurrentMinScreenY = theIter->GetNormalizedScreenY();
|
|
int theCurrentTipScreenBottom = (int)(theCurrentMinScreenY) + theTooltipScreenHeight;
|
|
|
|
float theCurrentMaxNormY = (float)(theBottomScreenY - theTooltipScreenHeight)/ScreenHeight();
|
|
float theNewNormY = min(theCurrentMaxNormY, (theCurrentMinScreenY + kMovement));
|
|
|
|
// Now this is a crazy bug! In release mode without the following two statements, theNewNormY isn't > theCurrentMinScreenY when it should be.
|
|
// It's as if a little time is needed between the computation of theNewNormY and using theNewNormY for it to work
|
|
char theMessage[256];
|
|
sprintf(theMessage, "theNewNormY %f, minScreenY: %f)", theNewNormY, theCurrentMinScreenY);
|
|
//CenterPrint(theMessage);
|
|
|
|
// If we moved it down
|
|
if(theNewNormY > theCurrentMinScreenY)
|
|
{
|
|
// Fade it in while it's dropping
|
|
theIter->FadeText(theTimePassed, false);
|
|
}
|
|
else
|
|
{
|
|
if(theIter == this->mTooltips.begin())
|
|
{
|
|
// If it's at the bottom of the list, start fading it out
|
|
theIter->FadeText(theTimePassed, true);
|
|
}
|
|
}
|
|
|
|
// Set the new position
|
|
theIter->SetNormalizedScreenY(theNewNormY);
|
|
|
|
// Subtract it's height to the current limit
|
|
theBottomScreenY -= theTooltipScreenHeight;
|
|
|
|
// Subtract out small spacing amount
|
|
theBottomScreenY -= max(1, kToolTipVerticalSpacing*ScreenHeight());
|
|
|
|
// If it's totally faded out, remove it from the list, else process next
|
|
int theAlpha = theIter->GetA();
|
|
if(theAlpha == 0)
|
|
{
|
|
theIter = this->mTooltips.erase(theIter);
|
|
}
|
|
else
|
|
{
|
|
theIter++;
|
|
}
|
|
|
|
//char theTempBuffer[256];
|
|
//sprintf(theTempBuffer, "UpdateTooltips, alpha: %d\n", theAlpha);
|
|
//CenterPrint(theTempBuffer);
|
|
}
|
|
|
|
// Update combat upgrade menu too
|
|
if(this->GetIsCombatMode())
|
|
{
|
|
const int kScrollDirection = this->mDrawCombatUpgradeMenu ? 1 : -1;
|
|
const float kScrollingSpeed = .7f*kScrollDirection;
|
|
|
|
float theXDiff = (theTimePassed*kScrollingSpeed);
|
|
const float kNormalizedWidth = this->mCombatUpgradeMenu.GetNormalizedMaxWidth();
|
|
|
|
const float kLeftEdgeInset = .02f;
|
|
float theNewX = this->mCombatUpgradeMenu.GetNormalizedScreenX() + theXDiff;
|
|
theNewX = max(-kNormalizedWidth, theNewX);
|
|
theNewX = min(theNewX, kLeftEdgeInset);
|
|
|
|
this->mCombatUpgradeMenu.SetNormalizedScreenX(theNewX);
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateStructureNotification(float inCurrentTime)
|
|
{
|
|
const float kTimeToDisplayIcon = 6.0f;
|
|
const int kMaxIcons = 5;
|
|
|
|
for(StructureHUDNotificationListType::iterator theIter = this->mStructureNotificationList.begin(); theIter != this->mStructureNotificationList.end(); /* no inc */)
|
|
{
|
|
if((inCurrentTime > (theIter->mTime + kTimeToDisplayIcon)) || (this->mStructureNotificationList.size() > kMaxIcons))
|
|
{
|
|
theIter = this->mStructureNotificationList.erase(theIter);
|
|
}
|
|
else
|
|
{
|
|
theIter++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//void AvHHud::FadeText(float inCurrentTime, bool inFadeDown)
|
|
//{
|
|
// const float kReticleInfoFadeUpSpeed = 500;
|
|
// const float kReticleInfoFadeDownSpeed = -150;
|
|
//
|
|
// // Fade reticle nicely
|
|
// int theFadeSpeed = inFadeDown ? kReticleInfoFadeDownSpeed : kReticleInfoFadeUpSpeed;
|
|
//
|
|
// float theTimePassed = (inCurrentTime - this->mTimeOfLastUpdate);
|
|
// float theNewAlpha = this->mReticleInfoColorA + theTimePassed*theFadeSpeed;
|
|
// this->mReticleInfoColorA = max(0, min(255, theNewAlpha));
|
|
//}
|
|
|
|
float AvHHud::GetTimeOfLastUpdate() const
|
|
{
|
|
return this->mTimeOfLastUpdate;
|
|
}
|
|
|
|
void AvHHud::UpdateProgressBar()
|
|
{
|
|
this->HideProgressStatus();
|
|
|
|
float thePercentage;
|
|
if(gMiniMap.GetIsProcessing(&thePercentage))
|
|
{
|
|
if(gMiniMap.WriteSpritesIfJustFinished())
|
|
{
|
|
this->HideProgressStatus();
|
|
}
|
|
else
|
|
{
|
|
this->SetProgressStatus(thePercentage);
|
|
}
|
|
}
|
|
// else if(this->mProgressBarEntityIndex == -1)
|
|
// {
|
|
// this->HideGenericProgressStatus();
|
|
// }
|
|
else
|
|
{
|
|
// Look up entity, and set progress according to it's fuser1
|
|
cl_entity_s* theProgressEntity = gEngfuncs.GetEntityByIndex(this->mProgressBarEntityIndex);
|
|
if(theProgressEntity)
|
|
{
|
|
ASSERT(this->mProgressBarParam >= 1);
|
|
ASSERT(this->mProgressBarParam <= 4);
|
|
|
|
float theProgress = 0.0f;
|
|
switch(this->mProgressBarParam)
|
|
{
|
|
case 1:
|
|
theProgress = theProgressEntity->curstate.fuser1;
|
|
break;
|
|
case 2:
|
|
theProgress = theProgressEntity->curstate.fuser2;
|
|
break;
|
|
case 3:
|
|
theProgress = theProgressEntity->curstate.fuser3;
|
|
break;
|
|
case 4: // NOTE: check delta.lst for fuser4, it isn't propagated currently
|
|
theProgress = theProgressEntity->curstate.fuser4;
|
|
break;
|
|
}
|
|
|
|
if((this->GetHUDUser3() == AVH_USER3_ALIEN_EMBRYO) || this->GetIsDigesting())
|
|
{
|
|
theProgress = pmove->fuser3;
|
|
}
|
|
|
|
thePercentage = theProgress/kNormalizationNetworkFactor;
|
|
if(thePercentage < 1.0f)
|
|
{
|
|
this->SetProgressStatus(thePercentage);
|
|
}
|
|
// else
|
|
// {
|
|
// this->HideGenericProgressStatus();
|
|
// }
|
|
}
|
|
else
|
|
{
|
|
// Look at selection. If selection has research and research isn't done, draw research bar. Else, hide research bar
|
|
if(this->mSelected.size() == 1)
|
|
{
|
|
cl_entity_s* theEntity = gEngfuncs.GetEntityByIndex(*this->mSelected.begin());
|
|
if(theEntity)
|
|
{
|
|
this->HideProgressStatus();
|
|
this->HideResearchProgressStatus();
|
|
|
|
bool theIsBuilding, theIsResearching;
|
|
float thePercentage;
|
|
AvHSHUGetBuildResearchState(theEntity->curstate.iuser3, theEntity->curstate.iuser4, theEntity->curstate.fuser1, theIsBuilding, theIsResearching, thePercentage);
|
|
|
|
if(theIsBuilding && (thePercentage > 0.0f) && (thePercentage < 1.0f))
|
|
{
|
|
// Turned off progress bar now that we have circular build icons
|
|
//this->SetGenericProgressStatus(thePercentage);
|
|
}
|
|
else if(theIsResearching && (thePercentage > 0) && (thePercentage < 1.0f))
|
|
{
|
|
this->SetResearchProgressStatus(thePercentage);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::GhostBuildingCallback(struct tempent_s* inEntity, float inFrametime, float inCurrentTime)
|
|
{
|
|
if(this->mGhostBuilding != MESSAGE_NULL)
|
|
{
|
|
// Don't let it die
|
|
inEntity->die = gClientTimeLastUpdate + 2.0f;
|
|
|
|
// Update position to be where mouse is
|
|
VectorCopy(this->mGhostWorldLocation, inEntity->entity.origin);
|
|
|
|
// Visually indicate whether this is a valid position or not
|
|
if(this->mCurrentGhostIsValid)
|
|
{
|
|
inEntity->entity.curstate.renderfx = kRenderFxGlowShell;
|
|
inEntity->entity.curstate.rendercolor.r = 0;
|
|
inEntity->entity.curstate.rendercolor.g = 255;
|
|
inEntity->entity.curstate.rendercolor.b = 0;
|
|
inEntity->entity.curstate.renderamt = kShellRenderAmount;
|
|
}
|
|
else
|
|
{
|
|
inEntity->entity.curstate.renderfx = kRenderFxGlowShell;
|
|
inEntity->entity.curstate.rendercolor.r = 255;
|
|
inEntity->entity.curstate.rendercolor.g = 0;
|
|
inEntity->entity.curstate.rendercolor.b = 0;
|
|
inEntity->entity.curstate.renderamt = kShellRenderAmount;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Kill it off immediately
|
|
inEntity->die = gClientTimeLastUpdate;
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateBuildingPlacement()
|
|
{
|
|
if(this->mGhostBuilding != MESSAGE_NULL)
|
|
{
|
|
// Fetch current mouse up/down state from gScrollHandler and store
|
|
bool theMouseOneDown = gScrollHandler.GetMouseOneDown() && !gCommanderHandler.GetMouseOneDown();
|
|
bool theMouseTwoDown = gScrollHandler.GetMouseTwoDown();
|
|
|
|
// If we haven't created the temp entity, create it
|
|
if(!this->mCreatedGhost)
|
|
{
|
|
// Create the temporary entity
|
|
int theModelIndex;
|
|
char* theModelName = AvHSHUGetBuildTechModelName(this->mGhostBuilding);
|
|
if(theModelName)
|
|
{
|
|
if(this->mLastGhostBuilding)
|
|
{
|
|
this->mLastGhostBuilding->die = -1;
|
|
this->mLastGhostBuilding = NULL;
|
|
}
|
|
|
|
vec3_t theOrigin = this->GetVisualOrigin();
|
|
struct model_s* theModel = gEngfuncs.CL_LoadModel(theModelName, &theModelIndex);
|
|
TEMPENTITY* theTempEntity = gEngfuncs.pEfxAPI->CL_TentEntAllocCustom(gPredictedPlayerOrigin, theModel, 0, CLinkGhostBuildingCallback);
|
|
if(theTempEntity)
|
|
{
|
|
theTempEntity->die += 10.0f;
|
|
theTempEntity->flags |= FTENT_PERSIST;
|
|
// Temp entities interpret baseline origin as velocity.
|
|
VectorCopy(vec3_origin, theTempEntity->entity.baseline.origin);
|
|
|
|
// Set special properties for some models
|
|
if(this->mGhostBuilding == BUILD_SCAN)
|
|
{
|
|
theTempEntity->entity.curstate.rendermode = kRenderTransAdd;
|
|
theTempEntity->entity.curstate.renderamt = 255;
|
|
|
|
theTempEntity->entity.baseline.rendermode = kRenderTransAdd;
|
|
theTempEntity->entity.baseline.renderamt = 255;
|
|
}
|
|
|
|
this->mCreatedGhost = true;
|
|
}
|
|
|
|
this->mLastGhostBuilding = theTempEntity;
|
|
}
|
|
}
|
|
|
|
// Update location we draw ghosted entity
|
|
int theMouseX, theMouseY;
|
|
this->GetMousePos(theMouseX, theMouseY);
|
|
|
|
Vector theNormMousePos;
|
|
CreatePickingRay(theMouseX, theMouseY, theNormMousePos);
|
|
|
|
//char theMessage[256];
|
|
//sprintf(theMessage, "Ghost: %f, %f, %f", this->mGhostWorldLocation[0], this->mGhostWorldLocation[1],this->mGhostWorldLocation[2]);
|
|
//CenterPrint(theMessage);
|
|
|
|
// Was either mouse button pressed?
|
|
bool theMouseOneReleased = (theMouseOneDown && !this->mMouseOneDown);
|
|
bool theMouseTwoReleased = (theMouseTwoDown && !this->mMouseTwoDown);
|
|
if(theMouseOneReleased)
|
|
{
|
|
VectorCopy(this->mLeftMouseWorldStart, this->mNormBuildLocation);
|
|
}
|
|
else if(theMouseTwoReleased)
|
|
{
|
|
VectorCopy(this->mRightMouseWorldStart, this->mNormBuildLocation);
|
|
}
|
|
|
|
// Test to see if we're in a valid position
|
|
this->mCurrentGhostIsValid = false;
|
|
|
|
vec3_t theLocation;
|
|
if(AvHSHUTraceAndGetIsSiteValidForBuild(this->mGhostBuilding, this->GetVisualOrigin(), theNormMousePos, &theLocation))
|
|
{
|
|
// Update with cost and research info
|
|
bool theIsResearchable;
|
|
int theCost;
|
|
float theTime;
|
|
if(this->mTechNodes.GetResearchInfo(this->mGhostBuilding, theIsResearchable, theCost, theTime))
|
|
{
|
|
// Ghost is valid if message available and
|
|
// we have enough resources OR
|
|
// tech takes energy and we have enough energy
|
|
this->mCurrentGhostIsValid = false;
|
|
|
|
if(this->mTechNodes.GetIsMessageAvailable(this->mGhostBuilding))
|
|
{
|
|
bool theTakesEnergy = AvHSHUGetDoesTechCostEnergy(this->mGhostBuilding);
|
|
if((theCost <= this->mResources) || (theTakesEnergy))
|
|
{
|
|
this->mCurrentGhostIsValid = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw at selection start range * invalid range multiplier if invalid placement, draw on at target location if valid
|
|
//VectorMA(this->GetVisualOrigin(), kSelectionStartRange*kBuildInvalidRangeMultiplier, theNormMousePos, this->mGhostWorldLocation);
|
|
VectorMA(this->GetVisualOrigin(), kSelectionStartRange*8, theNormMousePos, this->mGhostWorldLocation);
|
|
//if(this->mCurrentGhostIsValid)
|
|
//{
|
|
VectorCopy(theLocation, this->mGhostWorldLocation);
|
|
//}
|
|
|
|
if((theMouseOneReleased) || (theMouseTwoReleased))
|
|
{
|
|
// If this is a valid location
|
|
if(this->mCurrentGhostIsValid)
|
|
{
|
|
// Play sound
|
|
this->PlayHUDSound(HUD_SOUND_PLACE_BUILDING);
|
|
|
|
// Remember it for input to grab
|
|
this->mValidatedBuilding = this->mGhostBuilding;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::CancelBuilding()
|
|
{
|
|
SetGhostBuildingMode(MESSAGE_NULL);
|
|
this->mValidatedBuilding = MESSAGE_NULL;
|
|
}
|
|
|
|
void AvHHud::UpdateSelection()
|
|
{
|
|
// Fetch current mouse up/down state from gScrollHandler and store
|
|
bool theMouseOneDown = gScrollHandler.GetMouseOneDown() && !gCommanderHandler.GetMouseOneDown();
|
|
bool theMouseTwoDown = gScrollHandler.GetMouseTwoDown();
|
|
|
|
int theCurrentX, theCurrentY;
|
|
this->GetMousePos(theCurrentX, theCurrentY);
|
|
|
|
CreatePickingRay(theCurrentX, theCurrentY, this->mMouseWorldPosition);
|
|
//ASSERT(this->mMouseWorldPosition.z < 0.0f);
|
|
|
|
// Left mouse button //
|
|
// If mouse just pressed, set starting point
|
|
if(theMouseOneDown && !this->mMouseOneDown)
|
|
{
|
|
this->mMouseOneStartX = theCurrentX;
|
|
this->mMouseOneStartY = theCurrentY;
|
|
this->mLeftMouseStarted = true;
|
|
|
|
//CreatePickingRay(theCurrentX, theCurrentY, this->mLeftMouseWorldStart);
|
|
//ASSERT(this->mLeftMouseWorldStart.z < 0.0f);
|
|
VectorCopy(this->mMouseWorldPosition, this->mLeftMouseWorldStart);
|
|
}
|
|
else
|
|
{
|
|
this->mLeftMouseStarted = false;
|
|
}
|
|
|
|
// If mouse just released, set flag to indicate selection just changed
|
|
if(!theMouseOneDown && this->mMouseOneDown)
|
|
{
|
|
//CreatePickingRay(theCurrentX, theCurrentY, this->mLeftMouseWorldEnd);
|
|
//ASSERT(this->mLeftMouseWorldEnd.z < 0.0f);
|
|
VectorCopy(this->mMouseWorldPosition, this->mLeftMouseWorldEnd);
|
|
|
|
//this->mSelectionJustChanged = true;
|
|
this->mLeftMouseEnded = true;
|
|
}
|
|
else
|
|
{
|
|
this->mLeftMouseEnded = false;
|
|
}
|
|
|
|
// Right mouse button //
|
|
// If mouse two just pressed, set starting point
|
|
if(theMouseTwoDown && !this->mMouseTwoDown)
|
|
{
|
|
this->mMouseTwoStartX = theCurrentX;
|
|
this->mMouseTwoStartY = theCurrentY;
|
|
this->mRightMouseStarted = true;
|
|
|
|
//CreatePickingRay(theCurrentX, theCurrentY, this->mRightMouseWorldStart);
|
|
//ASSERT(this->mRightMouseWorldStart.z < 0.0f);
|
|
VectorCopy(this->mMouseWorldPosition, this->mRightMouseWorldStart);
|
|
}
|
|
else
|
|
{
|
|
this->mRightMouseStarted = false;
|
|
}
|
|
|
|
// If mouse just released, set flag to indicate selection just changed
|
|
if(!theMouseTwoDown && this->mMouseTwoDown)
|
|
{
|
|
//CreatePickingRay(theCurrentX, theCurrentY, this->mRightMouseWorldEnd);
|
|
//ASSERT(this->mRightMouseWorldEnd.z < 0.0f);
|
|
VectorCopy(this->mMouseWorldPosition, this->mRightMouseWorldEnd);
|
|
|
|
//this->mSelectionJustChanged = true;
|
|
this->mRightMouseEnded = true;
|
|
}
|
|
else
|
|
{
|
|
this->mRightMouseEnded = false;
|
|
}
|
|
|
|
// Set extents of marquee control
|
|
this->mSelectionBox->SetStartPos(this->mMouseOneStartX, this->mMouseOneStartY);
|
|
this->mSelectionBox->SetEndPos(theCurrentX, theCurrentY);
|
|
|
|
// Set visibility state of marquee control
|
|
//this->mSelectionBox->setVisible(theMouseOneDown);
|
|
this->mSelectionBox->setVisible(false);
|
|
|
|
this->mSelectionBoxX1 = mMouseOneStartX;
|
|
this->mSelectionBoxY1 = mMouseOneStartY;
|
|
this->mSelectionBoxX2 = theCurrentX;
|
|
this->mSelectionBoxY2 = theCurrentY;
|
|
|
|
this->mSelectionBoxVisible = theMouseOneDown;
|
|
|
|
// If we're just selecting stuff, don't want to hit this button by mistake
|
|
//gCommanderHandler.SetActive(!theMouseOneDown);
|
|
|
|
// Change context sensitive cursor depending on current position
|
|
//if(this->mSelected.size() > 0)
|
|
//{
|
|
// if(this->mGhostBuilding == MESSAGE_NULL)
|
|
// {
|
|
// Vector theCurrentMouseRay;
|
|
// CreatePickingRay(theCurrentX, theCurrentY, theCurrentMouseRay);
|
|
//
|
|
// int theTargetIndex;
|
|
// AvHOrderTargetType theTargetType;
|
|
// Vector theTargetLocation;
|
|
// AvHUser3 theUser3 = AVH_USER3_NONE;
|
|
// AvHOrderType theOrderType = AvHGetDefaultOrderType(this->GetHUDTeam(), this->GetVisualOrigin(), theCurrentMouseRay, theTargetIndex, theTargetLocation, theUser3, theTargetType);
|
|
// Test UI blocking
|
|
// theOrderType = ORDERTYPEL_DEFAULT;
|
|
// if(!AvHSHUGetIsRegionBlockedByUI((float)theCurrentX/ScreenWidth, (float)theCurrentY/ScreenHeight))
|
|
// {
|
|
// theOrderType = ORDERTYPET_GUARD;
|
|
// }
|
|
// this->SetCursor(theOrderType);
|
|
|
|
// Change cursor depending on order type
|
|
//if(theOrderType != ORDERTYPEL_MOVE && this->mSelected.size() > 0 )
|
|
//{
|
|
// if(!this->GetIsRegionBlockedByUI(theCurrentX/ScreenWidth(), theCurrentY/ScreenHeight()))
|
|
// {
|
|
//this->SetCursor(theOrderType);
|
|
// }
|
|
//}
|
|
// }
|
|
//}
|
|
|
|
if(this->mLeftMouseEnded)
|
|
{
|
|
// Select all units at this click or in this area (but don't select when clicking a building down)
|
|
if(!this->mPlacingBuilding)
|
|
{
|
|
gSelectionHelper.QueueSelection(this->GetVisualOrigin(), this->mLeftMouseWorldStart, this->mLeftMouseWorldEnd, this->GetHUDTeam());
|
|
gSelectionHelper.ProcessPendingSelections();
|
|
}
|
|
}
|
|
|
|
if(gSelectionHelper.SelectionResultsWaiting())
|
|
{
|
|
EntityListType theNewSelection;
|
|
gSelectionHelper.GetAndClearSelection(theNewSelection);
|
|
// this->mNumLocalSelectEvents++;
|
|
|
|
if(theNewSelection != this->mSelected)
|
|
{
|
|
this->mSelected = theNewSelection;
|
|
this->mSelectionJustChanged = true;
|
|
}
|
|
|
|
this->ClearTrackingEntity();
|
|
}
|
|
|
|
// If selection just changed, make sure we have selection effects for everyone
|
|
if(this->mSelectionJustChanged)
|
|
{
|
|
// Create effects
|
|
this->SetSelectionEffects(this->mSelected);
|
|
|
|
this->PlayHUDSound(HUD_SOUND_SELECT);
|
|
|
|
gCommanderHandler.SetSelectedUnits(this->mSelected);
|
|
|
|
// Clear flag
|
|
this->mSelectionJustChanged = false;
|
|
|
|
// // Set default order mode
|
|
// if(this->mSelected.size() > 0)
|
|
// {
|
|
// this->mOrderMode = ORDERTYPEL_DEFAULT;
|
|
// }
|
|
// else
|
|
// {
|
|
// this->mOrderMode = ORDERTYPE_UNDEFINED;
|
|
// }
|
|
}
|
|
|
|
this->UpdateBuildingPlacement();
|
|
|
|
// Store current mouse state
|
|
this->mMouseOneDown = theMouseOneDown;
|
|
this->mMouseTwoDown = theMouseTwoDown;
|
|
}
|
|
|
|
void AvHHud::UpdateBuildResearchText()
|
|
{
|
|
// Hide unchanging ("unhelpful"?) help text after this amount of time
|
|
const float kHelpTextInterval = 2.5f;
|
|
|
|
if(this->GetHUDUser3() == AVH_USER3_COMMANDER_PLAYER)
|
|
{
|
|
Label* theHelpTextLabel = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(kTechHelpText, theHelpTextLabel))
|
|
{
|
|
gCommanderHandler.RecalculateBuildResearchText();
|
|
|
|
// Display build/research text
|
|
string theBuildResearchText = gCommanderHandler.GetBuildResearchText();
|
|
theHelpTextLabel->setText(theBuildResearchText.c_str());
|
|
|
|
// Center it
|
|
int theWidth, theHeight;
|
|
theHelpTextLabel->getTextSize(theWidth, theHeight);
|
|
|
|
int theX, theY;
|
|
theHelpTextLabel->getPos(theX, theY);
|
|
|
|
int theScreenWidth = ScreenWidth();
|
|
theHelpTextLabel->setPos(theScreenWidth/2 - theWidth/2, theY);
|
|
|
|
// Vanish if no text (but keep build/research text visible)
|
|
theHelpTextLabel->setVisible(true);
|
|
if(theBuildResearchText.length() == 0)// || ((this->mTimeLastHelpTextChanged != -1) && (this->mTimeLastHelpTextChanged + kHelpTextInterval < this->mTimeOfLastUpdate)))
|
|
{
|
|
theHelpTextLabel->setVisible(false);
|
|
}
|
|
|
|
// Display action button tool tip
|
|
string theTechHelpText = gCommanderHandler.GetTechHelpText();
|
|
if(theTechHelpText != "")
|
|
{
|
|
this->SetActionButtonHelpMessage(theTechHelpText);
|
|
}
|
|
|
|
if(theTechHelpText != this->mPreviousHelpText)
|
|
{
|
|
this->mTimeLastHelpTextChanged = this->mTimeOfLastUpdate;
|
|
}
|
|
|
|
this->mPreviousHelpText = theTechHelpText;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateTechNodes()
|
|
{
|
|
this->UpdateBuildResearchText();
|
|
|
|
// Don't get new node until existing one has been processed
|
|
if(this->mTechEvent == MESSAGE_NULL)
|
|
{
|
|
//if(this->mGameStarted)
|
|
//{
|
|
//AvHTechNode theTechNode;
|
|
//if(gCommanderHandler.GetAndClearTechNodePressed(theTechNode))
|
|
AvHMessageID theMessageID;
|
|
if(gCommanderHandler.GetAndClearTechNodePressed(theMessageID))
|
|
{
|
|
// Check for grouping and request events and handle separately
|
|
if(this->mTechNodes.GetIsMessageAvailable(theMessageID))
|
|
{
|
|
bool theIsResearchable;
|
|
int theCost;
|
|
float theTime;
|
|
|
|
if(this->mTechNodes.GetResearchInfo(theMessageID, theIsResearchable, theCost, theTime))
|
|
{
|
|
if(AvHSHUGetIsBuildTech(theMessageID))
|
|
{
|
|
// Don't check for enough points yet, they might get enough points before they put it down
|
|
|
|
// Get ready to build it, don't send a research message
|
|
this->SetGhostBuildingMode(theMessageID);
|
|
}
|
|
else if(AvHSHUGetIsResearchTech(theMessageID) && theIsResearchable)
|
|
{
|
|
// If we hit cancel, and we're in building mode, get out of build mode and throw event away
|
|
if((theMessageID == MESSAGE_CANCEL) && (this->GetGhostBuilding() != MESSAGE_NULL))
|
|
{
|
|
CancelBuilding();
|
|
}
|
|
else if(theCost <= this->mResources)
|
|
{
|
|
this->mTechEvent = theMessageID;
|
|
}
|
|
else
|
|
{
|
|
// Emit error message that you don't have the resources
|
|
this->PlayHUDSound(HUD_SOUND_MARINE_MORE);
|
|
}
|
|
}
|
|
else if(theMessageID == BUILD_RECYCLE)
|
|
{
|
|
this->mTechEvent = theMessageID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this->mTechEvent = theMessageID;
|
|
}
|
|
}
|
|
else if((theMessageID >= SAYING_1) && (theMessageID <= SAYING_9))
|
|
{
|
|
this->mTechEvent = theMessageID;
|
|
}
|
|
}
|
|
//}
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateAmbientSounds()
|
|
{
|
|
Vector theListenerPosition;
|
|
VectorCopy(gPredictedPlayerOrigin, theListenerPosition);
|
|
|
|
// Commanders have a different PAS then themselves
|
|
if(this->mInTopDownMode)
|
|
{
|
|
VectorCopy(this->mCommanderPAS, theListenerPosition);
|
|
}
|
|
|
|
for(AmbientSoundListType::iterator theIter = this->mAmbientSounds.begin(); theIter != this->mAmbientSounds.end(); theIter++)
|
|
{
|
|
theIter->StartPlayingIfNot();
|
|
theIter->UpdateVolume(theListenerPosition);
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateFromEntities(float inCurrentTime)
|
|
{
|
|
// Only update every so often for performance reasons
|
|
const float kEntityUpdateInterval = .4f;
|
|
if(inCurrentTime > (this->mTimeOfLastEntityUpdate + kEntityUpdateInterval))
|
|
{
|
|
this->mHelpIcons.clear();
|
|
this->mHelpEnts.clear();
|
|
|
|
bool theAutoHelpEnabled = gEngfuncs.pfnGetCvarFloat(kvAutoHelp);
|
|
|
|
// Clear help icons
|
|
this->mHelpEnts.clear();
|
|
|
|
// Clear building effects
|
|
//this->mBuildingEffectsEntityList.clear();
|
|
|
|
this->mTimeOfLastEntityUpdate = inCurrentTime;
|
|
|
|
// Scan for entities, adding help icons
|
|
// Only draw if enabled
|
|
const int kHelpDistance = 350;
|
|
const int kBuildDistance = 500;
|
|
const int kHealthDistance = 125;
|
|
|
|
// Look for entities that have help icons in front of us. Don't search to far away, it could give players away.
|
|
EntityListType theHelpEntities;
|
|
AvHSHUGetEntities(-1, theHelpEntities);
|
|
|
|
cl_entity_t* theLocalPlayer = gEngfuncs.GetLocalPlayer();
|
|
|
|
for(EntityListType::iterator theIter = theHelpEntities.begin(); theIter != theHelpEntities.end(); theIter++)
|
|
{
|
|
vec3_t theLocation;
|
|
if(AvHSHUGetEntityLocation(*theIter, theLocation))
|
|
{
|
|
float theDistance = VectorDistance((float*)&theLocation, theLocalPlayer->origin);
|
|
if(theDistance < kHelpDistance)
|
|
{
|
|
// If iuser3 isn't 0, try looking up an icon for it
|
|
physent_t* theEntity = gEngfuncs.pEventAPI->EV_GetPhysent(*theIter);
|
|
if(theEntity)
|
|
{
|
|
// Don't add cloaked entities (I wish this could be more general purpose)
|
|
if((theEntity->team == this->GetHUDTeam()) || (theEntity->rendermode == kRenderNormal))
|
|
{
|
|
int theUser3 = theEntity->iuser3;
|
|
vec3_t theEntityOrigin = AvHSHUGetRealLocation(theEntity->origin, theEntity->mins, theEntity->maxs);
|
|
|
|
// Some entities always draw
|
|
bool theAlwaysDraw = false;
|
|
switch(theUser3)
|
|
{
|
|
case AVH_USER3_WELD:
|
|
//case AVH_USER3_COMMANDER_STATION:
|
|
//case AVH_USER3_HIVE:
|
|
theAlwaysDraw = true;
|
|
break;
|
|
}
|
|
|
|
if(theAutoHelpEnabled || theAlwaysDraw)
|
|
{
|
|
this->mHelpIcons.push_back( make_pair(theEntityOrigin, theUser3) );
|
|
|
|
// Push back entity for displaying helpful tooltips
|
|
this->mHelpEnts.push_back(*theIter);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateViewModelEffects()
|
|
{
|
|
cl_entity_t* theViewModel = GetViewEntity();
|
|
if(theViewModel)
|
|
{
|
|
int theRenderMode = kRenderNormal;
|
|
int theRenderAmount = 0;
|
|
int theRenderFx = theViewModel->curstate.renderfx;
|
|
color24 theRenderColor = theViewModel->curstate.rendercolor;
|
|
short theSkin = 0;
|
|
|
|
// Set the skin, stored in playerclass
|
|
|
|
//cl_entity_s* theLocalPlayer = gEngfuncs.GetLocalPlayer();
|
|
|
|
// Use the visible player so that when we are spectating we can tell
|
|
// when the player is cloaked.
|
|
cl_entity_s* theLocalPlayer = GetVisiblePlayer();
|
|
|
|
if(theLocalPlayer)
|
|
{
|
|
|
|
//theViewModel->curstate.skin = theLocalPlayer->curstate.skin;
|
|
theRenderMode = theLocalPlayer->curstate.rendermode;
|
|
theRenderAmount = theLocalPlayer->curstate.renderamt;
|
|
theRenderFx = theLocalPlayer->curstate.renderfx;
|
|
theRenderColor = theLocalPlayer->curstate.rendercolor;
|
|
theSkin = theLocalPlayer->curstate.skin;
|
|
// Hack to make cloaking work for viewmodels (if only view models rendered in additive properly).
|
|
// Draw view model normally unless fully cloaked.
|
|
//bool theIsCloakedViaUpgrade = GetHasUpgrade(theLocalPlayer->curstate.iuser4, MASK_ALIEN_CLOAKED);
|
|
int old=theRenderAmount;
|
|
if((theRenderMode == kRenderTransTexture) /*|| theIsCloakedViaUpgrade*/)
|
|
{
|
|
theRenderFx = kRenderFxNone;
|
|
theRenderColor.r = theRenderColor.g = theRenderColor.b = 0;
|
|
|
|
if ( theRenderAmount == kAlienSelfCloakingBaseOpacity )
|
|
{
|
|
theRenderMode = kAlienCloakViewModelRenderMode;
|
|
theRenderAmount = 10;
|
|
}
|
|
else if( theRenderAmount > kAlienSelfCloakingBaseOpacity && theRenderAmount < 186)
|
|
{
|
|
theRenderMode = kAlienCloakViewModelRenderMode;
|
|
theRenderAmount = 40;
|
|
}
|
|
else if ( theRenderAmount == 186 ) {
|
|
theRenderMode = kAlienCloakViewModelRenderMode;
|
|
theRenderAmount = 50;
|
|
}
|
|
else
|
|
{
|
|
theRenderMode = kRenderNormal;
|
|
theRenderAmount = 255;
|
|
}
|
|
}
|
|
|
|
|
|
//char theMessage[128];
|
|
//sprintf(theMessage, "Setting view model mode: %d amount: %d\n", theRenderMode, theRenderAmount);
|
|
//CenterPrint(theMessage);
|
|
}
|
|
|
|
// if(GetHasUpgrade(this->GetLocalUpgrades(), MASK_ALIEN_CLOAKED))
|
|
// {
|
|
// theRenderMode = kAlienCloakViewModelRenderMode;
|
|
// int theCloakingLevel = AvHGetAlienUpgradeLevel(this->GetLocalUpgrades(), MASK_UPGRADE_7);
|
|
// theRenderAmount = kAlienCloakViewModelAmount - theCloakingLevel*kAlienCloakViewModelLevelAmount;
|
|
//
|
|
// // Put in color, because texture rendering needs it
|
|
// theRenderFx = kRenderFxNone;
|
|
// theRenderColor.r = theRenderColor.g = theRenderColor.b = 0;
|
|
// }
|
|
|
|
if(this->mInTopDownMode)
|
|
{
|
|
theRenderMode = kRenderTransAdd;
|
|
theRenderAmount = 1;
|
|
}
|
|
|
|
theViewModel->curstate.skin = theSkin;
|
|
theViewModel->curstate.rendermode = theRenderMode;
|
|
theViewModel->curstate.renderamt = theRenderAmount;
|
|
theViewModel->curstate.renderfx = theRenderFx;
|
|
theViewModel->curstate.rendercolor = theRenderColor;
|
|
}
|
|
}
|
|
|
|
void AvHHud::UpdateResources(float inTimePassed)
|
|
{
|
|
const float kResourceRate = this->GetMaxAlienResources()/50.0f;
|
|
int thePointsToMove = max(inTimePassed*kResourceRate, 1);
|
|
|
|
// Update visual resources if different this resources
|
|
if(this->mVisualResources != this->mResources)
|
|
{
|
|
if(abs(this->mVisualResources - this->mResources) <= thePointsToMove)
|
|
{
|
|
this->mVisualResources = this->mResources;
|
|
}
|
|
else
|
|
{
|
|
if(this->mVisualResources < this->mResources)
|
|
{
|
|
this->mVisualResources += thePointsToMove;
|
|
}
|
|
else
|
|
{
|
|
this->mVisualResources -= thePointsToMove;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Smoothly adjust energy level
|
|
float theCurrentEnergyLevel = pmove->fuser3/kNormalizationNetworkFactor;
|
|
|
|
if((g_iUser1 == OBS_IN_EYE) && (g_iUser2 != this->mUser2OfLastEnergyLevel))
|
|
{
|
|
// This isn't working yet
|
|
this->mVisualEnergyLevel = theCurrentEnergyLevel;
|
|
this->mUser2OfLastEnergyLevel = g_iUser2;
|
|
}
|
|
else
|
|
{
|
|
float kEnergyRate = 1.0f;
|
|
float theEnergyToMove = inTimePassed*kEnergyRate;
|
|
if(this->mVisualEnergyLevel != theCurrentEnergyLevel)
|
|
{
|
|
float theDiff = fabs(this->mVisualEnergyLevel - theCurrentEnergyLevel);
|
|
if(theDiff <= theEnergyToMove)
|
|
{
|
|
this->mVisualEnergyLevel = theCurrentEnergyLevel;
|
|
}
|
|
else
|
|
{
|
|
if(this->mVisualEnergyLevel < theCurrentEnergyLevel)
|
|
{
|
|
this->mVisualEnergyLevel += theEnergyToMove;
|
|
}
|
|
else
|
|
{
|
|
this->mVisualEnergyLevel -= theEnergyToMove;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
string theResourceText;
|
|
char theResourceBuffer[64];
|
|
|
|
if(this->GetInTopDownMode() && this->mCommanderResourceLabel)
|
|
{
|
|
LocalizeString(kMarineResourcePrefix, theResourceText);
|
|
sprintf(theResourceBuffer, "%s %d", theResourceText.c_str(), this->mVisualResources);
|
|
this->mCommanderResourceLabel->setText(64, theResourceBuffer);
|
|
}
|
|
|
|
// Update visual resource indicators, expiring old ones
|
|
const float kNumericalInfoEffectLifetime = 1.1f;
|
|
const float kNumericalInfoScrollSpeed = 24;
|
|
for(NumericalInfoEffectListType::iterator theIter = this->mNumericalInfoEffects.begin(); theIter != this->mNumericalInfoEffects.end(); /* no inc */)
|
|
{
|
|
if((theIter->GetTimeCreated() + kNumericalInfoEffectLifetime) < this->mTimeOfLastUpdate)
|
|
{
|
|
theIter = this->mNumericalInfoEffects.erase(theIter);
|
|
}
|
|
else
|
|
{
|
|
// Update position
|
|
float thePosition[3];
|
|
theIter->GetPosition(thePosition);
|
|
|
|
thePosition[2] += inTimePassed*kNumericalInfoScrollSpeed;
|
|
|
|
theIter->SetPosition(thePosition);
|
|
|
|
// Next
|
|
theIter++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//void AvHHud::ChangeUpgradeCosts(int inOldMessageID, int inNewMessageID, const char* inText)
|
|
//{
|
|
// this->ChangeUpgradeCostsForMenu(this->mSoldierMenu, inOldMessageID, inNewMessageID, inText);
|
|
// this->ChangeUpgradeCostsForMenu(this->mLeaderMenu, inOldMessageID, inNewMessageID, inText);
|
|
// this->ChangeUpgradeCostsForMenu(this->mCommanderMenu, inOldMessageID, inNewMessageID, inText);
|
|
//
|
|
// this->UpdateUpgradeCosts();
|
|
//}
|
|
//
|
|
//void AvHHud::ChangeUpgradeCostsForMenu(PieMenu* inMenu, int inOldMessageID, int inNewMessageID, const char* inText)
|
|
//{
|
|
// if(inMenu)
|
|
// {
|
|
// inMenu->ChangeNode(inOldMessageID, inNewMessageID, string(inText));
|
|
// }
|
|
//}
|
|
//
|
|
//void AvHHud::ResetUpgradeCosts()
|
|
//{
|
|
// this->ResetUpgradeCostsForMenu(this->mSoldierMenu);
|
|
// this->ResetUpgradeCostsForMenu(this->mLeaderMenu);
|
|
// this->ResetUpgradeCostsForMenu(this->mCommanderMenu);
|
|
//
|
|
// this->UpdateUpgradeCosts();
|
|
//}
|
|
|
|
//void AvHHud::ResetUpgradeCostsForMenu(PieMenu* inMenu)
|
|
//{
|
|
// if(inMenu)
|
|
// {
|
|
// inMenu->ResetToDefaults();
|
|
// }
|
|
//}
|
|
|
|
bool AvHHud::GetParticlesVisible() const
|
|
{
|
|
|
|
if (g_iUser1 == OBS_NONE)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (m_Spectator.IsInOverviewMode())
|
|
{
|
|
return m_Spectator.m_iDrawCycle == 1;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
// Sprite drawing on a level change is problematic and can cause crashing or disconcerting "no such sprite" error messages
|
|
bool AvHHud::GetSafeForSpriteDrawing() const
|
|
{
|
|
bool theSafeForDrawing = false;
|
|
|
|
const char* theLevelName = gEngfuncs.pfnGetLevelName();
|
|
string theCurrentMapName = this->GetMapName(true);
|
|
if(theLevelName && (theCurrentMapName != ""))
|
|
{
|
|
string theLevelNameString(theLevelName);
|
|
int thePos = (int)theLevelNameString.find(theCurrentMapName);
|
|
if(thePos != string::npos)
|
|
{
|
|
theSafeForDrawing = true;
|
|
}
|
|
}
|
|
|
|
return theSafeForDrawing;
|
|
}
|
|
|
|
bool AvHHud::GetShouldDisplayUser3(AvHUser3 inUser3) const
|
|
{
|
|
bool theShouldDisplay = false;
|
|
|
|
if((inUser3 > AVH_USER3_NONE) && (inUser3 < AVH_USER3_MAX))
|
|
{
|
|
theShouldDisplay = true;
|
|
|
|
switch(inUser3)
|
|
{
|
|
case AVH_USER3_BREAKABLE:
|
|
case AVH_USER3_USEABLE:
|
|
case AVH_USER3_PARTICLE_ON:
|
|
case AVH_USER3_PARTICLE_OFF:
|
|
case AVH_USER3_ALPHA:
|
|
case AVH_USER3_WAYPOINT:
|
|
case AVH_USER3_NOBUILD:
|
|
case AVH_USER3_SPAWN_TEAMA:
|
|
case AVH_USER3_SPAWN_TEAMB:
|
|
theShouldDisplay = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return theShouldDisplay;
|
|
}
|
|
|
|
bool AvHHud::GetTranslatedUser3Name(AvHUser3 inUser3, string& outString) const
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
if(this->GetShouldDisplayUser3(inUser3))
|
|
{
|
|
char theUser3String[512];
|
|
sprintf(theUser3String, "#%s%d", kUser3Name, inUser3);
|
|
theSuccess = LocalizeString(theUser3String, outString);
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
bool AvHHud::GetTranslatedUser3Description(AvHUser3 inUser3, bool inFriendly, string& outString) const
|
|
{
|
|
bool theSuccess = false;
|
|
|
|
if(this->GetShouldDisplayUser3(inUser3))
|
|
{
|
|
char theUser3String[512];
|
|
sprintf(theUser3String, "#%s%d", kUser3Description, inUser3);
|
|
theSuccess = LocalizeString(theUser3String, outString);
|
|
|
|
// If we're commanding, look for that description if it exists
|
|
if(this->GetInTopDownMode())
|
|
{
|
|
string theCommanderDescription;
|
|
sprintf(theUser3String, "#%s%d", kUser3CommanderDescription, inUser3);
|
|
if(LocalizeString(theUser3String, theCommanderDescription))
|
|
{
|
|
outString = theCommanderDescription;
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
// Else look for a message that tell us what to do with this thing (assumes we're not commanding though)
|
|
else if(inFriendly)
|
|
{
|
|
string theFriendlyDescription;
|
|
sprintf(theUser3String, "#%s%d", kUser3FriendlyDescription, inUser3);
|
|
if(LocalizeString(theUser3String, theFriendlyDescription))
|
|
{
|
|
outString = theFriendlyDescription;
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
|
|
void AvHHud::UpdateUpgradeCosts()
|
|
{
|
|
PieMenu* theCurrentMenu = NULL;
|
|
if(this->GetManager().GetVGUIComponentNamed(this->mPieMenuControl, theCurrentMenu))
|
|
{
|
|
this->UpdateEnableState(theCurrentMenu);
|
|
}
|
|
}
|
|
|
|
void AvHHud::AddMiniMapAlert(float x, float y)
|
|
{
|
|
mOverviewMap.AddAlert(x, y);
|
|
}
|
|
|
|
void AvHHud::UpdateEnableState(PieMenu* inMenu)
|
|
{
|
|
if(inMenu)
|
|
{
|
|
int thePurchaseLevel = this->GetIsCombatMode() ? max(0, this->mExperienceLevel - this->mExperienceLevelSpent - 1) : this->mResources;
|
|
|
|
inMenu->UpdateMenuFromTech(this->mTechNodes, thePurchaseLevel);
|
|
|
|
// if(this->GetIsNSMode())
|
|
//{
|
|
// Now disable any nodes whose children are all disabled (in NS, only end nodes can be chosen)
|
|
//inMenu->DisableNodesWhoseChildrenAreDisabled();
|
|
//}
|
|
|
|
inMenu->RecomputeVisibleSize();
|
|
}
|
|
}
|
|
|
|
void AvHHud::ShowMap()
|
|
{
|
|
if (!sShowMap && gHUD.GetIsNSMode())
|
|
{
|
|
sShowMap = true;
|
|
gHUD.HideCrosshair();
|
|
gHUD.GetManager().UnhideComponent(kShowMapHierarchy);
|
|
}
|
|
}
|
|
|
|
void AvHHud::HideMap()
|
|
{
|
|
if (sShowMap)
|
|
{
|
|
sShowMap = false;
|
|
gHUD.GetManager().HideComponent(kShowMapHierarchy);
|
|
gHUD.ShowCrosshair();
|
|
}
|
|
}
|
|
|
|
void AvHHud::GetSpriteForUser3(AvHUser3 inUser3, int& outSprite, int& outFrame, int& outRenderMode)
|
|
{
|
|
|
|
switch (inUser3)
|
|
{
|
|
|
|
// Marines
|
|
case AVH_USER3_WAYPOINT:
|
|
outSprite = Safe_SPR_Load(kSmallOrderSprite);
|
|
outFrame = 2;
|
|
outRenderMode = kRenderTransAdd;
|
|
break;
|
|
case AVH_USER3_MARINE_PLAYER:
|
|
outSprite = Safe_SPR_Load(kMarinePlayersSprite);
|
|
outFrame = 0;
|
|
break;
|
|
case AVH_USER3_HEAVY: // This really means a marine with heavy armor, not a heavy armor object.
|
|
outSprite = Safe_SPR_Load(kMarinePlayersSprite);
|
|
outFrame = 1;
|
|
break;
|
|
case AVH_USER3_COMMANDER_STATION:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 5;
|
|
break;
|
|
case AVH_USER3_TURRET_FACTORY:
|
|
case AVH_USER3_ADVANCED_TURRET_FACTORY:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 6;
|
|
break;
|
|
case AVH_USER3_ARMORY:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 7;
|
|
break;
|
|
case AVH_USER3_ADVANCED_ARMORY:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 8;
|
|
break;
|
|
case AVH_USER3_ARMSLAB:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 9;
|
|
break;
|
|
case AVH_USER3_PROTOTYPE_LAB:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 10;
|
|
break;
|
|
case AVH_USER3_OBSERVATORY:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 11;
|
|
break;
|
|
case AVH_USER3_TURRET:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 12;
|
|
break;
|
|
case AVH_USER3_SIEGETURRET:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 13;
|
|
break;
|
|
case AVH_USER3_RESTOWER:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 14;
|
|
break;
|
|
case AVH_USER3_INFANTRYPORTAL:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 15;
|
|
break;
|
|
case AVH_USER3_PHASEGATE:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 16;
|
|
break;
|
|
|
|
// Aliens
|
|
case AVH_USER3_DEFENSE_CHAMBER:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 17;
|
|
break;
|
|
case AVH_USER3_MOVEMENT_CHAMBER:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 18;
|
|
break;
|
|
case AVH_USER3_OFFENSE_CHAMBER:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 19;
|
|
break;
|
|
case AVH_USER3_SENSORY_CHAMBER:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 20;
|
|
break;
|
|
case AVH_USER3_ALIENRESTOWER:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 21;
|
|
break;
|
|
case AVH_USER3_HIVE:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 3;
|
|
break;
|
|
case AVH_USER3_ALIEN_PLAYER1:
|
|
outSprite = Safe_SPR_Load(kAlienPlayersSprite);
|
|
outFrame = 0;
|
|
break;
|
|
case AVH_USER3_ALIEN_PLAYER2:
|
|
outSprite = Safe_SPR_Load(kAlienPlayersSprite);
|
|
outFrame = 1;
|
|
break;
|
|
case AVH_USER3_ALIEN_PLAYER3:
|
|
outSprite = Safe_SPR_Load(kAlienPlayersSprite);
|
|
outFrame = 2;
|
|
break;
|
|
case AVH_USER3_ALIEN_PLAYER4:
|
|
outSprite = Safe_SPR_Load(kAlienPlayersSprite);
|
|
outFrame = 3;
|
|
break;
|
|
case AVH_USER3_ALIEN_PLAYER5:
|
|
outSprite = Safe_SPR_Load(kAlienPlayersSprite);
|
|
outFrame = 4;
|
|
break;
|
|
case AVH_USER3_ALIEN_EMBRYO :
|
|
outSprite = Safe_SPR_Load(kAlienPlayersSprite);
|
|
outFrame = 5;
|
|
break;
|
|
|
|
case AVH_USER3_FUNC_RESOURCE:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 4;
|
|
break;
|
|
case AVH_USER3_WELD:
|
|
outSprite = Safe_SPR_Load(kStructuresSprite);
|
|
outFrame = 0;
|
|
break;
|
|
|
|
default:
|
|
outSprite = 0;
|
|
outFrame = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int AvHHud::GetCurrentSquad() const
|
|
{
|
|
return mCurrentSquad;
|
|
}
|
|
|
|
AvHOverviewMap& AvHHud::GetOverviewMap()
|
|
{
|
|
return mOverviewMap;
|
|
}
|
|
|
|
void AvHHud::ShowCrosshair()
|
|
{
|
|
|
|
++mCrosshairShowCount;
|
|
|
|
if (mCrosshairShowCount > 0)
|
|
{
|
|
SetCrosshair(mCrosshairSprite, mCrosshairRect, mCrosshairR, mCrosshairG, mCrosshairB);
|
|
}
|
|
|
|
}
|
|
|
|
void AvHHud::HideCrosshair()
|
|
{
|
|
|
|
--mCrosshairShowCount;
|
|
|
|
if (mCrosshairShowCount <= 0)
|
|
{
|
|
wrect_t nullrect = { 0, 0, 0, 0 };
|
|
SetCrosshair(0, nullrect, 0, 0, 0);
|
|
}
|
|
|
|
}
|
|
|
|
void AvHHud::SetCurrentCrosshair(HSPRITE hspr, wrect_t rc, int r, int g, int b)
|
|
{
|
|
mCrosshairSprite = hspr;
|
|
mCrosshairRect = rc;
|
|
mCrosshairR = r;
|
|
mCrosshairG = g;
|
|
mCrosshairB = b;
|
|
|
|
if (mCrosshairShowCount > 0)
|
|
{
|
|
SetCrosshair(mCrosshairSprite, mCrosshairRect, mCrosshairR, mCrosshairG, mCrosshairB);
|
|
}
|
|
|
|
}
|
|
|
|
void AvHHud::SetViewport(const int inViewport[4])
|
|
{
|
|
if (!m_Spectator.IsInOverviewMode())
|
|
{
|
|
mViewport[0] = inViewport[0];
|
|
mViewport[1] = inViewport[1];
|
|
mViewport[2] = inViewport[2];
|
|
mViewport[3] = inViewport[3];
|
|
}
|
|
else
|
|
{
|
|
mSpecialViewport[0] = inViewport[0];
|
|
mSpecialViewport[1] = inViewport[1];
|
|
mSpecialViewport[2] = inViewport[2];
|
|
mSpecialViewport[3] = inViewport[3];
|
|
|
|
mViewport[0] = 0;
|
|
mViewport[1] = 0;
|
|
mViewport[2] = ScreenWidth();
|
|
mViewport[3] = ScreenHeight();
|
|
|
|
}
|
|
}
|
|
|
|
void AvHHud::GetViewport(int outViewport[4]) const
|
|
{
|
|
outViewport[0] = mViewport[0];
|
|
outViewport[1] = mViewport[1];
|
|
outViewport[2] = mViewport[2];
|
|
outViewport[3] = mViewport[3];
|
|
}
|
|
|
|
const AvHFont& AvHHud::GetSmallFont() const
|
|
{
|
|
return mSmallFont;
|
|
}
|
|
|
|
void AvHHud::PlayStream()
|
|
{
|
|
if(gEngfuncs.Cmd_Argc() <= 1)
|
|
{
|
|
gEngfuncs.Con_Printf( "usage: playstream <url>\n" );
|
|
}
|
|
else
|
|
{
|
|
if ( gEngfuncs.Cmd_Argc() >= 2 )
|
|
{
|
|
// Read URL
|
|
string theURL;
|
|
theURL = string("http://") + string(gEngfuncs.Cmd_Argv(1));
|
|
|
|
string theError;
|
|
if(!gHUD.PlayInternetStream(theURL, theError))
|
|
{
|
|
gHUD.AddTooltip(theError.c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHHud::StopStream()
|
|
{
|
|
gHUD.StopInternetStream();
|
|
}
|
|
|
|
float AvHHud::GetServerVariableFloat(const char* inName) const
|
|
{
|
|
ServerVariableMapType::const_iterator iterator;
|
|
iterator = mServerVariableMap.find(inName);
|
|
|
|
if ( iterator == mServerVariableMap.end() )
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return atof( iterator->second.c_str() );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Prints the call stack when an unhandled exception occurs.
|
|
*/
|
|
LONG WINAPI ExceptionFilter(EXCEPTION_POINTERS* pExp)
|
|
{
|
|
|
|
/*
|
|
// E-mail the exception log to the programmers.
|
|
|
|
std::stringstream buffer;
|
|
LogException(buffer, pExp);
|
|
|
|
const char* serverName = "66.111.4.62";
|
|
const char* fromAddress = "noreply@overmind.com";
|
|
|
|
const char* programmerAddress[] =
|
|
{
|
|
"max_mcguire@yahoo.com",
|
|
};
|
|
|
|
for (int i = 0; i < sizeof(programmerAddress) / sizeof(char*); ++i)
|
|
{
|
|
SendMail(serverName, fromAddress, fromAddress, programmerAddress[i],
|
|
"Exception Log", buffer.str().c_str());
|
|
}
|
|
*/
|
|
|
|
AvHHud::ResetGammaAtExit();
|
|
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
|
|
|
}
|
|
|
|
// Added DLL entry point to try to reset gamma properly under VAC
|
|
BOOL WINAPI DllMain(HINSTANCE hinstDLL,
|
|
DWORD fdwReason,
|
|
LPVOID lpvReserved)
|
|
{
|
|
if (fdwReason == DLL_PROCESS_ATTACH)
|
|
{
|
|
|
|
// Install a crash handler.
|
|
//SetUnhandledExceptionFilter(ExceptionFilter);
|
|
|
|
}
|
|
else if (fdwReason == DLL_PROCESS_DETACH)
|
|
{
|
|
AvHHud::ResetGammaAtExit();
|
|
}
|
|
return TRUE;
|
|
}
|