//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDecalEmitterSystem::LevelInitPreEntity()
{
// Precache all entries
int c = m_AllDecals.Count();
for ( int i = 0 ; i < c; i++ )
{
DecalListEntry& e = m_AllDecals[ i ];
#if defined( CLIENT_DLL )
e.precache_index = effects->Draw_DecalIndexFromName( (char *)m_DecalFileNames.String( e.name ) );
#else
e.precache_index = engine->PrecacheDecal( m_DecalFileNames.String( e.name ) );
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void AnimationController::RunCmd_SetString( PostedMessage_t &msg )
{
Panel *panel = FindSiblingByName(g_ScriptSymbols.String(msg.event));
Assert(panel != NULL);
if (!panel)
return;
KeyValues *inputData = new KeyValues(g_ScriptSymbols.String(msg.variable));
inputData->SetString(g_ScriptSymbols.String(msg.variable), g_ScriptSymbols.String(msg.variable2));
if (!panel->SetInfo(inputData))
{
// Assert(!("Unhandlable var in AnimationController::SetValue())"));
}
inputData->deleteThis();
}
char const *CBugReporter::GetSeverity( int index )
{
if ( index < 0 || index >= m_Severity.Count() )
return "<<Invalid>>";
return m_BugStrings.String( m_Severity[ index ] );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Button::OnMousePressed(MouseCode code)
{
if (!IsEnabled())
return;
if (!IsMouseClickEnabled(code))
return;
if (_activationType == ACTIVATE_ONPRESSED)
{
DoClick();
return;
}
// play activation sound
if (m_sDepressedSoundName != UTL_INVAL_SYMBOL)
{
surface()->PlaySound(g_ButtonSoundNames.String(m_sDepressedSoundName));
}
if (IsUseCaptureMouseEnabled() && _activationType == ACTIVATE_ONPRESSEDANDRELEASED)
{
{
RequestFocus();
SetSelected(true);
Repaint();
}
// lock mouse input to going to this button
input()->SetMouseCapture(GetVPanel());
}
}
char const *CBugReporter::GetReportType( int index )
{
if ( index < 0 || index >= m_ReportType.Count() )
return "<<Invalid>>";
return m_BugStrings.String( m_ReportType[ index ] );
}
void Button::PlayButtonReleasedSound()
{
// check for playing a transition sound
if ( m_sReleasedSoundName != UTL_INVAL_SYMBOL )
{
surface()->PlaySound( g_ButtonSoundNames.String( m_sReleasedSoundName ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: a posted message to stop animations of a specific type
//-----------------------------------------------------------------------------
void AnimationController::RunCmd_StopAnimation(PostedMessage_t &msg)
{
Panel *panel = FindSiblingByName(g_ScriptSymbols.String(msg.event));
Assert(panel != NULL);
if (!panel)
return;
RemoveQueuedAnimationByType(panel, msg.variable, msg.seqName);
}
void Button_Panel::OnMousePressed(vgui::MouseCode MouseCode)
{
BaseClass::OnMousePressed(MouseCode);
if (MouseCode == MOUSE_LEFT)
{
if (m_sDepressedSoundName != UTL_INVAL_SYMBOL)
vgui::surface()->PlaySound(g_ButtonSoundNames.String(m_sDepressedSoundName));
}
}
//-----------------------------------------------------------------------------
// Purpose: starts a variable animation
//-----------------------------------------------------------------------------
void AnimationController::StartCmd_Animate(UtlSymId_t seqName, AnimCmdAnimate_t &cmd, Panel *pWithinParent)
{
Assert( pWithinParent );
// make sure the child exists
Panel *panel = pWithinParent->FindChildByName(g_ScriptSymbols.String(cmd.panel),true);
if ( !panel )
{
// Check the parent
Panel *parent = GetParent();
if ( !Q_stricmp( parent->GetName(), g_ScriptSymbols.String(cmd.panel) ) )
{
panel = parent;
}
}
if (!panel)
return;
StartCmd_Animate(panel, seqName, cmd);
}
void Button_Panel::OnMouseReleased(vgui::MouseCode MouseCode)
{
BaseClass::OnMouseReleased(MouseCode);
if (MouseCode == MOUSE_LEFT)
{
if (m_sReleasedSoundName != UTL_INVAL_SYMBOL)
vgui::surface()->PlaySound(g_ButtonSoundNames.String(m_sReleasedSoundName));
GetParent()->OnCommand(CommandShared);
}
}
//-----------------------------------------------------------------------------
// Purpose: Activate a button click.
//-----------------------------------------------------------------------------
void Button::DoClick()
{
SetSelected(true);
FireActionSignal();
// check for playing a transition sound
if (m_sReleasedSoundName != UTL_INVAL_SYMBOL)
{
surface()->PlaySound(g_ButtonSoundNames.String(m_sReleasedSoundName));
}
SetSelected(false);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void AnimationController::RunCmd_SetFont( PostedMessage_t &msg )
{
Panel *parent = msg.parent.Get();
if ( !parent )
{
parent = GetParent();
}
Panel *panel = parent->FindChildByName(g_ScriptSymbols.String(msg.event), true);
Assert(panel != NULL);
if (!panel)
return;
KeyValues *inputData = new KeyValues(g_ScriptSymbols.String(msg.variable));
inputData->SetString(g_ScriptSymbols.String(msg.variable), g_ScriptSymbols.String(msg.variable2));
if (!panel->SetInfo(inputData))
{
// Assert(!("Unhandlable var in AnimationController::SetValue())"));
}
inputData->deleteThis();
}
//-----------------------------------------------------------------------------
// Purpose: Set armed state.
//-----------------------------------------------------------------------------
void Button::SetArmed(bool state)
{
if ( _buttonFlags.IsFlagSet( ARMED ) != state )
{
_buttonFlags.SetFlag( ARMED, state );
RecalculateDepressedState();
InvalidateLayout(false);
// play any sounds specified
if (state && m_sArmedSoundName != UTL_INVAL_SYMBOL)
{
surface()->PlaySound(g_ButtonSoundNames.String(m_sArmedSoundName));
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Set armed state.
//-----------------------------------------------------------------------------
void Button::SetArmed(bool state)
{
if (_armed != state)
{
_armed = state;
RecalculateDepressedState();
InvalidateLayout(false);
// play any sounds specified
if (_armed && m_sArmedSoundName != UTL_INVAL_SYMBOL)
{
surface()->PlaySound(g_ButtonSoundNames.String(m_sArmedSoundName));
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int AnimationController::GetRelativeOffset( AnimAlign_t& align, bool xcoord )
{
if ( !align.relativePosition )
return 0;
Panel *panel = GetParent()->FindChildByName(g_ScriptSymbols.String(align.alignPanel), true);
if ( !panel )
return 0;
int x, y, w, h;
panel->GetBounds( x, y, w, h );
int offset =0;
switch ( align.alignment )
{
default:
case a_northwest:
offset = xcoord ? x : y;
break;
case a_north:
offset = xcoord ? ( x + w ) / 2 : y;
break;
case a_northeast:
offset = xcoord ? ( x + w ) : y;
break;
case a_west:
offset = xcoord ? x : ( y + h ) / 2;
break;
case a_center:
offset = xcoord ? ( x + w ) / 2 : ( y + h ) / 2;
break;
case a_east:
offset = xcoord ? ( x + w ) : ( y + h ) / 2;
break;
case a_southwest:
offset = xcoord ? x : ( y + h );
break;
case a_south:
offset = xcoord ? ( x + w ) / 2 : ( y + h );
break;
case a_southeast:
offset = xcoord ? ( x + w ) : ( y + h );
break;
}
return offset;
}
//-----------------------------------------------------------------------------
// Purpose: a posted message to stop all animations relevant to a specified panel
//-----------------------------------------------------------------------------
void AnimationController::RunCmd_StopPanelAnimations(PostedMessage_t &msg)
{
Panel *panel = FindSiblingByName(g_ScriptSymbols.String(msg.event));
Assert(panel != NULL);
if (!panel)
return;
// loop through all the active animations cancelling any that
// are operating on said panel, except for the event specified
for (int i = 0; i < m_ActiveAnimations.Count(); i++)
{
if (m_ActiveAnimations[i].panel == panel && m_ActiveAnimations[i].seqName != msg.seqName)
{
m_ActiveAnimations.Remove(i);
--i;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: reloads the currently set script file
//-----------------------------------------------------------------------------
void AnimationController::ReloadScriptFile()
{
// Clear all current sequences
m_Sequences.RemoveAll();
UpdateScreenSize();
// Reload each file we've loaded
for ( int i = 0; i < m_ScriptFileNames.Count(); i++ )
{
const char *lpszFilename = g_ScriptSymbols.String( m_ScriptFileNames[i] );
if ( strlen( lpszFilename ) > 0)
{
if ( LoadScriptFile( lpszFilename ) == false )
{
Assert( 0 );
}
}
}
}
const char *GetOriginalMaterialNameForPatchedMaterial( const char *pPatchMaterialName )
{
const char *pRetName = NULL;
int id;
NameTranslationLookup_t lookup;
lookup.m_PatchFileName = s_SymbolTable.AddString( pPatchMaterialName );
do
{
id = s_MapPatchedMatToOriginalMat.Find( lookup );
if( id >= 0 )
{
NameTranslationLookup_t &found = s_MapPatchedMatToOriginalMat[id];
lookup.m_PatchFileName = found.m_OriginalFileName;
pRetName = s_SymbolTable.String( found.m_OriginalFileName );
}
} while( id >= 0 );
if( !pRetName )
{
// This isn't a patched material, so just return the original name.
return pPatchMaterialName;
}
return pRetName;
}
//-----------------------------------------------------------------------------
// Purpose: Gets the specified value from a panel
//-----------------------------------------------------------------------------
AnimationController::Value_t AnimationController::GetValue(ActiveAnimation_t& anim, Panel *panel, UtlSymId_t var)
{
Value_t val = { 0, 0, 0, 0 };
if (var == m_sPosition)
{
int x, y;
panel->GetPos(x, y);
val.a = (float)(x - GetRelativeOffset( anim.align, true ) );
val.b = (float)(y - GetRelativeOffset( anim.align, false ) );
}
else if (var == m_sSize)
{
int w, t;
panel->GetSize(w, t);
val.a = (float)w;
val.b = (float)t;
}
else if (var == m_sFgColor)
{
Color col = panel->GetFgColor();
val.a = col[0];
val.b = col[1];
val.c = col[2];
val.d = col[3];
}
else if (var == m_sBgColor)
{
Color col = panel->GetBgColor();
val.a = col[0];
val.b = col[1];
val.c = col[2];
val.d = col[3];
}
else if ( var == m_sXPos )
{
int x, y;
panel->GetPos(x, y);
val.a = (float)( x - GetRelativeOffset( anim.align, true ) );
}
else if ( var == m_sYPos )
{
int x, y;
panel->GetPos(x, y);
val.a = (float)( y - GetRelativeOffset( anim.align, false ) );
}
else if ( var == m_sWide )
{
int w, h;
panel->GetSize(w, h);
val.a = (float)w;
}
else if ( var == m_sTall )
{
int w, h;
panel->GetSize(w, h);
val.a = (float)h;
}
else
{
KeyValues *outputData = new KeyValues(g_ScriptSymbols.String(var));
if (panel->RequestInfo(outputData))
{
// find the var and lookup it's type
KeyValues *kv = outputData->FindKey(g_ScriptSymbols.String(var));
if (kv && kv->GetDataType() == KeyValues::TYPE_FLOAT)
{
val.a = kv->GetFloat();
val.b = 0.0f;
val.c = 0.0f;
val.d = 0.0f;
}
else if (kv && kv->GetDataType() == KeyValues::TYPE_COLOR)
{
Color col = kv->GetColor();
val.a = col[0];
val.b = col[1];
val.c = col[2];
val.d = col[3];
}
}
else
{
// Assert(!("Unhandlable var in AnimationController::GetValue())"));
}
outputData->deleteThis();
}
return val;
}
//-----------------------------------------------------------------------------
// Purpose: a posted message to run another event
//-----------------------------------------------------------------------------
void AnimationController::RunCmd_RunEvent(PostedMessage_t &msg)
{
StartAnimationSequence(msg.parent.Get(), g_ScriptSymbols.String(msg.event));
}
//-----------------------------------------------------------------------------
// Purpose: Sets a value in a panel
//-----------------------------------------------------------------------------
void AnimationController::SetValue(ActiveAnimation_t& anim, Panel *panel, UtlSymId_t var, Value_t &value)
{
if (var == m_sPosition)
{
int x = (int)value.a + GetRelativeOffset( anim.align, true );
int y = (int)value.b + GetRelativeOffset( anim.align, false );
panel->SetPos(x, y);
}
else if (var == m_sSize)
{
panel->SetSize((int)value.a, (int)value.b);
}
else if (var == m_sFgColor)
{
Color col = panel->GetFgColor();
col[0] = (unsigned char)value.a;
col[1] = (unsigned char)value.b;
col[2] = (unsigned char)value.c;
col[3] = (unsigned char)value.d;
panel->SetFgColor(col);
}
else if (var == m_sBgColor)
{
Color col = panel->GetBgColor();
col[0] = (unsigned char)value.a;
col[1] = (unsigned char)value.b;
col[2] = (unsigned char)value.c;
col[3] = (unsigned char)value.d;
panel->SetBgColor(col);
}
else if (var == m_sXPos)
{
int newx = (int)value.a + GetRelativeOffset( anim.align, true );
int x, y;
panel->GetPos( x, y );
x = newx;
panel->SetPos(x, y);
}
else if (var == m_sYPos)
{
int newy = (int)value.a + GetRelativeOffset( anim.align, false );
int x, y;
panel->GetPos( x, y );
y = newy;
panel->SetPos(x, y);
}
else if (var == m_sWide)
{
int neww = (int)value.a;
int w, h;
panel->GetSize( w, h );
w = neww;
panel->SetSize(w, h);
}
else if (var == m_sTall)
{
int newh = (int)value.a;
int w, h;
panel->GetSize( w, h );
h = newh;
panel->SetSize(w, h);
}
else
{
KeyValues *inputData = new KeyValues(g_ScriptSymbols.String(var));
// set the custom value
if (value.b == 0.0f && value.c == 0.0f && value.d == 0.0f)
{
// only the first value is non-zero, so probably just a float value
inputData->SetFloat(g_ScriptSymbols.String(var), value.a);
}
else
{
// multivalue, set the color
Color col((unsigned char)value.a, (unsigned char)value.b, (unsigned char)value.c, (unsigned char)value.d);
inputData->SetColor(g_ScriptSymbols.String(var), col);
}
if (!panel->SetInfo(inputData))
{
// Assert(!("Unhandlable var in AnimationController::SetValue())"));
}
inputData->deleteThis();
}
}
//-----------------------------------------------------------------------------
// Purpose: parses a script into sequences
//-----------------------------------------------------------------------------
bool AnimationController::ParseScriptFile(char *pMem, int length)
{
// get the scheme (for looking up color names)
IScheme *scheme = vgui::scheme()->GetIScheme(GetScheme());
// get our screen size (for left/right/center alignment)
int screenWide = m_nScreenBounds[ 2 ];
int screenTall = m_nScreenBounds[ 3 ];
// start by getting the first token
char token[512];
pMem = ParseFile(pMem, token, NULL);
while (token[0])
{
bool bAccepted = true;
// should be 'event'
if (stricmp(token, "event"))
{
Warning("Couldn't parse script file: expected 'event', found '%s'\n", token);
return false;
}
// get the event name
pMem = ParseFile(pMem, token, NULL);
if (strlen(token) < 1)
{
Warning("Couldn't parse script file: expected <event name>, found nothing\n");
return false;
}
int seqIndex;
UtlSymId_t nameIndex = g_ScriptSymbols.AddString(token);
// Create a new sequence
seqIndex = m_Sequences.AddToTail();
AnimSequence_t &seq = m_Sequences[seqIndex];
seq.name = nameIndex;
seq.duration = 0.0f;
// get the open brace or a conditional
pMem = ParseFile(pMem, token, NULL);
if ( Q_stristr( token, "[$" ) )
{
bAccepted = EvaluateConditional( token );
// now get the open brace
pMem = ParseFile(pMem, token, NULL);
}
if (stricmp(token, "{"))
{
Warning("Couldn't parse script sequence '%s': expected '{', found '%s'\n", g_ScriptSymbols.String(seq.name), token);
return false;
}
// walk the commands
while (token && token[0])
{
// get the command type
pMem = ParseFile(pMem, token, NULL);
// skip out when we hit the end of the sequence
if (token[0] == '}')
break;
// create a new command
int cmdIndex = seq.cmdList.AddToTail();
AnimCommand_t &animCmd = seq.cmdList[cmdIndex];
memset(&animCmd, 0, sizeof(animCmd));
if (!stricmp(token, "animate"))
{
animCmd.commandType = CMD_ANIMATE;
// parse out the animation commands
AnimCmdAnimate_t &cmdAnimate = animCmd.cmdData.animate;
// panel to manipulate
pMem = ParseFile(pMem, token, NULL);
cmdAnimate.panel = g_ScriptSymbols.AddString(token);
// variable to change
pMem = ParseFile(pMem, token, NULL);
cmdAnimate.variable = g_ScriptSymbols.AddString(token);
// target value
pMem = ParseFile(pMem, token, NULL);
if (cmdAnimate.variable == m_sPosition)
{
// Get first token
SetupPosition( cmdAnimate, &cmdAnimate.target.a, token, screenWide );
// Get second token from "token"
char token2[32];
char *psz = ParseFile(token, token2, NULL);
psz = ParseFile(psz, token2, NULL);
psz = token2;
// Position Y goes into ".b"
SetupPosition( cmdAnimate, &cmdAnimate.target.b, psz, screenTall );
}
else if ( cmdAnimate.variable == m_sXPos )
{
// XPos and YPos both use target ".a"
SetupPosition( cmdAnimate, &cmdAnimate.target.a, token, screenWide );
}
else if ( cmdAnimate.variable == m_sYPos )
{
// XPos and YPos both use target ".a"
SetupPosition( cmdAnimate, &cmdAnimate.target.a, token, screenTall );
}
else
{
// parse the floating point values right out
if (0 == sscanf(token, "%f %f %f %f", &cmdAnimate.target.a, &cmdAnimate.target.b, &cmdAnimate.target.c, &cmdAnimate.target.d))
{
// could be referencing a value in the scheme file, lookup
Color col = scheme->GetColor(token, Color(0, 0, 0, 0));
cmdAnimate.target.a = col[0];
cmdAnimate.target.b = col[1];
cmdAnimate.target.c = col[2];
cmdAnimate.target.d = col[3];
}
}
// fix up scale
if (cmdAnimate.variable == m_sSize)
{
if (IsProportional())
{
cmdAnimate.target.a = static_cast<float>( vgui::scheme()->GetProportionalScaledValueEx(GetScheme(), cmdAnimate.target.a) );
cmdAnimate.target.b = static_cast<float>( vgui::scheme()->GetProportionalScaledValueEx(GetScheme(), cmdAnimate.target.b) );
}
}
else if (cmdAnimate.variable == m_sWide ||
cmdAnimate.variable == m_sTall )
{
if (IsProportional())
{
// Wide and tall both use.a
cmdAnimate.target.a = static_cast<float>( vgui::scheme()->GetProportionalScaledValueEx(GetScheme(), cmdAnimate.target.a) );
}
}
// interpolation function
pMem = ParseFile(pMem, token, NULL);
if (!stricmp(token, "Accel"))
{
cmdAnimate.interpolationFunction = INTERPOLATOR_ACCEL;
}
else if (!stricmp(token, "Deaccel"))
{
cmdAnimate.interpolationFunction = INTERPOLATOR_DEACCEL;
}
else if ( !stricmp(token, "Spline"))
{
cmdAnimate.interpolationFunction = INTERPOLATOR_SIMPLESPLINE;
}
else if (!stricmp(token,"Pulse"))
{
cmdAnimate.interpolationFunction = INTERPOLATOR_PULSE;
// frequencey
pMem = ParseFile(pMem, token, NULL);
cmdAnimate.interpolationParameter = (float)atof(token);
}
else if ( !stricmp( token, "Flicker"))
{
cmdAnimate.interpolationFunction = INTERPOLATOR_FLICKER;
// noiseamount
pMem = ParseFile(pMem, token, NULL);
cmdAnimate.interpolationParameter = (float)atof(token);
}
else
{
cmdAnimate.interpolationFunction = INTERPOLATOR_LINEAR;
}
// start time
pMem = ParseFile(pMem, token, NULL);
cmdAnimate.startTime = (float)atof(token);
// duration
pMem = ParseFile(pMem, token, NULL);
cmdAnimate.duration = (float)atof(token);
// check max duration
if (cmdAnimate.startTime + cmdAnimate.duration > seq.duration)
{
seq.duration = cmdAnimate.startTime + cmdAnimate.duration;
}
}
else if (!stricmp(token, "runevent"))
{
animCmd.commandType = CMD_RUNEVENT;
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.event = g_ScriptSymbols.AddString(token);
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.timeDelay = (float)atof(token);
}
else if (!stricmp(token, "stopevent"))
{
animCmd.commandType = CMD_STOPEVENT;
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.event = g_ScriptSymbols.AddString(token);
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.timeDelay = (float)atof(token);
}
else if (!stricmp(token, "StopPanelAnimations"))
{
animCmd.commandType = CMD_STOPPANELANIMATIONS;
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.event = g_ScriptSymbols.AddString(token);
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.timeDelay = (float)atof(token);
}
else if (!stricmp(token, "stopanimation"))
{
animCmd.commandType = CMD_STOPANIMATION;
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.event = g_ScriptSymbols.AddString(token);
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.variable = g_ScriptSymbols.AddString(token);
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.timeDelay = (float)atof(token);
}
else if ( !stricmp( token, "SetFont" ))
{
animCmd.commandType = CMD_SETFONT;
// Panel name
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.event = g_ScriptSymbols.AddString(token);
// Font parameter
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.variable = g_ScriptSymbols.AddString(token);
// Font name from scheme
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.variable2 = g_ScriptSymbols.AddString(token);
// Set time
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.timeDelay = (float)atof(token);
}
else if ( !stricmp( token, "SetTexture" ))
{
animCmd.commandType = CMD_SETTEXTURE;
// Panel name
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.event = g_ScriptSymbols.AddString(token);
// Texture Id
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.variable = g_ScriptSymbols.AddString(token);
// material name
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.variable2 = g_ScriptSymbols.AddString(token);
// Set time
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.timeDelay = (float)atof(token);
}
else if ( !stricmp( token, "SetString" ))
{
animCmd.commandType = CMD_SETSTRING;
// Panel name
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.event = g_ScriptSymbols.AddString(token);
// String variable name
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.variable = g_ScriptSymbols.AddString(token);
// String value to set
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.variable2 = g_ScriptSymbols.AddString(token);
// Set time
pMem = ParseFile(pMem, token, NULL);
animCmd.cmdData.runEvent.timeDelay = (float)atof(token);
}
else
{
Warning("Couldn't parse script sequence '%s': expected <anim command>, found '%s'\n", g_ScriptSymbols.String(seq.name), token);
return false;
}
// Look ahead one token for a conditional
char *peek = ParseFile(pMem, token, NULL);
if ( Q_stristr( token, "[$" ) )
{
if ( !EvaluateConditional( token ) )
{
seq.cmdList.Remove( cmdIndex );
}
pMem = peek;
}
}
if ( bAccepted )
{
// Attempt to find a collision in the sequences, replacing the old one if found
int seqIterator;
for ( seqIterator = 0; seqIterator < m_Sequences.Count()-1; seqIterator++ )
{
if ( m_Sequences[seqIterator].name == nameIndex )
{
// Get rid of it, we're overriding it
m_Sequences.Remove( seqIndex );
break;
}
}
}
else
{
// Dump the entire sequence
m_Sequences.Remove( seqIndex );
}
// get the next token, if any
pMem = ParseFile(pMem, token, NULL);
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: symbol table access
//-----------------------------------------------------------------------------
const char *CKeyValuesSystem::GetStringForSymbol(HKeySymbol symbol)
{
return m_SymbolTable.String(symbol);
}
char const *CMod::GetGameDir( void )
{
assert( gamedir != UTL_INVAL_SYMBOL );
return g_GameDirTable.String( gamedir );
}