tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/Combat/conversationmgr.cpp

1209 lines
31 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Combat *
* *
* $Archive:: /Commando/Code/Combat/conversationmgr.cpp $*
* *
* Author:: Patrick Smith *
* *
* $Modtime:: 1/15/02 9:37p $*
* *
* $Revision:: 24 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "conversationmgr.h"
#include "combatchunkid.h"
#include "chunkio.h"
#include "vector3.h"
#include "pscene.h"
#include "physicalgameobj.h"
#include "aabox.h"
#include "conversation.h"
#include "wwmath.h"
#include "soldierobserver.h"
#include "playertype.h"
#include "activeconversation.h"
#include "phys.h"
#include "string_ids.h"
#include "oratortypes.h"
////////////////////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////////////////////
enum
{
CHUNKID_VARIABLES = 0x08090315,
CHUNKID_OLD_CONVERSATION,
CHUNKID_ACTIVE_CONVERSATION,
CHUNKID_CONVERSATION_CATEGORY,
CHUNKID_CONVERSATION
};
enum
{
VARID_NEXT_ACTIVE_CONVERSATION_ID = 0,
XXX_VARID_NEXT_GLOBAL_CONVERSATION_ID,
VARID_NEXT_LEVEL_CONVERSATION_ID,
VARID_NEXT_GLOBAL_CONVERSATION_ID,
};
static const float BUDDY_LOCATE_CX = 7;
static const float BUDDY_LOCATE_CY = 7;
static const float BUDDY_LOCATE_CZ = 3;
static const int ACTIVE_CONVERSATION_START_ID = 1000;
static const int LEVEL_CONVERSATION_START_ID = 1;
static const int GLOBAL_CONVERSATION_START_ID = 100000;
////////////////////////////////////////////////////////////////
// Static member initialization
////////////////////////////////////////////////////////////////
CONVERSATION_LIST ConversationMgrClass::ConversationList[CATEGORY_MAX];
ACTIVE_CONVERSATION_LIST ConversationMgrClass::ActiveConversationList;
int ConversationMgrClass::NextActiveConversationID = ACTIVE_CONVERSATION_START_ID;
int ConversationMgrClass::NextGlobalConversationID = GLOBAL_CONVERSATION_START_ID;
int ConversationMgrClass::NextLevelConversationID = LEVEL_CONVERSATION_START_ID;
ConversationMgrClass::CATEGORY ConversationMgrClass::SaveCategoryID = CATEGORY_GLOBAL;
bool ConversationMgrClass::DisplayEmotIcons = false;
////////////////////////////////////////////////////////////////
// Singleton instance
////////////////////////////////////////////////////////////////
ConversationMgrClass _ConversationMgrSaveLoad;
////////////////////////////////////////////////////////////////
//
// ConversationMgrClass
//
////////////////////////////////////////////////////////////////
ConversationMgrClass::ConversationMgrClass (void)
{
return ;
}
////////////////////////////////////////////////////////////////
//
// ~ConversationMgrClass
//
////////////////////////////////////////////////////////////////
ConversationMgrClass::~ConversationMgrClass (void)
{
Reset ();
return ;
}
////////////////////////////////////////////////////////////////
//
// Reset_Conversations
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Reset_Conversations (int category_index, bool reset_start_id)
{
if (reset_start_id && category_index == CATEGORY_LEVEL) {
NextLevelConversationID = LEVEL_CONVERSATION_START_ID;
}
int count = ConversationList[category_index].Count ();
//
// Release our hold on all the conversations in this category
//
for (int index = 0; index < count; index ++) {
ConversationClass *conversation = ConversationList[category_index][index];
REF_PTR_RELEASE (conversation);
}
ConversationList[category_index].Delete_All ();
return ;
}
////////////////////////////////////////////////////////////////
//
// Reset_All_Other_Conversations
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Reset_All_Other_Conversations (ActiveConversationClass *active_conversation)
{
NextActiveConversationID = active_conversation->Get_ID () + 1;
//
// Release our hold on all the other conversations
//
int count = ActiveConversationList.Count ();
for (int index = 0; index < count; index ++) {
ActiveConversationClass *conversation = ActiveConversationList[index];
if (conversation != NULL && conversation != active_conversation) {
conversation->Stop_Conversation (ACTION_COMPLETE_CONVERSATION_INTERRUPTED);
REF_PTR_RELEASE (conversation);
}
}
ActiveConversationList.Delete_All ();
//
// Add this conversation back into the list
//
ActiveConversationList.Add (active_conversation);
return ;
}
////////////////////////////////////////////////////////////////
//
// Reset_Active_Conversations
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Reset_Active_Conversations (void)
{
NextActiveConversationID = ACTIVE_CONVERSATION_START_ID;
//
// Release our hold on all the active conversations
//
while (ActiveConversationList.Count () > 0) {
ActiveConversationClass *active_conversation = ActiveConversationList[0];
ActiveConversationList.Delete (0);
if (active_conversation != NULL) {
active_conversation->Stop_Conversation (ACTION_COMPLETE_CONVERSATION_INTERRUPTED);
}
REF_PTR_RELEASE (active_conversation);
}
return ;
}
////////////////////////////////////////////////////////////////
//
// Reset
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Reset (void)
{
//
// Release our hold on all the active conversations
//
Reset_Active_Conversations ();
//
// Release our hold on all the conversations
//
for (int cat_index = 0; cat_index < CATEGORY_MAX; cat_index ++) {
Reset_Conversations (cat_index);
}
return ;
}
////////////////////////////////////////////////////////////////
//
// Chunk_ID
//
////////////////////////////////////////////////////////////////
uint32
ConversationMgrClass::Chunk_ID (void) const
{
return CHUNKID_CONVERSATION_MGR;
}
////////////////////////////////////////////////////////////////
//
// Save
//
////////////////////////////////////////////////////////////////
bool
ConversationMgrClass::Save (ChunkSaveClass &csave)
{
csave.Begin_Chunk (CHUNKID_VARIABLES);
WRITE_MICRO_CHUNK (csave, VARID_NEXT_ACTIVE_CONVERSATION_ID, NextActiveConversationID);
if (SaveCategoryID == CATEGORY_GLOBAL) {
WRITE_MICRO_CHUNK (csave, VARID_NEXT_GLOBAL_CONVERSATION_ID, NextGlobalConversationID);
} else {
WRITE_MICRO_CHUNK (csave, VARID_NEXT_LEVEL_CONVERSATION_ID, NextLevelConversationID);
}
csave.End_Chunk ();
//
// Save the conversations in the current category
//
csave.Begin_Chunk (CHUNKID_CONVERSATION_CATEGORY);
//
// Save the category ID
//
csave.Write (&SaveCategoryID, sizeof (SaveCategoryID));
//
// Save each conversation in this category
//
int count = ConversationList[SaveCategoryID].Count ();
for (int index = 0; index < count; index ++) {
ConversationClass *conversation = ConversationList[SaveCategoryID][index];
if (conversation != NULL) {
csave.Begin_Chunk (CHUNKID_CONVERSATION);
conversation->Save (csave);
csave.End_Chunk ();
}
}
csave.End_Chunk ();
//
// Save each active conversation to its own chunk
//
count = ActiveConversationList.Count ();
for (index = 0; index < count; index ++) {
ActiveConversationClass *active_conversation = ActiveConversationList[index];
if (active_conversation != NULL) {
csave.Begin_Chunk (CHUNKID_ACTIVE_CONVERSATION);
active_conversation->Save (csave);
csave.End_Chunk ();
}
}
return true;
}
////////////////////////////////////////////////////////////////
//
// Load_Conversations
//
////////////////////////////////////////////////////////////////
bool
ConversationMgrClass::Load_Conversations (ChunkLoadClass &cload, int category_id)
{
while (cload.Open_Chunk ()) {
switch (cload.Cur_Chunk_ID ()) {
case CHUNKID_CONVERSATION:
{
//
// Create a new object and its state from the chunk
//
ConversationClass *conversation = new ConversationClass;
SET_REF_OWNER( conversation );
conversation->Load (cload);
//
// Debug check to ensure we've got the correct cateogry
//
WWASSERT (conversation->Get_Category_ID () == category_id);
//
// Add this conversation to our list
//
Add_Conversation (conversation);
REF_PTR_RELEASE (conversation);
}
break;
}
cload.Close_Chunk ();
}
return true;
}
////////////////////////////////////////////////////////////////
//
// Load
//
////////////////////////////////////////////////////////////////
bool
ConversationMgrClass::Load (ChunkLoadClass &cload)
{
int old_style_conv_count = 0;
//
// Remove all currently active conversations
//
Reset_Active_Conversations ();
while (cload.Open_Chunk ()) {
switch (cload.Cur_Chunk_ID ()) {
case CHUNKID_ACTIVE_CONVERSATION:
{
//
// Create a new object and its state from the chunk
//
ActiveConversationClass *active_conversation = new ActiveConversationClass;
active_conversation->Load (cload);
//
// Add this new active conversation to our list
//
ActiveConversationList.Add (active_conversation);
}
break;
case CHUNKID_CONVERSATION_CATEGORY:
{
int category_id = 0;
cload.Read (&category_id, sizeof (category_id));
//
// Remove all conversations in this category
//
Reset_Conversations (category_id);
//
// Load all the conversations in this category
//
Load_Conversations (cload, category_id);
}
break;
case CHUNKID_OLD_CONVERSATION:
{
//
// Reset the list of level conversations if this
// the first one loaded
//
if (old_style_conv_count == 0) {
Reset_Conversations (CATEGORY_LEVEL);
}
old_style_conv_count ++;
//
// Create a new object and its state from the chunk
//
ConversationClass *conversation = new ConversationClass;
conversation->Load (cload);
conversation->Set_Category_ID (CATEGORY_LEVEL);
//
// Add this conversation to our list
//
Add_Conversation (conversation);
REF_PTR_RELEASE (conversation);
}
break;
case CHUNKID_VARIABLES:
Load_Variables (cload);
break;
}
cload.Close_Chunk ();
}
return true;
}
///////////////////////////////////////////////////////////////////////
//
// Load_Variables
//
///////////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Load_Variables (ChunkLoadClass &cload)
{
//
// Loop through all the microchunks that define the variables
//
while (cload.Open_Micro_Chunk ()) {
switch (cload.Cur_Micro_Chunk_ID ()) {
READ_MICRO_CHUNK (cload, VARID_NEXT_ACTIVE_CONVERSATION_ID, NextActiveConversationID);
READ_MICRO_CHUNK (cload, VARID_NEXT_GLOBAL_CONVERSATION_ID, NextGlobalConversationID);
READ_MICRO_CHUNK (cload, VARID_NEXT_LEVEL_CONVERSATION_ID, NextLevelConversationID);
}
cload.Close_Micro_Chunk ();
}
return ;
}
////////////////////////////////////////////////////////////////
//
// Build_Buddy_List
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Build_Buddy_List
(
PhysicalGameObj * orator,
DynamicVectorClass<PhysicalGameObj *> & buddy_list,
bool include_orator
)
{
//
// Build a box, centered around the orator, that we can use to
// collect other 'friendly' orators in the area
//
Vector3 orator_pos (0, 0, 0);
orator->Get_Position (&orator_pos);
orator_pos.Z += BUDDY_LOCATE_CZ / 3.0F;
AABoxClass box (orator_pos, Vector3 (BUDDY_LOCATE_CX, BUDDY_LOCATE_CY, BUDDY_LOCATE_CZ));
//
// Collect all the dynamic objects in this box
//
NonRefPhysListClass obj_list;
PhysicsSceneClass::Get_Instance ()->Collect_Objects (box, false, true, &obj_list);
//
// Loop over all the collected objects
//
NonRefPhysListIterator it (&obj_list);
for (it.First(); !it.Is_Done(); it.Next()) {
PhysClass *phys_obj = it.Peek_Obj ();
//
// Check to ensure this game object is a orator
//
CombatPhysObserverClass *phys_observer = reinterpret_cast<CombatPhysObserverClass *>(phys_obj->Get_Observer ());
if (phys_observer != NULL) {
PhysicalGameObj *game_obj = phys_observer->As_PhysicalGameObj();
if (game_obj != NULL) {
//
// Check to make sure we found a orator who can participate
// in this conversation
//
PhysicalGameObj *other_orator = game_obj->As_PhysicalGameObj ();
if (other_orator != NULL && (include_orator || other_orator != orator)) {
//
// Can this orator hold a conversation?
//
if ( other_orator->Is_In_Conversation () == false &&
other_orator->Are_Innate_Conversations_Enabled ())
{
buddy_list.Add (other_orator);
}
}
}
}
}
return ;
}
////////////////////////////////////////////////////////////////
//
// Find_Active_Conversation
//
////////////////////////////////////////////////////////////////
ActiveConversationClass *
ConversationMgrClass::Find_Active_Conversation (int id)
{
ActiveConversationClass *conversation = NULL;
//
// Loop over each entry in the active conversation list, looking for one with
// the supplied identifier.
//
for (int index = 0; index < ActiveConversationList.Count (); index ++) {
ActiveConversationClass *curr_conversation = ActiveConversationList[index];
//
// Is this the conversation we were looking for?
//
if (curr_conversation != NULL && curr_conversation->Get_ID () == id) {
conversation = curr_conversation;
conversation->Add_Ref ();
break;
}
}
return conversation;
}
////////////////////////////////////////////////////////////////
//
// Find_Conversation
//
////////////////////////////////////////////////////////////////
ConversationClass *
ConversationMgrClass::Find_Conversation (const char *conversation_name)
{
ConversationClass *conversation = NULL;
//
// Loop over all the conversation categories
//
for (int cat_index = 0; cat_index < CATEGORY_MAX; cat_index ++) {
//
// Loop over each conversation in this category, looking for one with
// the requested name.
//
int count = ConversationList[cat_index].Count ();
for (int index = 0; index < count; index ++) {
ConversationClass *curr_conversation = ConversationList[cat_index][index];
//
// Is this the conversation we were looking for?
//
if ( curr_conversation != NULL &&
::strcmpi (curr_conversation->Get_Name (), conversation_name) == 0)
{
conversation = curr_conversation;
conversation->Add_Ref ();
break;
}
}
}
return conversation;
}
////////////////////////////////////////////////////////////////
//
// Find_Conversation
//
////////////////////////////////////////////////////////////////
ConversationClass *
ConversationMgrClass::Find_Conversation (int conversation_id)
{
ConversationClass *conversation = NULL;
//
// Loop over all the conversation categories
//
for (int cat_index = 0; cat_index < CATEGORY_MAX; cat_index ++) {
//
// Loop over each conversation in this category, looking for one with
// the requested name.
//
int count = ConversationList[cat_index].Count ();
for (int index = 0; index < count; index ++) {
ConversationClass *curr_conversation = ConversationList[cat_index][index];
//
// Is this the conversation we were looking for?
//
if ( (curr_conversation != NULL) &&
(curr_conversation->Get_ID () == conversation_id))
{
conversation = curr_conversation;
conversation->Add_Ref ();
break;
}
}
}
return conversation;
}
////////////////////////////////////////////////////////////////
//
// Start_Conversation
//
////////////////////////////////////////////////////////////////
ActiveConversationClass *
ConversationMgrClass::Start_Conversation (PhysicalGameObj *orator, int conversation_id, bool force)
{
ActiveConversationClass *active_conversation = NULL;
//
// Try to find the requested conversation
//
ConversationClass *conversation = Find_Conversation (conversation_id);
if (conversation != NULL) {
//
// Start the conversation
//
active_conversation = Start_Conversation (orator, conversation, force);
REF_PTR_RELEASE (conversation);
}
//
// Return a pointer to the conversation. Note: This object has
// an extra ref count on it, its the caller's responsibility to release
// this ref count when they are finished with it.
//
return active_conversation;
}
////////////////////////////////////////////////////////////////
//
// Start_Conversation
//
////////////////////////////////////////////////////////////////
ActiveConversationClass *
ConversationMgrClass::Start_Conversation (PhysicalGameObj *orator, const char *conversation_name, bool force)
{
ActiveConversationClass *active_conversation = NULL;
//
// Try to find the requested conversation
//
ConversationClass *conversation = Find_Conversation (conversation_name);
if (conversation != NULL) {
//
// Start the conversation
//
active_conversation = Start_Conversation (orator, conversation, force);
REF_PTR_RELEASE (conversation);
}
//
// Return a pointer to the conversation. Note: This object has
// an extra ref count on it, its the caller's responsibility to release
// this ref count when they are finished with it.
//
return active_conversation;
}
////////////////////////////////////////////////////////////////
//
// Start_Conversation
//
////////////////////////////////////////////////////////////////
ActiveConversationClass *
ConversationMgrClass::Start_Conversation (PhysicalGameObj *orator, ConversationClass *conversation, bool force)
{
//
// Build a list of potential participants in the conversation
//
DynamicVectorClass<PhysicalGameObj *> buddy_list;
Build_Buddy_List (orator, buddy_list, false);
//
// If we have enough people to hold this conversation, then activate
// the new conversation.
//
ActiveConversationClass *active_conversation = NULL;
if (Test_Conversation (orator, conversation, buddy_list, force)) {
active_conversation = Create_New_Conversation (conversation, buddy_list);
}
//
// Return a pointer to the conversation. Note: This object has
// an extra ref count on it, its the caller's responsibility to release
// this ref count when they are finished with it.
//
return active_conversation;
}
////////////////////////////////////////////////////////////////
//
// Create_New_Conversation
//
////////////////////////////////////////////////////////////////
ActiveConversationClass *
ConversationMgrClass::Create_New_Conversation
(
ConversationClass * conversation,
DynamicVectorClass<PhysicalGameObj *> & buddy_list
)
{
ActiveConversationClass *active_conversation = new ActiveConversationClass;
active_conversation->Set_Conversation (conversation);
//
// Add the participants to the active conversation.
// Note: Its assumed that the buddy_list is in the correct
// order for this conversation.
//
int count = conversation->Get_Orator_Count ();
for (int index = 0; index < count; index ++) {
active_conversation->Add_Orator (buddy_list[index]);
}
//
// Add it to our active conversation list
//
active_conversation->Set_ID (NextActiveConversationID ++);
ActiveConversationList.Add (active_conversation);
//
// Initialize the conversation
//
active_conversation->Start_Conversation ();
//
// Increment the reference count on the conversation and
// return it to the caller.
//
active_conversation->Add_Ref ();
return active_conversation;
}
////////////////////////////////////////////////////////////////
//
// Start_Conversation
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Start_Conversation (PhysicalGameObj *orator)
{
//
// Build a list of potential participants in the conversation
//
DynamicVectorClass<PhysicalGameObj *> available_buddy_list;
Build_Buddy_List (orator, available_buddy_list, false);
//
// Try to find a conversation that this list of orators can have
//
DynamicVectorClass<PhysicalGameObj *> orator_list;
ConversationClass *conversation = Pick_Conversation (orator, available_buddy_list, orator_list);
if (conversation != NULL) {
ActiveConversationClass *active_conversation = Create_New_Conversation (conversation, orator_list);
REF_PTR_RELEASE (active_conversation);
}
return ;
}
////////////////////////////////////////////////////////////////
//
// Test_Conversation
//
////////////////////////////////////////////////////////////////
bool
ConversationMgrClass::Test_Conversation
(
PhysicalGameObj * initiator,
ConversationClass * conversation,
DynamicVectorClass<PhysicalGameObj *> & buddy_list,
bool force
)
{
int orator_count = conversation->Get_Orator_Count ();
bool retval = (orator_count > 0);
bool initiator_included = false;
DynamicVectorClass<PhysicalGameObj *> available_buddy_list = buddy_list;
buddy_list.Reset_Active ();
//
// Loop over all the orator requirements for this conversation and
// see if they are in the buddy list
//
for (int orator_index = 0; orator_index < orator_count; orator_index ++) {
OratorClass *orator = conversation->Get_Orator (orator_index);
//
// If the orator is invisible, it automatically passes the test (we
// don't need a physical object to take the part).
//
bool found = false;
if (orator->Is_Invisible ()) {
buddy_list.Add (NULL);
found = true;
} else {
//
// Test the initiator
//
if (initiator_included == false) {
if (force || Test_Orator (conversation, orator, initiator)) {
buddy_list.Add (initiator);
initiator_included = true;
found = true;
}
}
//
// Try to find an entry in our buddy list that matches the orator
// requirements
//
for (int index = 0; index < available_buddy_list.Count (); index ++) {
PhysicalGameObj *game_obj = available_buddy_list[index];
//
// Does this game object fit the orator description?
//
if (Test_Orator (conversation, orator, game_obj)) {
buddy_list.Add (game_obj);
//
// Remove this orator from the buddy list
//
available_buddy_list.Delete (index);
found = true;
break;
}
}
}
//
// If we can't match up even ONE of the orators, then the
// conversation can't be executed
//
if (found == false) {
retval = false;
break;
}
}
//
// We can't pass the conversation if the initiator isn't
// included in the conversation.
//
if (initiator_included == false) {
retval = false;
}
return retval;
}
////////////////////////////////////////////////////////////////
//
// Test_Orator
//
////////////////////////////////////////////////////////////////
bool
ConversationMgrClass::Test_Orator
(
ConversationClass * conversation,
OratorClass * orator,
PhysicalGameObj * game_obj
)
{
bool retval = false;
//
// Check to ensure the orator types match
//
if (orator->Get_Orator_Type () == game_obj->Get_Definition ().Get_Orator_Type ()) {
//
// Check to see (if its a soldier) if this orator is in the correct state
//
SoldierGameObj *soldier = game_obj->As_SoldierGameObj ();
if ( soldier == NULL ||
soldier->Is_Human_Controlled () ||
soldier->Get_AI_State () == conversation->Get_AI_State ())
{
retval = true;
}
}
return retval;
}
////////////////////////////////////////////////////////////////
//
// Pick_Conversation
//
////////////////////////////////////////////////////////////////
ConversationClass *
ConversationMgrClass::Pick_Conversation
(
PhysicalGameObj * initiator,
const DynamicVectorClass<PhysicalGameObj *> & available_orator_list,
DynamicVectorClass<PhysicalGameObj *> & orator_list
)
{
ConversationClass *conversation = NULL;
//
// Try to find a conversation that matches the criteria
//
float best_match = 0;
//
// Loop over all the conversation categories
//
for (int cat_index = 0; cat_index < CATEGORY_MAX; cat_index ++) {
//
// Loop over all the conversations in this category
//
int count = ConversationList[cat_index].Count ();
for (int index = 0; index < count; index ++) {
ConversationClass *curr_conversation = ConversationList[cat_index][index];
//
// Can this conversation be used innately?
//
if ( curr_conversation != NULL &&
curr_conversation->Is_Innate ())
{
//
// Test this conversation to ensure all requirements are met
//
DynamicVectorClass<PhysicalGameObj *> curr_orator_list = available_orator_list;
if (Test_Conversation (initiator, curr_conversation, curr_orator_list)) {
//
// Randomize the selection process
//
float match_percent = WWMath::Random_Float (0.9F, 1.1F);
match_percent *= curr_conversation->Get_Probability ();
if (match_percent > best_match) {
//
// This is our best bet so far, so save this conversation
//
best_match = match_percent;
conversation = curr_conversation;
orator_list = curr_orator_list;
}
}
}
}
}
//
// If we've found a conversation, decrease its probability so
// it will be less likely to be picked next time.
//
if (conversation != NULL) {
float probability = conversation->Get_Probability ();
probability = probability * 0.75F;
conversation->Set_Probability (probability);
}
return conversation;
}
////////////////////////////////////////////////////////////////
//
// Is_Key_Conversation_Playing
//
////////////////////////////////////////////////////////////////
bool
ConversationMgrClass::Is_Key_Conversation_Playing (void)
{
bool retval = false;
//
// Check for any "key" conversations
//
int index = ActiveConversationList.Count ();
while (index --) {
ActiveConversationClass *active_conversation = ActiveConversationList[index];
//
// Is this a "key" conversation?
//
if (active_conversation->Peek_Conversation ()->Is_Key ()) {
retval = true;
break;
}
}
return retval;
}
////////////////////////////////////////////////////////////////
//
// Think
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Think (void)
{
bool is_key = Is_Key_Conversation_Playing ();
//
// Stop any non-key conversations that are playing (if there is a key conversation playing)
//
if (is_key) {
bool release_key_conv = false;
int index = ActiveConversationList.Count ();
while (index --) {
ActiveConversationClass *active_conversation = ActiveConversationList[index];
if (active_conversation->Peek_Conversation ()->Is_Key () == false || release_key_conv) {
//
// Stop any non-key conversation
//
active_conversation->Stop_Conversation ();
//
// Remove the conversation from the list
//
ActiveConversationList.Delete (index);
REF_PTR_RELEASE (active_conversation);
} else {
release_key_conv = true;
}
}
}
//
// Loop over all the remaining active conversations
//
int count = ActiveConversationList.Count ();
for (int index = 0; index < count; index ++) {
ActiveConversationClass *active_conversation = ActiveConversationList[index];
//
// Let this conversation process
//
bool remove_from_list = true;
if (active_conversation != NULL) {
active_conversation->Think ();
remove_from_list = active_conversation->Is_Finished ();
}
//
// Remove this conversation from our control (if necessary)
//
if (remove_from_list) {
ActiveConversationList.Delete (index);
REF_PTR_RELEASE (active_conversation);
index --;
count --;
}
}
return ;
}
////////////////////////////////////////////////////////////////
//
// Add_Conversation
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Add_Conversation (ConversationClass *conversation)
{
WWASSERT (conversation != NULL);
if (conversation == NULL) {
return ;
}
//
// Assign this conversation an ID (if necessary)
//
if (conversation->Get_ID () == 0) {
if (conversation->Get_Category_ID () == CATEGORY_LEVEL) {
conversation->Set_ID (NextLevelConversationID ++);
} else {
conversation->Set_ID (NextGlobalConversationID ++);
}
}
//
// Add a reference to the converation, then add it to our list
//
conversation->Add_Ref ();
ConversationList[conversation->Get_Category_ID ()].Add (conversation);
return ;
}
////////////////////////////////////////////////////////////////
//
// Create_New_Conversation
//
////////////////////////////////////////////////////////////////
ActiveConversationClass *
ConversationMgrClass::Create_New_Conversation (ConversationClass *conversation)
{
ActiveConversationClass *active_conversation = NULL;
if (conversation != NULL) {
//
// Allocate the new conversation
//
active_conversation = new ActiveConversationClass;
active_conversation->Set_Conversation (conversation);
//
// Add it to our active conversation list
//
active_conversation->Set_ID (NextActiveConversationID ++);
ActiveConversationList.Add (active_conversation);
active_conversation->Add_Ref ();
}
//
// Return a pointer to the conversation. Note: This object has
// an extra ref count on it, its the caller's responsibility to release
// this ref count when they are finished with it.
//
return active_conversation;
}
////////////////////////////////////////////////////////////////
//
// Remove_Conversation
//
////////////////////////////////////////////////////////////////
void
ConversationMgrClass::Remove_Conversation (ConversationClass *conversation)
{
int cat_index = conversation->Get_Category_ID ();
int count = ConversationList[cat_index].Count ();
//
// Loop over all the conversations in this category
//
for (int index = 0; index < count; index ++) {
ConversationClass *curr_conversation = ConversationList[cat_index][index];
if (conversation == curr_conversation) {
//
// Remove this conversation from the list
//
ConversationList[cat_index].Delete (index);
conversation->Set_ID (0);
REF_PTR_RELEASE (conversation);
break;
}
}
return ;
}
Reference in a new issue View git blame Copy permalink