GeneralsZeroHour/GeneralsMD/Code/Libraries/Source/WWVegas/WW3D2/animatedsoundmgr.cpp

/*
**	Command & Conquer Generals Zero Hour(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 : ww3d2																		  *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/ww3d2/animatedsoundmgr.cpp                   $*
 *                                                                                             *
 *                       Author:: Patrick Smith                                                *
 *                                                                                             *
 *                     $Modtime:: 12/13/01 6:05p                                              $*
 *                                                                                             *
 *                    $Revision:: 2                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
//
// MBL Update for CNC3 INCURSION - 10.23.2002 - Expanded param handling, Added STOP command
//

#include <string.h>	// stricmp()
#include "animatedsoundmgr.h"
#include "ini.h"
#include "inisup.h"
#include "ffactory.h"
#include "wwfile.h"
#include <stdio.h>
#include "definition.h"
#include "definitionmgr.h"
#include "definitionclassids.h"
#include "wwaudio.h"
#include "audiblesound.h"
#include "htree.h"
#include "hanim.h"
#include "soundlibrarybridge.h"

#include "WWDebug.h"

//////////////////////////////////////////////////////////////////////
//	Static member initialization
//////////////////////////////////////////////////////////////////////
HashTemplateClass<StringClass, AnimatedSoundMgrClass::ANIM_SOUND_LIST *>	AnimatedSoundMgrClass::AnimationNameHash;
DynamicVectorClass<AnimatedSoundMgrClass::ANIM_SOUND_LIST *>					AnimatedSoundMgrClass::AnimSoundLists;
SoundLibraryBridgeClass*																	AnimatedSoundMgrClass::SoundLibrary = NULL;

//////////////////////////////////////////////////////////////////////
//	Local inlines
//////////////////////////////////////////////////////////////////////
static WWINLINE INIClass *
Get_INI (const char *filename)
{
	INIClass *ini = NULL;

	//
	//	Get the file from our filefactory
	//
	FileClass *file = _TheFileFactory->Get_File (filename);
	if (file) {
		
		//
		//	Create the INI object
		//
		if (file->Is_Available ()) {
			ini = new INIClass (*file);
		}

		//
		//	Close the file
		//
		_TheFileFactory->Return_File (file);
	}

	return ini;
}

static int
Build_List_From_String
(
	const char *	buffer,
	const char *	delimiter,
	StringClass **	string_list
)
{
	int count = 0;

	WWASSERT (buffer != NULL);
	WWASSERT (delimiter != NULL);
	WWASSERT (string_list != NULL);
	if ((buffer != NULL) &&
		 (delimiter != NULL) &&
		 (string_list != NULL))
	{
		int delim_len = ::strlen (delimiter);

		//
		// Determine how many entries there will be in the list
		//
		for (const char *entry = buffer;
			  (entry != NULL) && (entry[1] != 0);
			  entry = ::strstr (entry, delimiter))
		{
			
			//
			// Move past the current delimiter (if necessary)
			//
			if ((::strnicmp (entry, delimiter, delim_len) == 0) && (count > 0)) {
				entry += delim_len;
			}

			// Increment the count of entries
			count ++;
		}
	
		if (count > 0) {

			//
			// Allocate enough StringClass objects to hold all the strings in the list
			//
			(*string_list) = new StringClass[count];
		
			//
			// Parse the string and pull out its entries.
			//
			count = 0;
			for (entry = buffer;
				  (entry != NULL) && (entry[1] != 0);
				  entry = ::strstr (entry, delimiter))
			{
				
				//
				// Move past the current delimiter (if necessary)
				//
				if ((::strnicmp (entry, delimiter, delim_len) == 0) && (count > 0)) {
					entry += delim_len;
				}

				//
				// Copy this entry into its own string
				//
				StringClass entry_string = entry;
				char *delim_start = ::strstr (entry_string, delimiter);				
				if (delim_start != NULL) {
					delim_start[0] = 0;
				}

				//
				// Add this entry to our list
				//
				if ((entry_string.Get_Length () > 0) || (count == 0)) {
					(*string_list)[count++] = entry_string;
				}
			}

		} else if (delim_len > 0) {
			count = 1;
			(*string_list) = new StringClass[count];
			(*string_list)[0] = buffer;
		}
				
	}

	//
	// Return the number of entries in our list
	//
	return count;
}


static bool
Is_In_Param_List
(
	StringClass *param_list,
	int param_count,
	const char *param_to_check
)
{
	//
	// Check incoming parameters
	//
	WWASSERT( param_list != NULL );
	if ( param_list == NULL )
	{
		return( false );
	}
	WWASSERT( param_count >= 2 );
	if ( param_count < 2 )
	{
		return( false );
	}
	WWASSERT( param_to_check != NULL );
	if ( param_to_check == NULL )
	{
		return( false );
	}

	//
	// Note: params 0 & 1 are fixed to frame and name...
	//
	for ( int param_index = 2; param_index < param_count; param_index ++ )
	{
		{
			StringClass string = param_list[ param_index ];

			// OutputDebugString( "MBL: Comparing " );
			// OutputDebugString( string.Peek_Buffer() );
			// OutputDebugString( " with " );
			// OutputDebugString( param_to_check );
			// OutputDebugString( "\n" );

			// if ( stricmp( string.Peek_Buffer(), param_to_check ) == 0 ) // Breaks with whitespaces
			if ( strstr( string.Peek_Buffer(), param_to_check ) != 0 )
			{
			 	return( true );
			}
		}
	}

	return( false );
}

//////////////////////////////////////////////////////////////////////
//
//	Initialize
//
//////////////////////////////////////////////////////////////////////
void
AnimatedSoundMgrClass::Initialize (const char *ini_filename)
{
	//
	//	Don't re-initialize...
	//
	if (AnimSoundLists.Count () > 0) {
		return ;
	}

	const char *DEFAULT_INI_FILENAME	= "w3danimsound.ini";
	
	//
	//	Determine which filename to use
	//
	const char *filename_to_use = ini_filename;
	if (filename_to_use == NULL) {
		filename_to_use = DEFAULT_INI_FILENAME;
	}

	//
	//	Get the INI file which contains the data for this viewer
	//
	INIClass *ini_file = ::Get_INI (filename_to_use);
	if (ini_file != NULL) {

		//
		//	Loop over all the sections in the INI
		//
		List<INISection *> &section_list = ini_file->Get_Section_List ();
		for (	INISection *section = section_list.First ();
				section != NULL && section->Is_Valid ();
				section = section->Next_Valid ())
		{
			//
			//	Get the animation name from the section name
			//
			StringClass animation_name = section->Section;
			::strupr (animation_name.Peek_Buffer ());

			// OutputDebugString( "MBL Section / animation: " );
			// OutputDebugString( animation_name.Peek_Buffer()	);
			// OutputDebugString( "\n" );

			//
			//	Allocate a sound list
			//
			ANIM_SOUND_LIST *sound_list = new ANIM_SOUND_LIST;

			//
			//	Loop over all the entries in this section
			//
			int entry_count = ini_file->Entry_Count (section->Section);

			for (int entry_index = 0; entry_index < entry_count; entry_index ++) {
				StringClass value;

				//
				//	Get the data associated with this entry
				//
				const char *entry_name = ini_file->Get_Entry (section->Section, entry_index);

				// OutputDebugString( "  MBL Entry name: " );
				// OutputDebugString( entry_name );
				// OutputDebugString( "\n" );

				if (strcmp(entry_name, "BoneName") == 0) {
					ini_file->Get_String (value, section->Section, entry_name);
					sound_list->BoneName = value;

					// OutputDebugString( "    MBL (BoneName) entry line value: " );
					// OutputDebugString( value.Peek_Buffer() );
					// OutputDebugString( "\n" );

				} else {
					ini_file->Get_String (value, section->Section, entry_name);

					// OutputDebugString( "    MBL (not BoneName) entry line value: " );
					// OutputDebugString( value.Peek_Buffer() );
					// OutputDebugString( "\n" );

					//
					//	Extract the parameters from the section
					//
					int len = value.Get_Length ();					
					StringClass definition_name (len + 1, true);
					int action_frame = 0;

					//
					//	Separate the parameters into an easy-to-handle data structure
					//
					StringClass *param_list = NULL;
					int param_count = ::Build_List_From_String (value, ",", &param_list);

					// if ((param_count >= 2) && (param_count <= 3)) 
					{
						action_frame		= ::atoi (param_list[0]);
						definition_name	= param_list[1];
						definition_name.Trim ();

						//
						//	Tie the relevant information together and store it
						// in the list of sounds for this animation
						//
						ANIM_SOUND_INFO* sound_info = new ANIM_SOUND_INFO;
						sound_info->Frame			= action_frame;
						sound_info->SoundName		= definition_name;

						//
						// "2D" check
						//
						// if ((param_count == 3) && (atoi(param_list[2]) == 2)) {
						// 	sound_info->Is2D = true;
						// }
						//
						sound_info->Is2D = false;
						if ( Is_In_Param_List( param_list, param_count, "2D" ) )
						{
							sound_info->Is2D = true;
						}

						//
						// "STOP" check
						//
						sound_info->IsStop = false;
						if ( Is_In_Param_List( param_list, param_count, "STOP" ) )
						{
							sound_info->IsStop = true;
						}

						sound_list->Add_Sound_Info (sound_info);
						delete [] param_list;
					}
				}
			}

			if (sound_list->List.Count () != 0) {
				
				//
				//	Add this sound list to our hash-table and vector-array
				//
				AnimationNameHash.Insert (animation_name, sound_list);
				AnimSoundLists.Add (sound_list);

			} else {
				//WWDEBUG_SAY (("AnimatedSoundMgrClass::Initialize -- No sounds added for %d!\n", animation_name.Peek_Buffer ()));
				delete sound_list;
			}
		}

		delete ini_file;
	}

	return ;
}


//////////////////////////////////////////////////////////////////////
//
//	Shutdown
//
//////////////////////////////////////////////////////////////////////
void
AnimatedSoundMgrClass::Shutdown (void)
{
	//
	//	Reset the animation name hash
	//
	AnimationNameHash.Remove_All ();

	//
	//	Free each of the sound objects
	//
	for (int index = 0; index < AnimSoundLists.Count (); index ++) {
		/*
		ANIM_SOUND_LIST* list = AnimSoundLists[index];
		for (int i = 0; i < list->Count(); i++) {
			delete (*list)[i];
		}
		*/
		delete AnimSoundLists[index];
	}

	AnimSoundLists.Delete_All ();
	return ;
}


//////////////////////////////////////////////////////////////////////
//
//	Does_Animation_Have_Embedded_Sounds
//
//////////////////////////////////////////////////////////////////////
const char*
AnimatedSoundMgrClass::Get_Embedded_Sound_Name (HAnimClass *anim)
{
	if (anim == NULL) {
		return NULL;
	}
	ANIM_SOUND_LIST* list = Find_Sound_List (anim);
	if (list == NULL) {
		return NULL;
	}

	return list->BoneName.Peek_Buffer();
}



//////////////////////////////////////////////////////////////////////
//
//	Find_Sound_List
//
//////////////////////////////////////////////////////////////////////
AnimatedSoundMgrClass::ANIM_SOUND_LIST *
AnimatedSoundMgrClass::Find_Sound_List (HAnimClass *anim)
{
	//
	//	Build the full name of the animation
	//
	StringClass full_name (0, true);
	full_name = anim->Get_Name ();

	//
	//	Make the name uppercase
	//
	::strupr (full_name.Peek_Buffer ());

	//
	//	Lookup the sound list for this animation
	//
	ANIM_SOUND_LIST *retval = AnimationNameHash.Get (full_name);
	return retval;
}


//////////////////////////////////////////////////////////////////////
//
//	Trigger_Sound
//
//////////////////////////////////////////////////////////////////////
float
AnimatedSoundMgrClass::Trigger_Sound
(
	HAnimClass *		anim,
	float					old_frame,
	float					new_frame,
	const Matrix3D &	tm
)
{
	if ((SoundLibrary == NULL) || (anim == NULL)) {
		return old_frame;
	}

	float retval = old_frame;

#ifndef W3D_MAX4
	//
	//	Lookup the sound list for this animation
	//
	ANIM_SOUND_LIST *sound_list = Find_Sound_List (anim);
	if (sound_list != NULL) {
		
		for (int index = 0; index < sound_list->List.Count (); index ++) {			
			int frame = sound_list->List[index]->Frame;

			//
			//	Is the animation passing the frame we need?
			//
			if ((old_frame < frame) && (new_frame >= frame)) {

				//
				//	Don't trigger the sound if its skipped too far past...
				//
				//if (WWMath::Fabs (new_frame - old_frame) < 3.0F) {
					
					//
					// Stop the audio?
					//
					if (sound_list->List[index]->IsStop == true) 
					{
						//
						// Stop the audio
						//
						SoundLibrary->Stop_Playing_Audio( sound_list->List[index]->SoundName.Peek_Buffer() );
					}
					else
					{
						//
						//	Play the audio
						//
						if (sound_list->List[index]->Is2D == true) 
						{
							SoundLibrary->Play_2D_Audio(sound_list->List[index]->SoundName.Peek_Buffer());
						} 
						else 
						{
							SoundLibrary->Play_3D_Audio(sound_list->List[index]->SoundName.Peek_Buffer(), tm);
						}
					}

					//WWDEBUG_SAY (("Triggering Sound %d %s\n", GetTickCount (), sound_list->List[index]->SoundName));

					retval = frame;

				//}
			}

		}

		//retval = true;
	}
#endif

	return retval;
}

void AnimatedSoundMgrClass::Set_Sound_Library(SoundLibraryBridgeClass* library)
{
	SoundLibrary = library;
}