452 lines
16 KiB
C++
452 lines
16 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef AI_SPEECH_H
|
|
#define AI_SPEECH_H
|
|
|
|
#include "utlmap.h"
|
|
|
|
#include "AI_ResponseSystem.h"
|
|
#include "soundflags.h"
|
|
#include "utldict.h"
|
|
|
|
#if defined(_WIN32)
|
|
#pragma once
|
|
#endif
|
|
|
|
class KeyValues;
|
|
class AI_CriteriaSet;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Used to share a global resource or prevent a system stepping on
|
|
// own toes.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CAI_TimedSemaphore {
|
|
public:
|
|
CAI_TimedSemaphore() : m_ReleaseTime(0) { m_hCurrentTalker = NULL; }
|
|
|
|
void Acquire(float time, CBaseEntity *pTalker) {
|
|
m_ReleaseTime = gpGlobals->curtime + time;
|
|
m_hCurrentTalker = pTalker;
|
|
}
|
|
void Release() {
|
|
m_ReleaseTime = 0;
|
|
m_hCurrentTalker = NULL;
|
|
}
|
|
|
|
// Current owner of the semaphore is always allowed to talk
|
|
bool IsAvailable(CBaseEntity *pTalker) const {
|
|
return ((gpGlobals->curtime > m_ReleaseTime) ||
|
|
(m_hCurrentTalker == pTalker));
|
|
}
|
|
float GetReleaseTime() const { return m_ReleaseTime; }
|
|
|
|
CBaseEntity *GetOwner() { return m_hCurrentTalker; }
|
|
|
|
private:
|
|
float m_ReleaseTime;
|
|
EHANDLE m_hCurrentTalker;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
extern CAI_TimedSemaphore g_AIFriendliesTalkSemaphore;
|
|
extern CAI_TimedSemaphore g_AIFoesTalkSemaphore;
|
|
|
|
#define GetSpeechSemaphore(pNpc) \
|
|
(((pNpc)->IsPlayerAlly()) ? &g_AIFriendliesTalkSemaphore \
|
|
: &g_AIFoesTalkSemaphore)
|
|
//-----------------------------------------------------------------------------
|
|
// Basic speech system types
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-------------------------------------
|
|
// Constants
|
|
|
|
const float AIS_DEF_MIN_DELAY =
|
|
2.8; // Minimum amount of time an NPCs will wait after someone has spoken
|
|
// before considering speaking again
|
|
const float AIS_DEF_MAX_DELAY =
|
|
3.2; // Maximum amount of time an NPCs will wait after someone has spoken
|
|
// before considering speaking again
|
|
const float AIS_NO_DELAY = 0;
|
|
const soundlevel_t AIS_DEF_SNDLVL = SNDLVL_TALKING;
|
|
#define AI_NULL_CONCEPT NULL
|
|
|
|
#define AI_NULL_SENTENCE NULL
|
|
|
|
// Sentence prefix constants
|
|
#define AI_SP_SPECIFIC_SENTENCE '!'
|
|
#define AI_SP_WAVFILE '^'
|
|
#define AI_SP_SCENE_GROUP '='
|
|
#define AI_SP_SPECIFIC_SCENE '?'
|
|
|
|
#define AI_SPECIFIC_SENTENCE(str_constant) "!" str_constant
|
|
#define AI_WAVFILE(str_constant) "^" str_constant
|
|
// @Note (toml 09-12-02): as scene groups are not currently implemented, the
|
|
// string is a semi-colon delimited list
|
|
#define AI_SCENE_GROUP(str_constant) "=" str_constant
|
|
#define AI_SPECIFIC_SCENE(str_constant) "?" str_constant
|
|
|
|
// Designer overriding modifiers
|
|
#define AI_SPECIFIC_SCENE_MODIFIER "scene:"
|
|
|
|
//-------------------------------------
|
|
|
|
//-------------------------------------
|
|
// An id that represents the core meaning of a spoken phrase,
|
|
// eventually to be mapped to a sentence group or scene
|
|
|
|
typedef const char *AIConcept_t;
|
|
|
|
inline bool CompareConcepts(AIConcept_t c1, AIConcept_t c2) {
|
|
return ((void *)c1 == (void *)c2 || (c1 && c2 && Q_stricmp(c1, c2) == 0));
|
|
}
|
|
|
|
//-------------------------------------
|
|
// Specifies and stores the base timing and attentuation values for concepts
|
|
//
|
|
class AI_Response;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CAI_Expresser
|
|
//
|
|
// Purpose: Provides the functionality of going from abstract concept ("hello")
|
|
// to specific sentence/scene/wave
|
|
//
|
|
|
|
//-------------------------------------
|
|
// Sink supports behavior control and receives notifications of internal events
|
|
|
|
class CAI_ExpresserSink {
|
|
public:
|
|
virtual void OnSpokeConcept(AIConcept_t concept, AI_Response *response){};
|
|
virtual void OnStartSpeaking() {}
|
|
virtual bool UseSemaphore() { return true; }
|
|
};
|
|
|
|
struct ConceptHistory_t {
|
|
DECLARE_SIMPLE_DATADESC();
|
|
|
|
ConceptHistory_t(float timeSpoken = -1)
|
|
: timeSpoken(timeSpoken), response(NULL) {}
|
|
|
|
ConceptHistory_t(const ConceptHistory_t &src);
|
|
ConceptHistory_t &operator=(const ConceptHistory_t &src);
|
|
|
|
~ConceptHistory_t();
|
|
|
|
float timeSpoken;
|
|
AI_Response *response;
|
|
};
|
|
//-------------------------------------
|
|
|
|
class CAI_Expresser : public IResponseFilter {
|
|
public:
|
|
CAI_Expresser(CBaseFlex *pOuter = NULL);
|
|
~CAI_Expresser();
|
|
|
|
// --------------------------------
|
|
|
|
bool Connect(CAI_ExpresserSink *pSink) {
|
|
m_pSink = pSink;
|
|
return true;
|
|
}
|
|
bool Disconnect(CAI_ExpresserSink *pSink) {
|
|
m_pSink = NULL;
|
|
return true;
|
|
}
|
|
|
|
void TestAllResponses();
|
|
|
|
// --------------------------------
|
|
|
|
bool Speak(AIConcept_t concept, const char *modifiers = NULL,
|
|
char *pszOutResponseChosen = NULL, size_t bufsize = 0,
|
|
IRecipientFilter *filter = NULL);
|
|
|
|
// These two methods allow looking up a response and dispatching it to be
|
|
// two different steps
|
|
bool SpeakFindResponse(AI_Response &response, AIConcept_t concept,
|
|
const char *modifiers = NULL);
|
|
bool SpeakDispatchResponse(AIConcept_t concept, AI_Response &response,
|
|
IRecipientFilter *filter = NULL);
|
|
float GetResponseDuration(AI_Response &response);
|
|
|
|
virtual int SpeakRawSentence(const char *pszSentence, float delay,
|
|
float volume = VOL_NORM,
|
|
soundlevel_t soundlevel = SNDLVL_TALKING,
|
|
CBaseEntity *pListener = NULL);
|
|
|
|
bool SemaphoreIsAvailable(CBaseEntity *pTalker);
|
|
float GetSemaphoreAvailableTime(CBaseEntity *pTalker);
|
|
|
|
// --------------------------------
|
|
|
|
virtual bool IsSpeaking();
|
|
bool CanSpeak();
|
|
bool CanSpeakAfterMyself();
|
|
float GetTimeSpeechComplete() const { return m_flStopTalkTime; }
|
|
void BlockSpeechUntil(float time);
|
|
|
|
// --------------------------------
|
|
|
|
bool CanSpeakConcept(AIConcept_t concept);
|
|
bool SpokeConcept(AIConcept_t concept);
|
|
float GetTimeSpokeConcept(AIConcept_t concept); // returns -1 if never
|
|
void SetSpokeConcept(AIConcept_t concept, AI_Response *response,
|
|
bool bCallback = true);
|
|
void ClearSpokeConcept(AIConcept_t concept);
|
|
|
|
// --------------------------------
|
|
|
|
void SetVoicePitch(int voicePitch) { m_voicePitch = voicePitch; }
|
|
int GetVoicePitch() const;
|
|
|
|
void NoteSpeaking(float duration, float delay = 0);
|
|
|
|
// Force the NPC to release the semaphore & clear next speech time
|
|
void ForceNotSpeaking(void);
|
|
|
|
protected:
|
|
CAI_TimedSemaphore *GetMySpeechSemaphore(CBaseEntity *pNpc);
|
|
|
|
bool SpeakRawScene(const char *pszScene, float delay, AI_Response *response,
|
|
IRecipientFilter *filter = NULL);
|
|
// This will create a fake .vcd/CChoreoScene to wrap the sound to be played
|
|
bool SpeakAutoGeneratedScene(char const *soundname, float delay);
|
|
|
|
void DumpHistories();
|
|
|
|
void SpeechMsg(CBaseEntity *pFlex,
|
|
PRINTF_FORMAT_STRING const char *pszFormat, ...);
|
|
|
|
// --------------------------------
|
|
|
|
CAI_ExpresserSink *GetSink() { return m_pSink; }
|
|
|
|
private:
|
|
// --------------------------------
|
|
|
|
virtual bool IsValidResponse(ResponseType_t type, const char *pszValue);
|
|
|
|
// --------------------------------
|
|
|
|
CAI_ExpresserSink *m_pSink;
|
|
|
|
// --------------------------------
|
|
//
|
|
// Speech concept data structures
|
|
//
|
|
|
|
CUtlDict<ConceptHistory_t, int> m_ConceptHistories;
|
|
|
|
// --------------------------------
|
|
//
|
|
// Speaking states
|
|
//
|
|
|
|
float m_flStopTalkTime; // when in the future that I'll be done saying this
|
|
// sentence.
|
|
float m_flStopTalkTimeWithoutDelay; // same as the above, but minus the
|
|
// delay before other people can speak
|
|
float m_flBlockedTalkTime;
|
|
int m_voicePitch; // pitch of voice for this head
|
|
float m_flLastTimeAcceptedSpeak; // because speech may not be blocked until
|
|
// NoteSpeaking called by scene ent, this
|
|
// handles in-think blocking
|
|
|
|
DECLARE_SIMPLE_DATADESC();
|
|
|
|
// --------------------------------
|
|
//
|
|
public:
|
|
virtual void SetOuter(CBaseFlex *pOuter) { m_pOuter = pOuter; }
|
|
|
|
CBaseFlex *GetOuter() { return m_pOuter; }
|
|
const CBaseFlex *GetOuter() const { return m_pOuter; }
|
|
|
|
private:
|
|
CHandle<CBaseFlex> m_pOuter;
|
|
};
|
|
|
|
class CMultiplayer_Expresser : public CAI_Expresser {
|
|
public:
|
|
CMultiplayer_Expresser(CBaseFlex *pOuter = NULL);
|
|
//~CMultiplayer_Expresser();
|
|
|
|
virtual bool IsSpeaking();
|
|
|
|
void AllowMultipleScenes();
|
|
void DisallowMultipleScenes();
|
|
|
|
private:
|
|
bool m_bAllowMultipleScenes;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// An NPC base class to assist a branch of the inheritance graph
|
|
// in utilizing CAI_Expresser
|
|
//
|
|
|
|
template <class BASE_NPC>
|
|
class CAI_ExpresserHost : public BASE_NPC, protected CAI_ExpresserSink {
|
|
DECLARE_CLASS_NOFRIEND(CAI_ExpresserHost, BASE_NPC);
|
|
|
|
public:
|
|
virtual void NoteSpeaking(float duration, float delay);
|
|
|
|
virtual bool Speak(AIConcept_t concept, const char *modifiers = NULL,
|
|
char *pszOutResponseChosen = NULL, size_t bufsize = 0,
|
|
IRecipientFilter *filter = NULL);
|
|
|
|
// These two methods allow looking up a response and dispatching it to be
|
|
// two different steps
|
|
bool SpeakFindResponse(AI_Response &response, AIConcept_t concept,
|
|
const char *modifiers = NULL);
|
|
bool SpeakDispatchResponse(AIConcept_t concept, AI_Response &response);
|
|
virtual void PostSpeakDispatchResponse(AIConcept_t concept,
|
|
AI_Response &response) {
|
|
return;
|
|
}
|
|
float GetResponseDuration(AI_Response &response);
|
|
|
|
float GetTimeSpeechComplete() const {
|
|
return this->GetExpresser()->GetTimeSpeechComplete();
|
|
}
|
|
|
|
bool IsSpeaking() { return this->GetExpresser()->IsSpeaking(); }
|
|
bool CanSpeak() { return this->GetExpresser()->CanSpeak(); }
|
|
bool CanSpeakAfterMyself() {
|
|
return this->GetExpresser()->CanSpeakAfterMyself();
|
|
}
|
|
|
|
void SetSpokeConcept(AIConcept_t concept, AI_Response *response,
|
|
bool bCallback = true) {
|
|
this->GetExpresser()->SetSpokeConcept(concept, response, bCallback);
|
|
}
|
|
float GetTimeSpokeConcept(AIConcept_t concept) {
|
|
return this->GetExpresser()->GetTimeSpokeConcept(concept);
|
|
}
|
|
bool SpokeConcept(AIConcept_t concept) {
|
|
return this->GetExpresser()->SpokeConcept(concept);
|
|
}
|
|
|
|
protected:
|
|
int PlaySentence(const char *pszSentence, float delay,
|
|
float volume = VOL_NORM,
|
|
soundlevel_t soundlevel = SNDLVL_TALKING,
|
|
CBaseEntity *pListener = NULL);
|
|
virtual void ModifyOrAppendCriteria(AI_CriteriaSet &set);
|
|
|
|
virtual IResponseSystem *GetResponseSystem();
|
|
// Override of base entity response input handler
|
|
virtual void DispatchResponse(const char *conceptName);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
template <class BASE_NPC>
|
|
inline void CAI_ExpresserHost<BASE_NPC>::NoteSpeaking(float duration,
|
|
float delay) {
|
|
this->GetExpresser()->NoteSpeaking(duration, delay);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
template <class BASE_NPC>
|
|
inline bool CAI_ExpresserHost<BASE_NPC>::Speak(
|
|
AIConcept_t concept, const char *modifiers /*= NULL*/,
|
|
char *pszOutResponseChosen /*=NULL*/, size_t bufsize /* = 0 */,
|
|
IRecipientFilter *filter /* = NULL */) {
|
|
AssertOnce(this->GetExpresser()->GetOuter() == this);
|
|
return this->GetExpresser()->Speak(concept, modifiers, pszOutResponseChosen,
|
|
bufsize, filter);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
template <class BASE_NPC>
|
|
inline int CAI_ExpresserHost<BASE_NPC>::PlaySentence(const char *pszSentence,
|
|
float delay, float volume,
|
|
soundlevel_t soundlevel,
|
|
CBaseEntity *pListener) {
|
|
return this->GetExpresser()->SpeakRawSentence(pszSentence, delay, volume,
|
|
soundlevel, pListener);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
extern void CAI_ExpresserHost_NPC_DoModifyOrAppendCriteria(
|
|
CAI_BaseNPC *pSpeaker, AI_CriteriaSet &criteriaSet);
|
|
|
|
template <class BASE_NPC>
|
|
inline void CAI_ExpresserHost<BASE_NPC>::ModifyOrAppendCriteria(
|
|
AI_CriteriaSet &criteriaSet) {
|
|
BaseClass::ModifyOrAppendCriteria(criteriaSet);
|
|
|
|
if (this->MyNPCPointer()) {
|
|
CAI_ExpresserHost_NPC_DoModifyOrAppendCriteria(this->MyNPCPointer(),
|
|
criteriaSet);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
template <class BASE_NPC>
|
|
inline IResponseSystem *CAI_ExpresserHost<BASE_NPC>::GetResponseSystem() {
|
|
extern IResponseSystem *g_pResponseSystem;
|
|
// Expressive NPC's use the general response system
|
|
return g_pResponseSystem;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
template <class BASE_NPC>
|
|
inline bool CAI_ExpresserHost<BASE_NPC>::SpeakFindResponse(
|
|
AI_Response &response, AIConcept_t concept,
|
|
const char *modifiers /*= NULL*/) {
|
|
return this->GetExpresser()->SpeakFindResponse(response, concept,
|
|
modifiers);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
template <class BASE_NPC>
|
|
inline bool CAI_ExpresserHost<BASE_NPC>::SpeakDispatchResponse(
|
|
AIConcept_t concept, AI_Response &response) {
|
|
if (this->GetExpresser()->SpeakDispatchResponse(concept, response)) {
|
|
PostSpeakDispatchResponse(concept, response);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
template <class BASE_NPC>
|
|
inline float CAI_ExpresserHost<BASE_NPC>::GetResponseDuration(
|
|
AI_Response &response) {
|
|
return this->GetExpresser()->GetResponseDuration(response);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Override of base entity response input handler
|
|
//-----------------------------------------------------------------------------
|
|
template <class BASE_NPC>
|
|
inline void CAI_ExpresserHost<BASE_NPC>::DispatchResponse(
|
|
const char *conceptName) {
|
|
Speak((AIConcept_t)conceptName);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#endif // AI_SPEECH_H
|