Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

3404 lines
78 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "SoundEmitterSystem/isoundemittersystembase.h"
#include "AI_ResponseSystem.h"
#include "igamesystem.h"
#include "AI_Criteria.h"
#include <KeyValues.h>
#include "filesystem.h"
#include "utldict.h"
#include "ai_speech.h"
#include "tier0/icommandline.h"
#include <ctype.h>
#include "sceneentity.h"
#include "isaverestore.h"
#include "utlbuffer.h"
#include "stringpool.h"
#include "fmtstr.h"
#include "multiplay_gamerules.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
ConVar rr_debugresponses( "rr_debugresponses", "0", FCVAR_NONE, "Show verbose matching output (1 for simple, 2 for rule scoring). If set to 3, it will only show response success/failure for npc_selected NPCs." );
ConVar rr_debugrule( "rr_debugrule", "", FCVAR_NONE, "If set to the name of the rule, that rule's score will be shown whenever a concept is passed into the response rules system.");
ConVar rr_dumpresponses( "rr_dumpresponses", "0", FCVAR_NONE, "Dump all response_rules.txt and rules (requires restart)" );
static CUtlSymbolTable g_RS;
inline static char *CopyString( const char *in )
{
if ( !in )
return NULL;
int len = Q_strlen( in );
char *out = new char[ len + 1 ];
Q_memcpy( out, in, len );
out[ len ] = 0;
return out;
}
#pragma pack(1)
class Matcher
{
public:
Matcher()
{
valid = false;
isnumeric = false;
notequal = false;
usemin = false;
minequals = false;
usemax = false;
maxequals = false;
maxval = 0.0f;
minval = 0.0f;
token = UTL_INVAL_SYMBOL;
rawtoken = UTL_INVAL_SYMBOL;
}
void Describe( void )
{
if ( !valid )
{
DevMsg( " invalid!\n" );
return;
}
char sz[ 128 ];
sz[ 0] = 0;
int minmaxcount = 0;
if ( usemin )
{
Q_snprintf( sz, sizeof( sz ), ">%s%.3f", minequals ? "=" : "", minval );
minmaxcount++;
}
if ( usemax )
{
char sz2[ 128 ];
Q_snprintf( sz2, sizeof( sz2 ), "<%s%.3f", maxequals ? "=" : "", maxval );
if ( minmaxcount > 0 )
{
Q_strncat( sz, " and ", sizeof( sz ), COPY_ALL_CHARACTERS );
}
Q_strncat( sz, sz2, sizeof( sz ), COPY_ALL_CHARACTERS );
minmaxcount++;
}
if ( minmaxcount >= 1 )
{
DevMsg( " matcher: %s\n", sz );
return;
}
if ( notequal )
{
DevMsg( " matcher: !=%s\n", GetToken() );
return;
}
DevMsg( " matcher: ==%s\n", GetToken() );
}
float maxval;
float minval;
bool valid : 1; //1
bool isnumeric : 1; //2
bool notequal : 1; //3
bool usemin : 1; //4
bool minequals : 1; //5
bool usemax : 1; //6
bool maxequals : 1; //7
void SetToken( char const *s )
{
token = g_RS.AddString( s );
}
char const *GetToken()
{
if ( token.IsValid() )
{
return g_RS.String( token );
}
return "";
}
void SetRaw( char const *raw )
{
rawtoken = g_RS.AddString( raw );
}
char const *GetRaw()
{
if ( rawtoken.IsValid() )
{
return g_RS.String( rawtoken );
}
return "";
}
private:
CUtlSymbol token;
CUtlSymbol rawtoken;
};
struct Response
{
DECLARE_SIMPLE_DATADESC();
Response()
{
type = RESPONSE_NONE;
value = NULL;
weight.SetFloat( 1.0f );
depletioncount = 0;
first = false;
last = false;
}
Response( const Response& src )
{
weight = src.weight;
type = src.type;
value = CopyString( src.value );
depletioncount = src.depletioncount;
first = src.first;
last = src.last;
}
Response& operator =( const Response& src )
{
if ( this == &src )
return *this;
weight = src.weight;
type = src.type;
value = CopyString( src.value );
depletioncount = src.depletioncount;
first = src.first;
last = src.last;
return *this;
}
~Response()
{
delete[] value;
}
ResponseType_t GetType() { return (ResponseType_t)type; }
char *value; // fixed up value spot // 4
float16 weight; // 6
byte depletioncount; // 7
byte type : 6; // 8
byte first : 1; //
byte last : 1; //
};
struct ResponseGroup
{
DECLARE_SIMPLE_DATADESC();
ResponseGroup()
{
// By default visit all nodes before repeating
m_bSequential = false;
m_bNoRepeat = false;
m_bEnabled = true;
m_nCurrentIndex = 0;
m_bDepleteBeforeRepeat = true;
m_nDepletionCount = 1;
m_bHasFirst = false;
m_bHasLast = false;
}
ResponseGroup( const ResponseGroup& src )
{
int c = src.group.Count();
for ( int i = 0; i < c; i++ )
{
group.AddToTail( src.group[ i ] );
}
rp = src.rp;
m_bDepleteBeforeRepeat = src.m_bDepleteBeforeRepeat;
m_nDepletionCount = src.m_nDepletionCount;
m_bHasFirst = src.m_bHasFirst;
m_bHasLast = src.m_bHasLast;
m_bSequential = src.m_bSequential;
m_bNoRepeat = src.m_bNoRepeat;
m_bEnabled = src.m_bEnabled;
m_nCurrentIndex = src.m_nCurrentIndex;
}
ResponseGroup& operator=( const ResponseGroup& src )
{
if ( this == &src )
return *this;
int c = src.group.Count();
for ( int i = 0; i < c; i++ )
{
group.AddToTail( src.group[ i ] );
}
rp = src.rp;
m_bDepleteBeforeRepeat = src.m_bDepleteBeforeRepeat;
m_nDepletionCount = src.m_nDepletionCount;
m_bHasFirst = src.m_bHasFirst;
m_bHasLast = src.m_bHasLast;
m_bSequential = src.m_bSequential;
m_bNoRepeat = src.m_bNoRepeat;
m_bEnabled = src.m_bEnabled;
m_nCurrentIndex = src.m_nCurrentIndex;
return *this;
}
bool HasUndepletedChoices() const
{
if ( !m_bDepleteBeforeRepeat )
return true;
int c = group.Count();
for ( int i = 0; i < c; i++ )
{
if ( group[ i ].depletioncount != m_nDepletionCount )
return true;
}
return false;
}
void MarkResponseUsed( int idx )
{
if ( !m_bDepleteBeforeRepeat )
return;
if ( idx < 0 || idx >= group.Count() )
{
Assert( 0 );
return;
}
group[ idx ].depletioncount = m_nDepletionCount;
}
void ResetDepletionCount()
{
if ( !m_bDepleteBeforeRepeat )
return;
++m_nDepletionCount;
}
void Reset()
{
ResetDepletionCount();
SetEnabled( true );
SetCurrentIndex( 0 );
m_nDepletionCount = 1;
for ( int i = 0; i < group.Count(); ++i )
{
group[ i ].depletioncount = 0;
}
}
bool HasUndepletedFirst( int& index )
{
index = -1;
if ( !m_bDepleteBeforeRepeat )
return false;
int c = group.Count();
for ( int i = 0; i < c; i++ )
{
Response *r = &group[ i ];
if ( ( r->depletioncount != m_nDepletionCount ) && r->first )
{
index = i;
return true;
}
}
return false;
}
bool HasUndepletedLast( int& index )
{
index = -1;
if ( !m_bDepleteBeforeRepeat )
return false;
int c = group.Count();
for ( int i = 0; i < c; i++ )
{
Response *r = &group[ i ];
if ( ( r->depletioncount != m_nDepletionCount ) && r->last )
{
index = i;
return true;
}
}
return false;
}
bool ShouldCheckRepeats() const { return m_bDepleteBeforeRepeat; }
int GetDepletionCount() const { return m_nDepletionCount; }
bool IsSequential() const { return m_bSequential; }
void SetSequential( bool seq ) { m_bSequential = seq; }
bool IsNoRepeat() const { return m_bNoRepeat; }
void SetNoRepeat( bool norepeat ) { m_bNoRepeat = norepeat; }
bool IsEnabled() const { return m_bEnabled; }
void SetEnabled( bool enabled ) { m_bEnabled = enabled; }
int GetCurrentIndex() const { return m_nCurrentIndex; }
void SetCurrentIndex( byte idx ) { m_nCurrentIndex = idx; }
CUtlVector< Response > group;
AI_ResponseParams rp;
bool m_bEnabled;
byte m_nCurrentIndex;
// Invalidation counter
byte m_nDepletionCount;
// Use all slots before repeating any
bool m_bDepleteBeforeRepeat : 1;
bool m_bHasFirst : 1;
bool m_bHasLast : 1;
bool m_bSequential : 1;
bool m_bNoRepeat : 1;
};
struct Criteria
{
Criteria()
{
name = NULL;
value = NULL;
weight.SetFloat( 1.0f );
required = false;
}
Criteria& operator =(const Criteria& src )
{
if ( this == &src )
return *this;
name = CopyString( src.name );
value = CopyString( src.value );
weight = src.weight;
required = src.required;
matcher = src.matcher;
int c = src.subcriteria.Count();
for ( int i = 0; i < c; i++ )
{
subcriteria.AddToTail( src.subcriteria[ i ] );
}
return *this;
}
Criteria(const Criteria& src )
{
name = CopyString( src.name );
value = CopyString( src.value );
weight = src.weight;
required = src.required;
matcher = src.matcher;
int c = src.subcriteria.Count();
for ( int i = 0; i < c; i++ )
{
subcriteria.AddToTail( src.subcriteria[ i ] );
}
}
~Criteria()
{
delete[] name;
delete[] value;
}
bool IsSubCriteriaType() const
{
return ( subcriteria.Count() > 0 ) ? true : false;
}
char *name;
char *value;
float16 weight;
bool required;
Matcher matcher;
// Indices into sub criteria
CUtlVector< unsigned short > subcriteria;
};
struct Rule
{
Rule()
{
m_bMatchOnce = false;
m_bEnabled = true;
m_szContext = NULL;
m_bApplyContextToWorld = false;
}
Rule& operator =( const Rule& src )
{
if ( this == &src )
return *this;
int i;
int c;
c = src.m_Criteria.Count();
for ( i = 0; i < c; i++ )
{
m_Criteria.AddToTail( src.m_Criteria[ i ] );
}
c = src.m_Responses.Count();
for ( i = 0; i < c; i++ )
{
m_Responses.AddToTail( src.m_Responses[ i ] );
}
SetContext( src.m_szContext );
m_bMatchOnce = src.m_bMatchOnce;
m_bEnabled = src.m_bEnabled;
m_bApplyContextToWorld = src.m_bApplyContextToWorld;
return *this;
}
Rule( const Rule& src )
{
int i;
int c;
c = src.m_Criteria.Count();
for ( i = 0; i < c; i++ )
{
m_Criteria.AddToTail( src.m_Criteria[ i ] );
}
c = src.m_Responses.Count();
for ( i = 0; i < c; i++ )
{
m_Responses.AddToTail( src.m_Responses[ i ] );
}
SetContext( src.m_szContext );
m_bMatchOnce = src.m_bMatchOnce;
m_bEnabled = src.m_bEnabled;
m_bApplyContextToWorld = src.m_bApplyContextToWorld;
}
~Rule()
{
delete[] m_szContext;
}
void SetContext( const char *context )
{
delete[] m_szContext;
m_szContext = CopyString( context );
}
const char *GetContext( void ) const { return m_szContext; }
bool IsEnabled() const { return m_bEnabled; }
void Disable() { m_bEnabled = false; }
bool IsMatchOnce() const { return m_bMatchOnce; }
bool IsApplyContextToWorld() const { return m_bApplyContextToWorld; }
// Indices into underlying criteria and response dictionaries
CUtlVector< unsigned short > m_Criteria;
CUtlVector< unsigned short> m_Responses;
char *m_szContext;
bool m_bApplyContextToWorld : 1;
bool m_bMatchOnce : 1;
bool m_bEnabled : 1;
};
#pragma pack()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
abstract_class CResponseSystem : public IResponseSystem
{
public:
CResponseSystem();
~CResponseSystem();
// IResponseSystem
virtual bool FindBestResponse( const AI_CriteriaSet& set, AI_Response& response, IResponseFilter *pFilter = NULL );
virtual void GetAllResponses( CUtlVector<AI_Response *> *pResponses );
virtual void Release() = 0;
virtual void DumpRules();
virtual void Precache();
virtual void PrecacheResponses( bool bEnable )
{
m_bPrecache = bEnable;
}
bool ShouldPrecache() { return m_bPrecache; }
bool IsCustomManagable() { return m_bCustomManagable; }
void Clear();
void DumpDictionary( const char *pszName );
protected:
virtual const char *GetScriptFile( void ) = 0;
void LoadRuleSet( const char *setname );
void ResetResponseGroups();
float LookForCriteria( const AI_CriteriaSet &criteriaSet, int iCriteria );
float RecursiveLookForCriteria( const AI_CriteriaSet &criteriaSet, Criteria *pParent );
public:
void CopyRuleFrom( Rule *pSrcRule, int iRule, CResponseSystem *pCustomSystem );
void CopyCriteriaFrom( Rule *pSrcRule, Rule *pDstRule, CResponseSystem *pCustomSystem );
void CopyResponsesFrom( Rule *pSrcRule, Rule *pDstRule, CResponseSystem *pCustomSystem );
void CopyEnumerationsFrom( CResponseSystem *pCustomSystem );
//private:
struct Enumeration
{
float value;
};
struct ResponseSearchResult
{
ResponseSearchResult()
{
group = NULL;
action = NULL;
}
ResponseGroup *group;
Response *action;
};
inline bool ParseToken( void )
{
if ( m_bUnget )
{
m_bUnget = false;
return true;
}
if ( m_ScriptStack.Count() <= 0 )
{
Assert( 0 );
return false;
}
m_ScriptStack[ 0 ].currenttoken = engine->ParseFile( m_ScriptStack[ 0 ].currenttoken, token, sizeof( token ) );
m_ScriptStack[ 0 ].tokencount++;
return m_ScriptStack[ 0 ].currenttoken != NULL ? true : false;
}
inline void Unget()
{
m_bUnget = true;
}
inline bool TokenWaiting( void )
{
if ( m_ScriptStack.Count() <= 0 )
{
Assert( 0 );
return false;
}
const char *p = m_ScriptStack[ 0 ].currenttoken;
if ( !p )
{
Error( "AI_ResponseSystem: Unxpected TokenWaiting() with NULL buffer in %p", m_ScriptStack[ 0 ].name );
return false;
}
while ( *p && *p!='\n')
{
// Special handler for // comment blocks
if ( *p == '/' && *(p+1) == '/' )
return false;
if ( !isspace( *p ) || isalnum( *p ) )
return true;
p++;
}
return false;
}
void ParseOneResponse( const char *responseGroupName, ResponseGroup& group );
void ParseInclude( CStringPool &includedFiles );
void ParseResponse( void );
void ParseCriterion( void );
void ParseRule( void );
void ParseEnumeration( void );
int ParseOneCriterion( const char *criterionName );
bool Compare( const char *setValue, Criteria *c, bool verbose = false );
bool CompareUsingMatcher( const char *setValue, Matcher& m, bool verbose = false );
void ComputeMatcher( Criteria *c, Matcher& matcher );
void ResolveToken( Matcher& matcher, char *token, size_t bufsize, char const *rawtoken );
float LookupEnumeration( const char *name, bool& found );
int FindBestMatchingRule( const AI_CriteriaSet& set, bool verbose );
float ScoreCriteriaAgainstRule( const AI_CriteriaSet& set, int irule, bool verbose = false );
float RecursiveScoreSubcriteriaAgainstRule( const AI_CriteriaSet& set, Criteria *parent, bool& exclude, bool verbose /*=false*/ );
float ScoreCriteriaAgainstRuleCriteria( const AI_CriteriaSet& set, int icriterion, bool& exclude, bool verbose = false );
bool GetBestResponse( ResponseSearchResult& result, Rule *rule, bool verbose = false, IResponseFilter *pFilter = NULL );
bool ResolveResponse( ResponseSearchResult& result, int depth, const char *name, bool verbose = false, IResponseFilter *pFilter = NULL );
int SelectWeightedResponseFromResponseGroup( ResponseGroup *g, IResponseFilter *pFilter );
void DescribeResponseGroup( ResponseGroup *group, int selected, int depth );
void DebugPrint( int depth, const char *fmt, ... );
void LoadFromBuffer( const char *scriptfile, const char *buffer, CStringPool &includedFiles );
void GetCurrentScript( char *buf, size_t buflen );
int GetCurrentToken() const;
void SetCurrentScript( const char *script );
bool IsRootCommand();
void PushScript( const char *scriptfile, unsigned char *buffer );
void PopScript(void);
void ResponseWarning( const char *fmt, ... );
CUtlDict< ResponseGroup, short > m_Responses;
CUtlDict< Criteria, short > m_Criteria;
CUtlDict< Rule, short > m_Rules;
CUtlDict< Enumeration, short > m_Enumerations;
char token[ 1204 ];
bool m_bUnget;
bool m_bPrecache;
bool m_bCustomManagable;
struct ScriptEntry
{
unsigned char *buffer;
FileNameHandle_t name;
const char *currenttoken;
int tokencount;
};
CUtlVector< ScriptEntry > m_ScriptStack;
friend class CDefaultResponseSystemSaveRestoreBlockHandler;
friend class CResponseSystemSaveRestoreOps;
};
BEGIN_SIMPLE_DATADESC( Response )
// DEFINE_FIELD( type, FIELD_INTEGER ),
// DEFINE_ARRAY( value, FIELD_CHARACTER ),
// DEFINE_FIELD( weight, FIELD_FLOAT ),
DEFINE_FIELD( depletioncount, FIELD_CHARACTER ),
// DEFINE_FIELD( first, FIELD_BOOLEAN ),
// DEFINE_FIELD( last, FIELD_BOOLEAN ),
END_DATADESC()
BEGIN_SIMPLE_DATADESC( ResponseGroup )
// DEFINE_FIELD( group, FIELD_UTLVECTOR ),
// DEFINE_FIELD( rp, FIELD_EMBEDDED ),
// DEFINE_FIELD( m_bDepleteBeforeRepeat, FIELD_BOOLEAN ),
DEFINE_FIELD( m_nDepletionCount, FIELD_CHARACTER ),
// DEFINE_FIELD( m_bHasFirst, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_bHasLast, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_bSequential, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_bNoRepeat, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
DEFINE_FIELD( m_nCurrentIndex, FIELD_CHARACTER ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CResponseSystem::CResponseSystem()
{
token[0] = 0;
m_bUnget = false;
m_bPrecache = true;
m_bCustomManagable = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CResponseSystem::~CResponseSystem()
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : char const
//-----------------------------------------------------------------------------
void CResponseSystem::GetCurrentScript( char *buf, size_t buflen )
{
Assert( buf );
buf[ 0 ] = 0;
if ( m_ScriptStack.Count() <= 0 )
return;
if ( filesystem->String( m_ScriptStack[ 0 ].name, buf, buflen ) )
{
return;
}
buf[ 0 ] = 0;
}
void CResponseSystem::PushScript( const char *scriptfile, unsigned char *buffer )
{
ScriptEntry e;
e.name = filesystem->FindOrAddFileName( scriptfile );
e.buffer = buffer;
e.currenttoken = (char *)e.buffer;
e.tokencount = 0;
m_ScriptStack.AddToHead( e );
}
void CResponseSystem::PopScript(void)
{
Assert( m_ScriptStack.Count() >= 1 );
if ( m_ScriptStack.Count() <= 0 )
return;
m_ScriptStack.Remove( 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResponseSystem::Clear()
{
m_Responses.RemoveAll();
m_Criteria.RemoveAll();
m_Rules.RemoveAll();
m_Enumerations.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *name -
// found -
// Output : float
//-----------------------------------------------------------------------------
float CResponseSystem::LookupEnumeration( const char *name, bool& found )
{
int idx = m_Enumerations.Find( name );
if ( idx == m_Enumerations.InvalidIndex() )
{
found = false;
return 0.0f;
}
found = true;
return m_Enumerations[ idx ].value;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : matcher -
//-----------------------------------------------------------------------------
void CResponseSystem::ResolveToken( Matcher& matcher, char *token, size_t bufsize, char const *rawtoken )
{
if ( rawtoken[0] != '[' )
{
Q_strncpy( token, rawtoken, bufsize );
return;
}
// Now lookup enumeration
bool found = false;
float f = LookupEnumeration( rawtoken, found );
if ( !found )
{
Q_strncpy( token, rawtoken, bufsize );
ResponseWarning( "No such enumeration '%s'\n", token );
return;
}
Q_snprintf( token, bufsize, "%f", f );
}
static bool AppearsToBeANumber( char const *token )
{
if ( atof( token ) != 0.0f )
return true;
char const *p = token;
while ( *p )
{
if ( *p != '0' )
return false;
p++;
}
return true;
}
void CResponseSystem::ComputeMatcher( Criteria *c, Matcher& matcher )
{
const char *s = c->value;
if ( !s )
{
matcher.valid = false;
return;
}
const char *in = s;
char token[ 128 ];
char rawtoken[ 128 ];
token[ 0 ] = 0;
rawtoken[ 0 ] = 0;
int n = 0;
bool gt = false;
bool lt = false;
bool eq = false;
bool nt = false;
bool done = false;
while ( !done )
{
switch( *in )
{
case '>':
{
gt = true;
Assert( !lt ); // Can't be both
}
break;
case '<':
{
lt = true;
Assert( !gt ); // Can't be both
}
break;
case '=':
{
eq = true;
}
break;
case ',':
case '\0':
{
rawtoken[ n ] = 0;
n = 0;
// Convert raw token to real token in case token is an enumerated type specifier
ResolveToken( matcher, token, sizeof( token ), rawtoken );
// Fill in first data set
if ( gt )
{
matcher.usemin = true;
matcher.minequals = eq;
matcher.minval = (float)atof( token );
matcher.isnumeric = true;
}
else if ( lt )
{
matcher.usemax = true;
matcher.maxequals = eq;
matcher.maxval = (float)atof( token );
matcher.isnumeric = true;
}
else
{
if ( *in == ',' )
{
// If there's a comma, this better have been a less than or a gt key
Assert( 0 );
}
matcher.notequal = nt;
matcher.isnumeric = AppearsToBeANumber( token );
}
gt = lt = eq = nt = false;
if ( !(*in) )
{
done = true;
}
}
break;
case '!':
nt = true;
break;
default:
rawtoken[ n++ ] = *in;
break;
}
in++;
}
matcher.SetToken( token );
matcher.SetRaw( rawtoken );
matcher.valid = true;
}
bool CResponseSystem::CompareUsingMatcher( const char *setValue, Matcher& m, bool verbose /*=false*/ )
{
if ( !m.valid )
return false;
float v = (float)atof( setValue );
if ( setValue[0] == '[' )
{
bool found = false;
v = LookupEnumeration( setValue, found );
}
int minmaxcount = 0;
if ( m.usemin )
{
if ( m.minequals )
{
if ( v < m.minval )
return false;
}
else
{
if ( v <= m.minval )
return false;
}
++minmaxcount;
}
if ( m.usemax )
{
if ( m.maxequals )
{
if ( v > m.maxval )
return false;
}
else
{
if ( v >= m.maxval )
return false;
}
++minmaxcount;
}
// Had one or both criteria and met them
if ( minmaxcount >= 1 )
{
return true;
}
if ( m.notequal )
{
if ( m.isnumeric )
{
if ( v == (float)atof( m.GetToken() ) )
return false;
}
else
{
if ( !Q_stricmp( setValue, m.GetToken() ) )
return false;
}
return true;
}
if ( m.isnumeric )
{
// If the setValue is "", the NPC doesn't have the key at all,
// in which case we shouldn't match "0".
if ( !setValue || !setValue[0] )
return false;
return v == (float)atof( m.GetToken() );
}
return !Q_stricmp( setValue, m.GetToken() ) ? true : false;
}
bool CResponseSystem::Compare( const char *setValue, Criteria *c, bool verbose /*= false*/ )
{
Assert( c );
Assert( setValue );
bool bret = CompareUsingMatcher( setValue, c->matcher, verbose );
if ( verbose )
{
DevMsg( "'%20s' vs. '%20s' = ", setValue, c->value );
{
//DevMsg( "\n" );
//m.Describe();
}
}
return bret;
}
float CResponseSystem::RecursiveScoreSubcriteriaAgainstRule( const AI_CriteriaSet& set, Criteria *parent, bool& exclude, bool verbose /*=false*/ )
{
float score = 0.0f;
int subcount = parent->subcriteria.Count();
for ( int i = 0; i < subcount; i++ )
{
int icriterion = parent->subcriteria[ i ];
bool excludesubrule = false;
if (verbose)
{
DevMsg( "\n" );
}
score += ScoreCriteriaAgainstRuleCriteria( set, icriterion, excludesubrule, verbose );
}
exclude = ( parent->required && score == 0.0f ) ? true : false;
return score * parent->weight.GetFloat();
}
float CResponseSystem::RecursiveLookForCriteria( const AI_CriteriaSet &criteriaSet, Criteria *pParent )
{
float flScore = 0.0f;
int nSubCount = pParent->subcriteria.Count();
for ( int iSub = 0; iSub < nSubCount; ++iSub )
{
int iCriteria = pParent->subcriteria[iSub];
flScore += LookForCriteria( criteriaSet, iCriteria );
}
return flScore;
}
float CResponseSystem::LookForCriteria( const AI_CriteriaSet &criteriaSet, int iCriteria )
{
Criteria *pCriteria = &m_Criteria[iCriteria];
if ( pCriteria->IsSubCriteriaType() )
{
return RecursiveLookForCriteria( criteriaSet, pCriteria );
}
int iIndex = criteriaSet.FindCriterionIndex( pCriteria->name );
if ( iIndex == -1 )
return 0.0f;
Assert( criteriaSet.GetValue( iIndex ) );
if ( Q_stricmp( criteriaSet.GetValue( iIndex ), pCriteria->value ) )
return 0.0f;
return 1.0f;
}
float CResponseSystem::ScoreCriteriaAgainstRuleCriteria( const AI_CriteriaSet& set, int icriterion, bool& exclude, bool verbose /*=false*/ )
{
Criteria *c = &m_Criteria[ icriterion ];
if ( c->IsSubCriteriaType() )
{
return RecursiveScoreSubcriteriaAgainstRule( set, c, exclude, verbose );
}
if ( verbose )
{
DevMsg( " criterion '%25s':'%15s' ", m_Criteria.GetElementName( icriterion ), c->name );
}
exclude = false;
float score = 0.0f;
const char *actualValue = "";
int found = set.FindCriterionIndex( c->name );
if ( found != -1 )
{
actualValue = set.GetValue( found );
if ( !actualValue )
{
Assert( 0 );
return score;
}
}
Assert( actualValue );
if ( Compare( actualValue, c, verbose ) )
{
float w = set.GetWeight( found );
score = w * c->weight.GetFloat();
if ( verbose )
{
DevMsg( "matched, weight %4.2f (s %4.2f x c %4.2f)",
score, w, c->weight.GetFloat() );
}
}
else
{
if ( c->required )
{
exclude = true;
if ( verbose )
{
DevMsg( "failed (+exclude rule)" );
}
}
else
{
if ( verbose )
{
DevMsg( "failed" );
}
}
}
return score;
}
float CResponseSystem::ScoreCriteriaAgainstRule( const AI_CriteriaSet& set, int irule, bool verbose /*=false*/ )
{
Rule *rule = &m_Rules[ irule ];
float score = 0.0f;
bool bBeingWatched = false;
// See if we're trying to debug this rule
const char *pszText = rr_debugrule.GetString();
if ( pszText && pszText[0] && !Q_stricmp( pszText, m_Rules.GetElementName( irule ) ) )
{
bBeingWatched = true;
}
if ( !rule->IsEnabled() )
{
if ( bBeingWatched )
{
DevMsg("Rule '%s' is disabled.\n", m_Rules.GetElementName( irule ) );
}
return 0.0f;
}
if ( bBeingWatched )
{
verbose = true;
}
if ( verbose )
{
DevMsg( "Scoring rule '%s' (%i)\n{\n", m_Rules.GetElementName( irule ), irule+1 );
}
// Iterate set criteria
int count = rule->m_Criteria.Count();
int i;
for ( i = 0; i < count; i++ )
{
int icriterion = rule->m_Criteria[ i ];
bool exclude = false;
score += ScoreCriteriaAgainstRuleCriteria( set, icriterion, exclude, verbose );
if ( verbose )
{
DevMsg( ", score %4.2f\n", score );
}
if ( exclude )
{
score = 0.0f;
break;
}
}
if ( verbose )
{
DevMsg( "}\n" );
}
return score;
}
void CResponseSystem::DebugPrint( int depth, const char *fmt, ... )
{
int indentchars = 3 * depth;
char *indent = (char *)_alloca( indentchars + 1);
indent[ indentchars ] = 0;
while ( --indentchars >= 0 )
{
indent[ indentchars ] = ' ';
}
// Dump text to debugging console.
va_list argptr;
char szText[1024];
va_start (argptr, fmt);
Q_vsnprintf (szText, sizeof( szText ), fmt, argptr);
va_end (argptr);
DevMsg( "%s%s", indent, szText );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResponseSystem::ResetResponseGroups()
{
int i;
int c = m_Responses.Count();
for ( i = 0; i < c; i++ )
{
m_Responses[ i ].Reset();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *g -
// Output : int
//-----------------------------------------------------------------------------
int CResponseSystem::SelectWeightedResponseFromResponseGroup( ResponseGroup *g, IResponseFilter *pFilter )
{
int c = g->group.Count();
if ( !c )
{
Assert( !"Expecting response group with >= 1 elements" );
return -1;
}
int i;
// Fake depletion of unavailable choices
CUtlVector<int> fakedDepletes;
if ( pFilter && g->ShouldCheckRepeats() )
{
for ( i = 0; i < c; i++ )
{
Response *r = &g->group[ i ];
if ( r->depletioncount != g->GetDepletionCount() && !pFilter->IsValidResponse( r->GetType(), r->value ) )
{
fakedDepletes.AddToTail( i );
g->MarkResponseUsed( i );
}
}
}
if ( !g->HasUndepletedChoices() )
{
g->ResetDepletionCount();
if ( pFilter && g->ShouldCheckRepeats() )
{
fakedDepletes.RemoveAll();
for ( i = 0; i < c; i++ )
{
Response *r = &g->group[ i ];
if ( !pFilter->IsValidResponse( r->GetType(), r->value ) )
{
fakedDepletes.AddToTail( i );
g->MarkResponseUsed( i );
}
}
}
if ( !g->HasUndepletedChoices() )
return -1;
// Disable the group if we looped through all the way
if ( g->IsNoRepeat() )
{
g->SetEnabled( false );
return -1;
}
}
bool checkrepeats = g->ShouldCheckRepeats();
int depletioncount = g->GetDepletionCount();
float totalweight = 0.0f;
int slot = -1;
if ( checkrepeats )
{
int check= -1;
// Snag the first slot right away
if ( g->HasUndepletedFirst( check ) && check != -1 )
{
slot = check;
}
if ( slot == -1 && g->HasUndepletedLast( check ) && check != -1 )
{
// If this is the only undepleted one, use it now
for ( i = 0; i < c; i++ )
{
Response *r = &g->group[ i ];
if ( checkrepeats &&
( r->depletioncount == depletioncount ) )
{
continue;
}
if ( r->last )
{
Assert( i == check );
continue;
}
// There's still another undepleted entry
break;
}
// No more undepleted so use the r->last slot
if ( i >= c )
{
slot = check;
}
}
}
if ( slot == -1 )
{
for ( i = 0; i < c; i++ )
{
Response *r = &g->group[ i ];
if ( checkrepeats &&
( r->depletioncount == depletioncount ) )
{
continue;
}
// Always skip last entry here since we will deal with it above
if ( checkrepeats && r->last )
continue;
int prevSlot = slot;
if ( !totalweight )
{
slot = i;
}
// Always assume very first slot will match
totalweight += r->weight.GetFloat();
if ( !totalweight || random->RandomFloat(0,totalweight) < r->weight.GetFloat() )
{
slot = i;
}
if ( !checkrepeats && slot != prevSlot && pFilter && !pFilter->IsValidResponse( r->GetType(), r->value ) )
{
slot = prevSlot;
totalweight -= r->weight.GetFloat();
}
}
}
if ( slot != -1 )
g->MarkResponseUsed( slot );
// Revert fake depletion of unavailable choices
if ( pFilter && g->ShouldCheckRepeats() )
{
for ( i = 0; i < fakedDepletes.Count(); i++ )
{
g->group[ fakedDepletes[ i ] ].depletioncount = 0;;
}
}
return slot;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : searchResult -
// depth -
// *name -
// verbose -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CResponseSystem::ResolveResponse( ResponseSearchResult& searchResult, int depth, const char *name, bool verbose /*= false*/, IResponseFilter *pFilter )
{
int responseIndex = m_Responses.Find( name );
if ( responseIndex == m_Responses.InvalidIndex() )
return false;
ResponseGroup *g = &m_Responses[ responseIndex ];
// Group has been disabled
if ( !g->IsEnabled() )
return false;
int c = g->group.Count();
if ( !c )
return false;
int idx = 0;
if ( g->IsSequential() )
{
// See if next index is valid
int initialIndex = g->GetCurrentIndex();
bool bFoundValid = false;
do
{
idx = g->GetCurrentIndex();
g->SetCurrentIndex( idx + 1 );
if ( idx >= c )
{
if ( g->IsNoRepeat() )
{
g->SetEnabled( false );
return false;
}
idx = 0;
g->SetCurrentIndex( 0 );
}
if ( !pFilter || pFilter->IsValidResponse( g->group[idx].GetType(), g->group[idx].value ) )
{
bFoundValid = true;
break;
}
} while ( g->GetCurrentIndex() != initialIndex );
if ( !bFoundValid )
return false;
}
else
{
idx = SelectWeightedResponseFromResponseGroup( g, pFilter );
if ( idx < 0 )
return false;
}
if ( verbose )
{
DebugPrint( depth, "%s\n", m_Responses.GetElementName( responseIndex ) );
DebugPrint( depth, "{\n" );
DescribeResponseGroup( g, idx, depth );
}
bool bret = true;
Response *result = &g->group[ idx ];
if ( result->type == RESPONSE_RESPONSE )
{
// Recurse
bret = ResolveResponse( searchResult, depth + 1, result->value, verbose, pFilter );
}
else
{
searchResult.action = result;
searchResult.group = g;
}
if( verbose )
{
DebugPrint( depth, "}\n" );
}
return bret;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *group -
// selected -
// depth -
//-----------------------------------------------------------------------------
void CResponseSystem::DescribeResponseGroup( ResponseGroup *group, int selected, int depth )
{
int c = group->group.Count();
for ( int i = 0; i < c ; i++ )
{
Response *r = &group->group[ i ];
DebugPrint( depth + 1, "%s%20s : %40s %5.3f\n",
i == selected ? "-> " : " ",
AI_Response::DescribeResponse( r->GetType() ),
r->value,
r->weight.GetFloat() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *rule -
// Output : CResponseSystem::Response
//-----------------------------------------------------------------------------
bool CResponseSystem::GetBestResponse( ResponseSearchResult& searchResult, Rule *rule, bool verbose /*=false*/, IResponseFilter *pFilter )
{
int c = rule->m_Responses.Count();
if ( !c )
return false;
int index = random->RandomInt( 0, c - 1 );
int groupIndex = rule->m_Responses[ index ];
ResponseGroup *g = &m_Responses[ groupIndex ];
// Group has been disabled
if ( !g->IsEnabled() )
return false;
int count = g->group.Count();
if ( !count )
return false;
int responseIndex = 0;
if ( g->IsSequential() )
{
// See if next index is valid
int initialIndex = g->GetCurrentIndex();
bool bFoundValid = false;
do
{
responseIndex = g->GetCurrentIndex();
g->SetCurrentIndex( responseIndex + 1 );
if ( responseIndex >= count )
{
if ( g->IsNoRepeat() )
{
g->SetEnabled( false );
return false;
}
responseIndex = 0;
g->SetCurrentIndex( 0 );
}
if ( !pFilter || pFilter->IsValidResponse( g->group[responseIndex].GetType(), g->group[responseIndex].value ) )
{
bFoundValid = true;
break;
}
} while ( g->GetCurrentIndex() != initialIndex );
if ( !bFoundValid )
return false;
}
else
{
responseIndex = SelectWeightedResponseFromResponseGroup( g, pFilter );
if ( responseIndex < 0 )
return false;
}
Response *r = &g->group[ responseIndex ];
int depth = 0;
if ( verbose )
{
DebugPrint( depth, "%s\n", m_Responses.GetElementName( groupIndex ) );
DebugPrint( depth, "{\n" );
DescribeResponseGroup( g, responseIndex, depth );
}
bool bret = true;
if ( r->type == RESPONSE_RESPONSE )
{
bret = ResolveResponse( searchResult, depth + 1, r->value, verbose, pFilter );
}
else
{
searchResult.action = r;
searchResult.group = g;
}
if ( verbose )
{
DebugPrint( depth, "}\n" );
}
return bret;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : set -
// verbose -
// Output : int
//-----------------------------------------------------------------------------
int CResponseSystem::FindBestMatchingRule( const AI_CriteriaSet& set, bool verbose )
{
CUtlVector< int > bestrules;
float bestscore = 0.001f;
int c = m_Rules.Count();
int i;
for ( i = 0; i < c; i++ )
{
float score = ScoreCriteriaAgainstRule( set, i, verbose );
// Check equals so that we keep track of all matching rules
if ( score >= bestscore )
{
// Reset bucket
if( score != bestscore )
{
bestscore = score;
bestrules.RemoveAll();
}
// Add to bucket
bestrules.AddToTail( i );
}
}
int bestCount = bestrules.Count();
if ( bestCount <= 0 )
return -1;
if ( bestCount == 1 )
return bestrules[ 0 ];
// Randomly pick one of the tied matching rules
int idx = random->RandomInt( 0, bestCount - 1 );
if ( verbose )
{
DevMsg( "Found %i matching rules, selecting slot %i\n", bestCount, idx );
}
return bestrules[ idx ];
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : set -
// Output : AI_Response
//-----------------------------------------------------------------------------
bool CResponseSystem::FindBestResponse( const AI_CriteriaSet& set, AI_Response& response, IResponseFilter *pFilter )
{
bool valid = false;
int iDbgResponse = rr_debugresponses.GetInt();
bool showRules = ( iDbgResponse == 2 );
bool showResult = ( iDbgResponse == 1 || iDbgResponse == 2 );
// Look for match. verbose mode used to be at level 2, but disabled because the writers don't actually care for that info.
int bestRule = FindBestMatchingRule( set, iDbgResponse == 3 );
ResponseType_t responseType = RESPONSE_NONE;
AI_ResponseParams rp;
char ruleName[ 128 ];
char responseName[ 128 ];
const char *context;
bool bcontexttoworld;
ruleName[ 0 ] = 0;
responseName[ 0 ] = 0;
context = NULL;
bcontexttoworld = false;
if ( bestRule != -1 )
{
Rule *r = &m_Rules[ bestRule ];
ResponseSearchResult result;
if ( GetBestResponse( result, r, showResult, pFilter ) )
{
Q_strncpy( responseName, result.action->value, sizeof( responseName ) );
responseType = result.action->GetType();
rp = result.group->rp;
}
Q_strncpy( ruleName, m_Rules.GetElementName( bestRule ), sizeof( ruleName ) );
// Disable the rule if it only allows for matching one time
if ( r->IsMatchOnce() )
{
r->Disable();
}
context = r->GetContext();
bcontexttoworld = r->IsApplyContextToWorld();
valid = true;
}
response.Init( responseType, responseName, set, rp, ruleName, context, bcontexttoworld );
if ( showResult )
{
/*
// clipped -- chet doesn't really want this info
if ( valid )
{
// Rescore the winner and dump to console
ScoreCriteriaAgainstRule( set, bestRule, true );
}
*/
if ( valid || showRules )
{
// Describe the response, too
response.Describe();
}
}
return valid;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CResponseSystem::GetAllResponses( CUtlVector<AI_Response *> *pResponses )
{
for ( int i = 0; i < (int)m_Responses.Count(); i++ )
{
ResponseGroup &group = m_Responses[i];
for ( int j = 0; j < group.group.Count(); j++)
{
Response &response = group.group[j];
if ( response.type != RESPONSE_RESPONSE )
{
AI_Response *pResponse = new AI_Response;
pResponse->Init( response.GetType(), response.value, AI_CriteriaSet(), group.rp, NULL, NULL, false );
pResponses->AddToTail(pResponse);
}
}
}
}
static void TouchFile( char const *pchFileName )
{
filesystem->Size( pchFileName );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResponseSystem::Precache()
{
bool bTouchFiles = CommandLine()->FindParm( "-makereslists" ) != 0;
// enumerate and mark all the scripts so we know they're referenced
for ( int i = 0; i < (int)m_Responses.Count(); i++ )
{
ResponseGroup &group = m_Responses[i];
for ( int j = 0; j < group.group.Count(); j++)
{
Response &response = group.group[j];
switch ( response.type )
{
default:
break;
case RESPONSE_SCENE:
{
// fixup $gender references
char file[_MAX_PATH];
Q_strncpy( file, response.value, sizeof(file) );
char *gender = strstr( file, "$gender" );
if ( gender )
{
// replace with male & female
const char *postGender = gender + strlen("$gender");
*gender = 0;
char genderFile[_MAX_PATH];
// male
Q_snprintf( genderFile, sizeof(genderFile), "%smale%s", file, postGender);
PrecacheInstancedScene( genderFile );
if ( bTouchFiles )
{
TouchFile( genderFile );
}
Q_snprintf( genderFile, sizeof(genderFile), "%sfemale%s", file, postGender);
PrecacheInstancedScene( genderFile );
if ( bTouchFiles )
{
TouchFile( genderFile );
}
}
else
{
PrecacheInstancedScene( file );
if ( bTouchFiles )
{
TouchFile( file );
}
}
}
break;
case RESPONSE_SPEAK:
{
CBaseEntity::PrecacheScriptSound( response.value );
}
break;
}
}
}
}
void CResponseSystem::ParseInclude( CStringPool &includedFiles )
{
char includefile[ 256 ];
ParseToken();
Q_snprintf( includefile, sizeof( includefile ), "scripts/%s", token );
// check if the file is already included
if ( includedFiles.Find( includefile ) != NULL )
{
return;
}
MEM_ALLOC_CREDIT();
// Try and load it
CUtlBuffer buf;
if ( !filesystem->ReadFile( includefile, "GAME", buf ) )
{
DevMsg( "Unable to load #included script %s\n", includefile );
return;
}
LoadFromBuffer( includefile, (const char *)buf.PeekGet(), includedFiles );
}
void CResponseSystem::LoadFromBuffer( const char *scriptfile, const char *buffer, CStringPool &includedFiles )
{
includedFiles.Allocate( scriptfile );
PushScript( scriptfile, (unsigned char * )buffer );
if( rr_dumpresponses.GetBool() )
{
DevMsg("Reading: %s\n", scriptfile );
}
while ( 1 )
{
ParseToken();
if ( !token[0] )
{
break;
}
if ( !Q_stricmp( token, "#include" ) )
{
ParseInclude( includedFiles );
}
else if ( !Q_stricmp( token, "response" ) )
{
ParseResponse();
}
else if ( !Q_stricmp( token, "criterion" ) ||
!Q_stricmp( token, "criteria" ) )
{
ParseCriterion();
}
else if ( !Q_stricmp( token, "rule" ) )
{
ParseRule();
}
else if ( !Q_stricmp( token, "enumeration" ) )
{
ParseEnumeration();
}
else
{
int byteoffset = m_ScriptStack[ 0 ].currenttoken - (const char *)m_ScriptStack[ 0 ].buffer;
Error( "CResponseSystem::LoadFromBuffer: Unknown entry type '%s', expecting 'response', 'criterion', 'enumeration' or 'rules' in file %s(offset:%i)\n",
token, scriptfile, byteoffset );
break;
}
}
if ( m_ScriptStack.Count() == 1 )
{
char cur[ 256 ];
GetCurrentScript( cur, sizeof( cur ) );
DevMsg( 1, "CResponseSystem: %s (%i rules, %i criteria, and %i responses)\n",
cur, m_Rules.Count(), m_Criteria.Count(), m_Responses.Count() );
if( rr_dumpresponses.GetBool() )
{
DumpRules();
}
}
PopScript();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResponseSystem::LoadRuleSet( const char *basescript )
{
int length = 0;
unsigned char *buffer = (unsigned char *)UTIL_LoadFileForMe( basescript, &length );
if ( length <= 0 || !buffer )
{
DevMsg( 1, "CResponseSystem: failed to load %s\n", basescript );
return;
}
CStringPool includedFiles;
LoadFromBuffer( basescript, (const char *)buffer, includedFiles );
UTIL_FreeFile( buffer );
Assert( m_ScriptStack.Count() == 0 );
}
static ResponseType_t ComputeResponseType( const char *s )
{
if ( !Q_stricmp( s, "scene" ) )
{
return RESPONSE_SCENE;
}
else if ( !Q_stricmp( s, "sentence" ) )
{
return RESPONSE_SENTENCE;
}
else if ( !Q_stricmp( s, "speak" ) )
{
return RESPONSE_SPEAK;
}
else if ( !Q_stricmp( s, "response" ) )
{
return RESPONSE_RESPONSE;
}
else if ( !Q_stricmp( s, "print" ) )
{
return RESPONSE_PRINT;
}
return RESPONSE_NONE;
}
void CResponseSystem::ParseOneResponse( const char *responseGroupName, ResponseGroup& group )
{
Response newResponse;
newResponse.weight.SetFloat( 1.0f );
AI_ResponseParams *rp = &group.rp;
newResponse.type = ComputeResponseType( token );
if ( RESPONSE_NONE == newResponse.type )
{
ResponseWarning( "response entry '%s' with unknown response type '%s'\n", responseGroupName, token );
return;
}
ParseToken();
newResponse.value = CopyString( token );
while ( TokenWaiting() )
{
ParseToken();
if ( !Q_stricmp( token, "weight" ) )
{
ParseToken();
newResponse.weight.SetFloat( (float)atof( token ) );
continue;
}
if ( !Q_stricmp( token, "predelay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_DELAYBEFORESPEAK;
rp->predelay.FromInterval( ReadInterval( token ) );
continue;
}
if ( !Q_stricmp( token, "nodelay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_DELAYAFTERSPEAK;
rp->delay.start = 0;
rp->delay.range = 0;
continue;
}
if ( !Q_stricmp( token, "defaultdelay" ) )
{
rp->flags |= AI_ResponseParams::RG_DELAYAFTERSPEAK;
rp->delay.start = AIS_DEF_MIN_DELAY;
rp->delay.range = ( AIS_DEF_MAX_DELAY - AIS_DEF_MIN_DELAY );
continue;
}
if ( !Q_stricmp( token, "delay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_DELAYAFTERSPEAK;
rp->delay.FromInterval( ReadInterval( token ) );
continue;
}
if ( !Q_stricmp( token, "speakonce" ) )
{
rp->flags |= AI_ResponseParams::RG_SPEAKONCE;
continue;
}
if ( !Q_stricmp( token, "noscene" ) )
{
rp->flags |= AI_ResponseParams::RG_DONT_USE_SCENE;
continue;
}
if ( !Q_stricmp( token, "stop_on_nonidle" ) )
{
rp->flags |= AI_ResponseParams::RG_STOP_ON_NONIDLE;
continue;
}
if ( !Q_stricmp( token, "odds" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_ODDS;
rp->odds = clamp( atoi( token ), 0, 100 );
continue;
}
if ( !Q_stricmp( token, "respeakdelay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_RESPEAKDELAY;
rp->respeakdelay.FromInterval( ReadInterval( token ) );
continue;
}
if ( !Q_stricmp( token, "weapondelay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_WEAPONDELAY;
rp->weapondelay.FromInterval( ReadInterval( token ) );
continue;
}
if ( !Q_stricmp( token, "soundlevel" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_SOUNDLEVEL;
rp->soundlevel = (soundlevel_t)TextToSoundLevel( token );
continue;
}
if ( !Q_stricmp( token, "displayfirst" ) )
{
newResponse.first = true;
group.m_bHasFirst = true;
continue;
}
if ( !Q_stricmp( token, "displaylast" ) )
{
newResponse.last = true;
group.m_bHasLast= true;
continue;
}
ResponseWarning( "response entry '%s' with unknown command '%s'\n", responseGroupName, token );
}
group.group.AddToTail( newResponse );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CResponseSystem::IsRootCommand()
{
if ( !Q_stricmp( token, "#include" ) )
return true;
if ( !Q_stricmp( token, "response" ) )
return true;
if ( !Q_stricmp( token, "enumeration" ) )
return true;
if ( !Q_stricmp( token, "criteria" ) )
return true;
if ( !Q_stricmp( token, "criterion" ) )
return true;
if ( !Q_stricmp( token, "rule" ) )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *kv -
//-----------------------------------------------------------------------------
void CResponseSystem::ParseResponse( void )
{
// Should have groupname at start
char responseGroupName[ 128 ];
ResponseGroup newGroup;
AI_ResponseParams *rp = &newGroup.rp;
// Response Group Name
ParseToken();
Q_strncpy( responseGroupName, token, sizeof( responseGroupName ) );
while ( 1 )
{
ParseToken();
// Oops, part of next definition
if( IsRootCommand() )
{
Unget();
break;
}
if ( !Q_stricmp( token, "{" ) )
{
while ( 1 )
{
ParseToken();
if ( !Q_stricmp( token, "}" ) )
break;
if ( !Q_stricmp( token, "permitrepeats" ) )
{
newGroup.m_bDepleteBeforeRepeat = false;
continue;
}
else if ( !Q_stricmp( token, "sequential" ) )
{
newGroup.SetSequential( true );
continue;
}
else if ( !Q_stricmp( token, "norepeat" ) )
{
newGroup.SetNoRepeat( true );
continue;
}
ParseOneResponse( responseGroupName, newGroup );
}
break;
}
if ( !Q_stricmp( token, "predelay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_DELAYBEFORESPEAK;
rp->predelay.FromInterval( ReadInterval( token ) );
continue;
}
if ( !Q_stricmp( token, "nodelay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_DELAYAFTERSPEAK;
rp->delay.start = 0;
rp->delay.range = 0;
continue;
}
if ( !Q_stricmp( token, "defaultdelay" ) )
{
rp->flags |= AI_ResponseParams::RG_DELAYAFTERSPEAK;
rp->delay.start = AIS_DEF_MIN_DELAY;
rp->delay.range = ( AIS_DEF_MAX_DELAY - AIS_DEF_MIN_DELAY );
continue;
}
if ( !Q_stricmp( token, "delay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_DELAYAFTERSPEAK;
rp->delay.FromInterval( ReadInterval( token ) );
continue;
}
if ( !Q_stricmp( token, "speakonce" ) )
{
rp->flags |= AI_ResponseParams::RG_SPEAKONCE;
continue;
}
if ( !Q_stricmp( token, "noscene" ) )
{
rp->flags |= AI_ResponseParams::RG_DONT_USE_SCENE;
continue;
}
if ( !Q_stricmp( token, "stop_on_nonidle" ) )
{
rp->flags |= AI_ResponseParams::RG_STOP_ON_NONIDLE;
continue;
}
if ( !Q_stricmp( token, "odds" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_ODDS;
rp->odds = clamp( atoi( token ), 0, 100 );
continue;
}
if ( !Q_stricmp( token, "respeakdelay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_RESPEAKDELAY;
rp->respeakdelay.FromInterval( ReadInterval( token ) );
continue;
}
if ( !Q_stricmp( token, "weapondelay" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_WEAPONDELAY;
rp->weapondelay.FromInterval( ReadInterval( token ) );
continue;
}
if ( !Q_stricmp( token, "soundlevel" ) )
{
ParseToken();
rp->flags |= AI_ResponseParams::RG_SOUNDLEVEL;
rp->soundlevel = (soundlevel_t)TextToSoundLevel( token );
continue;
}
ParseOneResponse( responseGroupName, newGroup );
}
m_Responses.Insert( responseGroupName, newGroup );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *criterion -
//-----------------------------------------------------------------------------
int CResponseSystem::ParseOneCriterion( const char *criterionName )
{
char key[ 128 ];
char value[ 128 ];
Criteria newCriterion;
bool gotbody = false;
while ( TokenWaiting() || !gotbody )
{
ParseToken();
// Oops, part of next definition
if( IsRootCommand() )
{
Unget();
break;
}
if ( !Q_stricmp( token, "{" ) )
{
gotbody = true;
while ( 1 )
{
ParseToken();
if ( !Q_stricmp( token, "}" ) )
break;
// Look up subcriteria index
int idx = m_Criteria.Find( token );
if ( idx != m_Criteria.InvalidIndex() )
{
newCriterion.subcriteria.AddToTail( idx );
}
else
{
ResponseWarning( "Skipping unrecongized subcriterion '%s' in '%s'\n", token, criterionName );
}
}
continue;
}
else if ( !Q_stricmp( token, "required" ) )
{
newCriterion.required = true;
}
else if ( !Q_stricmp( token, "weight" ) )
{
ParseToken();
newCriterion.weight.SetFloat( (float)atof( token ) );
}
else
{
Assert( newCriterion.subcriteria.Count() == 0 );
// Assume it's the math info for a non-subcriteria resposne
Q_strncpy( key, token, sizeof( key ) );
ParseToken();
Q_strncpy( value, token, sizeof( value ) );
newCriterion.name = CopyString( key );
newCriterion.value = CopyString( value );
gotbody = true;
}
}
if ( !newCriterion.IsSubCriteriaType() )
{
ComputeMatcher( &newCriterion, newCriterion.matcher );
}
if ( m_Criteria.Find( criterionName ) != m_Criteria.InvalidIndex() )
{
ResponseWarning( "Multiple definitions for criteria '%s'\n", criterionName );
return m_Criteria.InvalidIndex();
}
int idx = m_Criteria.Insert( criterionName, newCriterion );
return idx;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *kv -
//-----------------------------------------------------------------------------
void CResponseSystem::ParseCriterion( void )
{
// Should have groupname at start
char criterionName[ 128 ];
ParseToken();
Q_strncpy( criterionName, token, sizeof( criterionName ) );
ParseOneCriterion( criterionName );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *kv -
//-----------------------------------------------------------------------------
void CResponseSystem::ParseEnumeration( void )
{
char enumerationName[ 128 ];
ParseToken();
Q_strncpy( enumerationName, token, sizeof( enumerationName ) );
ParseToken();
if ( Q_stricmp( token, "{" ) )
{
ResponseWarning( "Expecting '{' in enumeration '%s', got '%s'\n", enumerationName, token );
return;
}
while ( 1 )
{
ParseToken();
if ( !Q_stricmp( token, "}" ) )
break;
if ( Q_strlen( token ) <= 0 )
{
ResponseWarning( "Expecting more tokens in enumeration '%s'\n", enumerationName );
break;
}
char key[ 128 ];
Q_strncpy( key, token, sizeof( key ) );
ParseToken();
float value = (float)atof( token );
char sz[ 128 ];
Q_snprintf( sz, sizeof( sz ), "[%s::%s]", enumerationName, key );
Q_strlower( sz );
Enumeration newEnum;
newEnum.value = value;
if ( m_Enumerations.Find( sz ) == m_Enumerations.InvalidIndex() )
{
m_Enumerations.Insert( sz, newEnum );
}
/*
else
{
ResponseWarning( "Ignoring duplication enumeration '%s'\n", sz );
}
*/
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *kv -
//-----------------------------------------------------------------------------
void CResponseSystem::ParseRule( void )
{
static int instancedCriteria = 0;
char ruleName[ 128 ];
ParseToken();
Q_strncpy( ruleName, token, sizeof( ruleName ) );
ParseToken();
if ( Q_stricmp( token, "{" ) )
{
ResponseWarning( "Expecting '{' in rule '%s', got '%s'\n", ruleName, token );
return;
}
// entries are "criteria", "response" or an in-line criteria to instance
Rule newRule;
char sz[ 128 ];
bool validRule = true;
while ( 1 )
{
ParseToken();
if ( !Q_stricmp( token, "}" ) )
{
break;
}
if ( Q_strlen( token ) <= 0 )
{
ResponseWarning( "Expecting more tokens in rule '%s'\n", ruleName );
break;
}
if ( !Q_stricmp( token, "matchonce" ) )
{
newRule.m_bMatchOnce = true;
continue;
}
if ( !Q_stricmp( token, "applyContextToWorld" ) )
{
newRule.m_bApplyContextToWorld = true;
continue;
}
if ( !Q_stricmp( token, "applyContext" ) )
{
ParseToken();
if ( newRule.GetContext() == NULL )
{
newRule.SetContext( token );
}
else
{
CFmtStrN<1024> newContext( "%s,%s", newRule.GetContext(), token );
newRule.SetContext( newContext );
}
continue;
}
if ( !Q_stricmp( token, "response" ) )
{
// Read them until we run out.
while ( TokenWaiting() )
{
ParseToken();
int idx = m_Responses.Find( token );
if ( idx != m_Responses.InvalidIndex() )
{
MEM_ALLOC_CREDIT();
newRule.m_Responses.AddToTail( idx );
}
else
{
validRule = false;
ResponseWarning( "No such response '%s' for rule '%s'\n", token, ruleName );
}
}
continue;
}
if ( !Q_stricmp( token, "criteria" ) ||
!Q_stricmp( token, "criterion" ) )
{
// Read them until we run out.
while ( TokenWaiting() )
{
ParseToken();
int idx = m_Criteria.Find( token );
if ( idx != m_Criteria.InvalidIndex() )
{
MEM_ALLOC_CREDIT();
newRule.m_Criteria.AddToTail( idx );
}
else
{
validRule = false;
ResponseWarning( "No such criterion '%s' for rule '%s'\n", token, ruleName );
}
}
continue;
}
// It's an inline criteria, generate a name and parse it in
Q_snprintf( sz, sizeof( sz ), "[%s%03i]", ruleName, ++instancedCriteria );
Unget();
int idx = ParseOneCriterion( sz );
if ( idx != m_Criteria.InvalidIndex() )
{
newRule.m_Criteria.AddToTail( idx );
}
}
if ( validRule )
{
m_Rules.Insert( ruleName, newRule );
}
else
{
DevMsg( "Discarded rule %s\n", ruleName );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CResponseSystem::GetCurrentToken() const
{
if ( m_ScriptStack.Count() <= 0 )
return -1;
return m_ScriptStack[ 0 ].tokencount;
}
void CResponseSystem::ResponseWarning( const char *fmt, ... )
{
va_list argptr;
#ifndef _XBOX
static char string[1024];
#else
char string[1024];
#endif
va_start (argptr, fmt);
Q_vsnprintf(string, sizeof(string), fmt,argptr);
va_end (argptr);
char cur[ 256 ];
GetCurrentScript( cur, sizeof( cur ) );
DevMsg( 1, "%s(token %i) : %s", cur, GetCurrentToken(), string );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResponseSystem::CopyCriteriaFrom( Rule *pSrcRule, Rule *pDstRule, CResponseSystem *pCustomSystem )
{
// Add criteria from this rule to global list in custom response system.
int nCriteriaCount = pSrcRule->m_Criteria.Count();
for ( int iCriteria = 0; iCriteria < nCriteriaCount; ++iCriteria )
{
int iSrcIndex = pSrcRule->m_Criteria[iCriteria];
Criteria *pSrcCriteria = &m_Criteria[iSrcIndex];
if ( pSrcCriteria )
{
int iIndex = pCustomSystem->m_Criteria.Find( m_Criteria.GetElementName( iSrcIndex ) );
if ( iIndex != pCustomSystem->m_Criteria.InvalidIndex() )
{
pDstRule->m_Criteria.AddToTail( iIndex );
continue;
}
// Add the criteria.
Criteria dstCriteria;
dstCriteria.name = CopyString( pSrcCriteria->name );
dstCriteria.value = CopyString( pSrcCriteria->value );
dstCriteria.weight = pSrcCriteria->weight;
dstCriteria.required = pSrcCriteria->required;
dstCriteria.matcher = pSrcCriteria->matcher;
int nSubCriteriaCount = pSrcCriteria->subcriteria.Count();
for ( int iSubCriteria = 0; iSubCriteria < nSubCriteriaCount; ++iSubCriteria )
{
int iSrcSubIndex = pSrcCriteria->subcriteria[iSubCriteria];
Criteria *pSrcSubCriteria = &m_Criteria[iSrcSubIndex];
if ( pSrcCriteria )
{
int iSubIndex = pCustomSystem->m_Criteria.Find( pSrcSubCriteria->value );
if ( iSubIndex != pCustomSystem->m_Criteria.InvalidIndex() )
continue;
// Add the criteria.
Criteria dstSubCriteria;
dstSubCriteria.name = CopyString( pSrcSubCriteria->name );
dstSubCriteria.value = CopyString( pSrcSubCriteria->value );
dstSubCriteria.weight = pSrcSubCriteria->weight;
dstSubCriteria.required = pSrcSubCriteria->required;
dstSubCriteria.matcher = pSrcSubCriteria->matcher;
int iSubInsertIndex = pCustomSystem->m_Criteria.Insert( pSrcSubCriteria->value, dstSubCriteria );
dstCriteria.subcriteria.AddToTail( iSubInsertIndex );
}
}
int iInsertIndex = pCustomSystem->m_Criteria.Insert( m_Criteria.GetElementName( iSrcIndex ), dstCriteria );
pDstRule->m_Criteria.AddToTail( iInsertIndex );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResponseSystem::CopyResponsesFrom( Rule *pSrcRule, Rule *pDstRule, CResponseSystem *pCustomSystem )
{
// Add responses from this rule to global list in custom response system.
int nResponseGroupCount = pSrcRule->m_Responses.Count();
for ( int iResponseGroup = 0; iResponseGroup < nResponseGroupCount; ++iResponseGroup )
{
int iSrcResponseGroup = pSrcRule->m_Responses[iResponseGroup];
ResponseGroup *pSrcResponseGroup = &m_Responses[iSrcResponseGroup];
if ( pSrcResponseGroup )
{
// Add response group.
ResponseGroup dstResponseGroup;
dstResponseGroup.rp = pSrcResponseGroup->rp;
dstResponseGroup.m_bDepleteBeforeRepeat = pSrcResponseGroup->m_bDepleteBeforeRepeat;
dstResponseGroup.m_nDepletionCount = pSrcResponseGroup->m_nDepletionCount;
dstResponseGroup.m_bHasFirst = pSrcResponseGroup->m_bHasFirst;
dstResponseGroup.m_bHasLast = pSrcResponseGroup->m_bHasLast;
dstResponseGroup.m_bSequential = pSrcResponseGroup->m_bSequential;
dstResponseGroup.m_bNoRepeat = pSrcResponseGroup->m_bNoRepeat;
dstResponseGroup.m_bEnabled = pSrcResponseGroup->m_bEnabled;
dstResponseGroup.m_nCurrentIndex = pSrcResponseGroup->m_nCurrentIndex;
int nSrcResponseCount = pSrcResponseGroup->group.Count();
for ( int iResponse = 0; iResponse < nSrcResponseCount; ++iResponse )
{
Response *pSrcResponse = &pSrcResponseGroup->group[iResponse];
if ( pSrcResponse )
{
// Add Response
Response dstResponse;
dstResponse.weight = pSrcResponse->weight;
dstResponse.type = pSrcResponse->type;
dstResponse.value = CopyString( pSrcResponse->value );
dstResponse.depletioncount = pSrcResponse->depletioncount;
dstResponse.first = pSrcResponse->first;
dstResponse.last = pSrcResponse->last;
dstResponseGroup.group.AddToTail( dstResponse );
}
}
int iInsertIndex = pCustomSystem->m_Responses.Insert( m_Responses.GetElementName( iSrcResponseGroup ), dstResponseGroup );
pDstRule->m_Responses.AddToTail( iInsertIndex );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResponseSystem::CopyEnumerationsFrom( CResponseSystem *pCustomSystem )
{
int nEnumerationCount = m_Enumerations.Count();
for ( int iEnumeration = 0; iEnumeration < nEnumerationCount; ++iEnumeration )
{
Enumeration *pSrcEnumeration = &m_Enumerations[iEnumeration];
if ( pSrcEnumeration )
{
Enumeration dstEnumeration;
dstEnumeration.value = pSrcEnumeration->value;
pCustomSystem->m_Enumerations.Insert( m_Enumerations.GetElementName( iEnumeration ), dstEnumeration );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CResponseSystem::CopyRuleFrom( Rule *pSrcRule, int iRule, CResponseSystem *pCustomSystem )
{
// Verify data.
Assert( pSrcRule );
Assert( pCustomSystem );
if ( !pSrcRule || !pCustomSystem )
return;
// New rule
Rule dstRule;
dstRule.SetContext( pSrcRule->GetContext() );
dstRule.m_bMatchOnce = pSrcRule->m_bMatchOnce;
dstRule.m_bEnabled = pSrcRule->m_bEnabled;
dstRule.m_bApplyContextToWorld = pSrcRule->m_bApplyContextToWorld;
// Copy off criteria.
CopyCriteriaFrom( pSrcRule, &dstRule, pCustomSystem );
// Copy off responses.
CopyResponsesFrom( pSrcRule, &dstRule, pCustomSystem );
// Copy off enumerations - Don't think we use these.
// CopyEnumerationsFrom( pCustomSystem );
// Add rule.
pCustomSystem->m_Rules.Insert( m_Rules.GetElementName( iRule ), dstRule );
}
//-----------------------------------------------------------------------------
// Purpose: A special purpose response system associated with a custom entity
//-----------------------------------------------------------------------------
class CInstancedResponseSystem : public CResponseSystem
{
typedef CResponseSystem BaseClass;
public:
CInstancedResponseSystem( const char *scriptfile ) :
m_pszScriptFile( 0 )
{
Assert( scriptfile );
int len = Q_strlen( scriptfile ) + 1;
m_pszScriptFile = new char[ len ];
Assert( m_pszScriptFile );
Q_strncpy( m_pszScriptFile, scriptfile, len );
}
~CInstancedResponseSystem()
{
delete[] m_pszScriptFile;
}
virtual const char *GetScriptFile( void )
{
Assert( m_pszScriptFile );
return m_pszScriptFile;
}
// CAutoGameSystem
virtual bool Init()
{
const char *basescript = GetScriptFile();
LoadRuleSet( basescript );
return true;
}
virtual void LevelInitPostEntity()
{
ResetResponseGroups();
}
virtual void Release()
{
Clear();
delete this;
}
private:
char *m_pszScriptFile;
};
//-----------------------------------------------------------------------------
// Purpose: The default response system for expressive AIs
//-----------------------------------------------------------------------------
class CDefaultResponseSystem : public CResponseSystem, public CAutoGameSystem
{
typedef CAutoGameSystem BaseClass;
public:
CDefaultResponseSystem() : CAutoGameSystem( "CDefaultResponseSystem" )
{
}
virtual const char *GetScriptFile( void )
{
return "scripts/talker/response_rules.txt";
}
// CAutoServerSystem
virtual bool Init();
virtual void Shutdown();
virtual void LevelInitPostEntity()
{
}
virtual void Release()
{
Assert( 0 );
}
void AddInstancedResponseSystem( const char *scriptfile, CInstancedResponseSystem *sys )
{
m_InstancedSystems.Insert( scriptfile, sys );
}
CInstancedResponseSystem *FindResponseSystem( const char *scriptfile )
{
int idx = m_InstancedSystems.Find( scriptfile );
if ( idx == m_InstancedSystems.InvalidIndex() )
return NULL;
return m_InstancedSystems[ idx ];
}
IResponseSystem *PrecacheCustomResponseSystem( const char *scriptfile )
{
CInstancedResponseSystem *sys = ( CInstancedResponseSystem * )FindResponseSystem( scriptfile );
if ( !sys )
{
sys = new CInstancedResponseSystem( scriptfile );
if ( !sys )
{
Error( "Failed to load response system data from %s", scriptfile );
}
if ( !sys->Init() )
{
Error( "CInstancedResponseSystem: Failed to init response system from %s!", scriptfile );
}
AddInstancedResponseSystem( scriptfile, sys );
}
sys->Precache();
return ( IResponseSystem * )sys;
}
IResponseSystem *BuildCustomResponseSystemGivenCriteria( const char *pszBaseFile, const char *pszCustomName, AI_CriteriaSet &criteriaSet, float flCriteriaScore );
void DestroyCustomResponseSystems();
virtual void LevelInitPreEntity()
{
// This will precache the default system
// All user installed systems are init'd by PrecacheCustomResponseSystem which will call sys->Precache() on the ones being used
// FIXME: This is SLOW the first time you run the engine (can take 3 - 10 seconds!!!)
if ( ShouldPrecache() )
{
Precache();
}
ResetResponseGroups();
}
void ReloadAllResponseSystems()
{
Clear();
Init();
int c = m_InstancedSystems.Count();
for ( int i = c - 1 ; i >= 0; i-- )
{
CInstancedResponseSystem *sys = m_InstancedSystems[ i ];
if ( !IsCustomManagable() )
{
sys->Clear();
sys->Init();
}
else
{
// Custom reponse rules will manage/reload themselves - remove them.
m_InstancedSystems.RemoveAt( i );
}
}
}
private:
void ClearInstanced()
{
int c = m_InstancedSystems.Count();
for ( int i = c - 1 ; i >= 0; i-- )
{
CInstancedResponseSystem *sys = m_InstancedSystems[ i ];
sys->Release();
}
m_InstancedSystems.RemoveAll();
}
CUtlDict< CInstancedResponseSystem *, int > m_InstancedSystems;
};
IResponseSystem *CDefaultResponseSystem::BuildCustomResponseSystemGivenCriteria( const char *pszBaseFile, const char *pszCustomName, AI_CriteriaSet &criteriaSet, float flCriteriaScore )
{
// Create a instanced response system.
CInstancedResponseSystem *pCustomSystem = new CInstancedResponseSystem( pszCustomName );
if ( !pCustomSystem )
{
Error( "BuildCustomResponseSystemGivenCriterea: Failed to create custom response system %s!", pszCustomName );
}
pCustomSystem->Clear();
// Copy the relevant rules and data.
int nRuleCount = m_Rules.Count();
for ( int iRule = 0; iRule < nRuleCount; ++iRule )
{
Rule *pRule = &m_Rules[iRule];
if ( pRule )
{
float flScore = 0.0f;
int nCriteriaCount = pRule->m_Criteria.Count();
for ( int iCriteria = 0; iCriteria < nCriteriaCount; ++iCriteria )
{
int iRuleCriteria = pRule->m_Criteria[iCriteria];
flScore += LookForCriteria( criteriaSet, iRuleCriteria );
if ( flScore >= flCriteriaScore )
{
CopyRuleFrom( pRule, iRule, pCustomSystem );
break;
}
}
}
}
// Set as a custom response system.
m_bCustomManagable = true;
AddInstancedResponseSystem( pszCustomName, pCustomSystem );
// pCustomSystem->DumpDictionary( pszCustomName );
return pCustomSystem;
}
void CDefaultResponseSystem::DestroyCustomResponseSystems()
{
ClearInstanced();
}
static CDefaultResponseSystem defaultresponsesytem;
IResponseSystem *g_pResponseSystem = &defaultresponsesytem;
CON_COMMAND( rr_reloadresponsesystems, "Reload all response system scripts." )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
defaultresponsesytem.ReloadAllResponseSystems();
#if defined( TF_DLL )
// This is kind of hacky, but I need to get it in for now!
if( g_pGameRules->IsMultiplayer() )
{
CMultiplayRules *pMultiplayRules = static_cast<CMultiplayRules*>( g_pGameRules );
pMultiplayRules->InitCustomResponseRulesDicts();
}
#endif
}
static short RESPONSESYSTEM_SAVE_RESTORE_VERSION = 1;
// note: this won't save/restore settings from instanced response systems. Could add that with a CDefSaveRestoreOps implementation if needed
//
class CDefaultResponseSystemSaveRestoreBlockHandler : public CDefSaveRestoreBlockHandler
{
public:
const char *GetBlockName()
{
return "ResponseSystem";
}
void WriteSaveHeaders( ISave *pSave )
{
pSave->WriteShort( &RESPONSESYSTEM_SAVE_RESTORE_VERSION );
}
void ReadRestoreHeaders( IRestore *pRestore )
{
// No reason why any future version shouldn't try to retain backward compatability. The default here is to not do so.
short version;
pRestore->ReadShort( &version );
m_fDoLoad = ( version == RESPONSESYSTEM_SAVE_RESTORE_VERSION );
}
void Save( ISave *pSave )
{
CDefaultResponseSystem& rs = defaultresponsesytem;
int count = rs.m_Responses.Count();
pSave->WriteInt( &count );
for ( int i = 0; i < count; ++i )
{
pSave->StartBlock( "ResponseGroup" );
pSave->WriteString( rs.m_Responses.GetElementName( i ) );
const ResponseGroup *group = &rs.m_Responses[ i ];
pSave->WriteAll( group );
short groupCount = group->group.Count();
pSave->WriteShort( &groupCount );
for ( int j = 0; j < groupCount; ++j )
{
const Response *response = &group->group[ j ];
pSave->StartBlock( "Response" );
pSave->WriteString( response->value );
pSave->WriteAll( response );
pSave->EndBlock();
}
pSave->EndBlock();
}
}
void Restore( IRestore *pRestore, bool createPlayers )
{
if ( !m_fDoLoad )
return;
CDefaultResponseSystem& rs = defaultresponsesytem;
int count = pRestore->ReadInt();
for ( int i = 0; i < count; ++i )
{
char szResponseGroupBlockName[SIZE_BLOCK_NAME_BUF];
pRestore->StartBlock( szResponseGroupBlockName );
if ( !Q_stricmp( szResponseGroupBlockName, "ResponseGroup" ) )
{
char groupname[ 256 ];
pRestore->ReadString( groupname, sizeof( groupname ), 0 );
// Try and find it
int idx = rs.m_Responses.Find( groupname );
if ( idx != rs.m_Responses.InvalidIndex() )
{
ResponseGroup *group = &rs.m_Responses[ idx ];
pRestore->ReadAll( group );
short groupCount = pRestore->ReadShort();
for ( int j = 0; j < groupCount; ++j )
{
char szResponseBlockName[SIZE_BLOCK_NAME_BUF];
char responsename[ 256 ];
pRestore->StartBlock( szResponseBlockName );
if ( !Q_stricmp( szResponseBlockName, "Response" ) )
{
pRestore->ReadString( responsename, sizeof( responsename ), 0 );
// Find it by name
int ri;
for ( ri = 0; ri < group->group.Count(); ++ri )
{
Response *response = &group->group[ ri ];
if ( !Q_stricmp( response->value, responsename ) )
{
break;
}
}
if ( ri < group->group.Count() )
{
Response *response = &group->group[ ri ];
pRestore->ReadAll( response );
}
}
pRestore->EndBlock();
}
}
}
pRestore->EndBlock();
}
}
private:
bool m_fDoLoad;
} g_DefaultResponseSystemSaveRestoreBlockHandler;
ISaveRestoreBlockHandler *GetDefaultResponseSystemSaveRestoreBlockHandler()
{
return &g_DefaultResponseSystemSaveRestoreBlockHandler;
}
//-----------------------------------------------------------------------------
// CResponseSystemSaveRestoreOps
//
// Purpose: Handles save and load for instanced response systems...
//
// BUGBUG: This will save the same response system to file multiple times for "shared" response systems and
// therefore it'll restore the same data onto the same pointer N times on reload (probably benign for now, but we could
// write code to save/restore the instanced ones by filename in the block handler above maybe?
//-----------------------------------------------------------------------------
class CResponseSystemSaveRestoreOps : public CDefSaveRestoreOps
{
public:
virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave )
{
CResponseSystem *pRS = *(CResponseSystem **)fieldInfo.pField;
if ( !pRS || pRS == &defaultresponsesytem )
return;
int count = pRS->m_Responses.Count();
pSave->WriteInt( &count );
for ( int i = 0; i < count; ++i )
{
pSave->StartBlock( "ResponseGroup" );
pSave->WriteString( pRS->m_Responses.GetElementName( i ) );
const ResponseGroup *group = &pRS->m_Responses[ i ];
pSave->WriteAll( group );
short groupCount = group->group.Count();
pSave->WriteShort( &groupCount );
for ( int j = 0; j < groupCount; ++j )
{
const Response *response = &group->group[ j ];
pSave->StartBlock( "Response" );
pSave->WriteString( response->value );
pSave->WriteAll( response );
pSave->EndBlock();
}
pSave->EndBlock();
}
}
virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore )
{
CResponseSystem *pRS = *(CResponseSystem **)fieldInfo.pField;
if ( !pRS || pRS == &defaultresponsesytem )
return;
int count = pRestore->ReadInt();
for ( int i = 0; i < count; ++i )
{
char szResponseGroupBlockName[SIZE_BLOCK_NAME_BUF];
pRestore->StartBlock( szResponseGroupBlockName );
if ( !Q_stricmp( szResponseGroupBlockName, "ResponseGroup" ) )
{
char groupname[ 256 ];
pRestore->ReadString( groupname, sizeof( groupname ), 0 );
// Try and find it
int idx = pRS->m_Responses.Find( groupname );
if ( idx != pRS->m_Responses.InvalidIndex() )
{
ResponseGroup *group = &pRS->m_Responses[ idx ];
pRestore->ReadAll( group );
short groupCount = pRestore->ReadShort();
for ( int j = 0; j < groupCount; ++j )
{
char szResponseBlockName[SIZE_BLOCK_NAME_BUF];
char responsename[ 256 ];
pRestore->StartBlock( szResponseBlockName );
if ( !Q_stricmp( szResponseBlockName, "Response" ) )
{
pRestore->ReadString( responsename, sizeof( responsename ), 0 );
// Find it by name
int ri;
for ( ri = 0; ri < group->group.Count(); ++ri )
{
Response *response = &group->group[ ri ];
if ( !Q_stricmp( response->value, responsename ) )
{
break;
}
}
if ( ri < group->group.Count() )
{
Response *response = &group->group[ ri ];
pRestore->ReadAll( response );
}
}
pRestore->EndBlock();
}
}
}
pRestore->EndBlock();
}
}
} g_ResponseSystemSaveRestoreOps;
ISaveRestoreOps *responseSystemSaveRestoreOps = &g_ResponseSystemSaveRestoreOps;
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CDefaultResponseSystem::Init()
{
/*
Warning( "sizeof( Response ) == %d\n", sizeof( Response ) );
Warning( "sizeof( ResponseGroup ) == %d\n", sizeof( ResponseGroup ) );
Warning( "sizeof( Criteria ) == %d\n", sizeof( Criteria ) );
Warning( "sizeof( AI_ResponseParams ) == %d\n", sizeof( AI_ResponseParams ) );
*/
const char *basescript = GetScriptFile();
LoadRuleSet( basescript );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDefaultResponseSystem::Shutdown()
{
// Wipe instanced versions
ClearInstanced();
// Clear outselves
Clear();
// IServerSystem chain
BaseClass::Shutdown();
}
//-----------------------------------------------------------------------------
// Purpose: Instance a custom response system
// Input : *scriptfile -
// Output : IResponseSystem
//-----------------------------------------------------------------------------
IResponseSystem *PrecacheCustomResponseSystem( const char *scriptfile )
{
return defaultresponsesytem.PrecacheCustomResponseSystem( scriptfile );
}
//-----------------------------------------------------------------------------
// Purpose: Instance a custom response system
// Input : *scriptfile -
// set -
// Output : IResponseSystem
//-----------------------------------------------------------------------------
IResponseSystem *BuildCustomResponseSystemGivenCriteria( const char *pszBaseFile, const char *pszCustomName, AI_CriteriaSet &criteriaSet, float flCriteriaScore )
{
return defaultresponsesytem.BuildCustomResponseSystemGivenCriteria( pszBaseFile, pszCustomName, criteriaSet, flCriteriaScore );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void DestroyCustomResponseSystems()
{
defaultresponsesytem.DestroyCustomResponseSystems();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CResponseSystem::DumpRules()
{
int c = m_Rules.Count();
int i;
for ( i = 0; i < c; i++ )
{
Msg("%s\n", m_Rules.GetElementName( i ) );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CResponseSystem::DumpDictionary( const char *pszName )
{
Msg( "\nDictionary: %s\n", pszName );
int nRuleCount = m_Rules.Count();
for ( int iRule = 0; iRule < nRuleCount; ++iRule )
{
Msg(" Rule %d: %s\n", iRule, m_Rules.GetElementName( iRule ) );
Rule *pRule = &m_Rules[iRule];
int nCriteriaCount = pRule->m_Criteria.Count();
for( int iCriteria = 0; iCriteria < nCriteriaCount; ++iCriteria )
{
int iRuleCriteria = pRule->m_Criteria[iCriteria];
Criteria *pCriteria = &m_Criteria[iRuleCriteria];
Msg( " Criteria %d: %s %s\n", iCriteria, pCriteria->name, pCriteria->value );
}
int nResponseGroupCount = pRule->m_Responses.Count();
for ( int iResponseGroup = 0; iResponseGroup < nResponseGroupCount; ++iResponseGroup )
{
int iRuleResponse = pRule->m_Responses[iResponseGroup];
ResponseGroup *pResponseGroup = &m_Responses[iRuleResponse];
Msg( " ResponseGroup %d: %s\n", iResponseGroup, m_Responses.GetElementName( iRuleResponse ) );
int nResponseCount = pResponseGroup->group.Count();
for ( int iResponse = 0; iResponse < nResponseCount; ++iResponse )
{
Response *pResponse = &pResponseGroup->group[iResponse];
Msg( " Response %d: %s\n", iResponse, pResponse->value );
}
}
}
}