gamesoundengine.hpp

本游戏是一款单机版的坦克大战游戏

//////////////////////////////////////////////////////////////////////////////////////////////////
//      #                                                                               #       //
//		#		* File Name:	GameSoundEngine.hpp										#	    //
//		#																				#	    //
//		#		* Function:		the engine of the game									#	    //
//		#																				#	    //
//		#		* Instruction:	Created by JIAN NAN FEI 2008 8 29						#	    //
//      #                                                                               #       //
///////////////////////////////////////////////////////////////////////////////////////////////////

//----------------------------------------------------------------------------------------------//
//										DEFINES REFERENCES HERE									//
//----------------------------------------------------------------------------------------------//

	#ifndef WIN32_LEAN_AND_MEAN
	#define WIN32_LEAN_AND_MEAN
	#endif


//----------------------------------------------------------------------------------------------//
//										HEADFILES REFERENCES HERE								//
//----------------------------------------------------------------------------------------------//

	#include <windows.h>
	#include <windowsx.h>
	#include <mmsystem.h>
	#include <dsound.h>

	typedef struct
	{
		BYTE *pbWaveData;               // pointer into wave resource (for restore)
		DWORD cbWaveSize;               // size of wave data (for restore)
		int iAlloc;                     // number of buffers.
		int iCurrent;                   // current buffer
		IDirectSoundBuffer* Buffers[1]; // list of buffers

	} SNDOBJ, *HSNDOBJ;

	#define _HSNDOBJ_DEFINED
	#include "GameSoundEngine.h"

//----------------------------------------------------------------------------------------------//
//										GLOBAL MEMBER VARIAYS REFERENCES HERE					//
//----------------------------------------------------------------------------------------------//


	static const char c_szWAV[] = "WAV";


//----------------------------------------------------------------------------------------------//
//										FUNCTION MEMBERS REFERENCES HERE						//
//----------------------------------------------------------------------------------------------//

//----------------------------------------------------------------------------------------------//
//										FUNCTION COMPLISHMENT REFERENCES HERE					//
//----------------------------------------------------------------------------------------------//

//-----------------------------------------------------------------------------
//
// name:	DSLoadSoundBuffer
//
//-----------------------------------------------------------------------------

	IDirectSoundBuffer *DSLoadSoundBuffer(IDirectSound *pDS, LPCTSTR lpName)
	{
		IDirectSoundBuffer *pDSB = NULL;
		DSBUFFERDESC dsBD = {0};
		BYTE *pbWaveData;

		if (DSGetWaveResource(NULL, lpName, &dsBD.lpwfxFormat, &pbWaveData, &dsBD.dwBufferBytes))
		{
			dsBD.dwSize = sizeof(dsBD);
			dsBD.dwFlags = DSBCAPS_STATIC | DSBCAPS_GETCURRENTPOSITION2;

			if (SUCCEEDED(IDirectSound_CreateSoundBuffer(pDS, &dsBD, &pDSB, NULL)))
			{
				if (!DSFillSoundBuffer(pDSB, pbWaveData, dsBD.dwBufferBytes))
				{
					IDirectSoundBuffer_Release(pDSB);
					pDSB = NULL;
					OutputDebugString("the directsound pointer is null!\n");
				}
			}
			else
				pDSB = NULL;
		}
		return pDSB;
	}

//-----------------------------------------------------------------------------
//
// name:	DSReloadSoundBuffer
//
//-----------------------------------------------------------------------------

	BOOL DSReloadSoundBuffer(IDirectSoundBuffer *pDSB, LPCTSTR lpName)
	{
		BOOL result=FALSE;
		BYTE *pbWaveData;
		DWORD cbWaveSize;

		if (DSGetWaveResource(NULL, lpName, NULL, &pbWaveData, &cbWaveSize))
		{
			if (SUCCEEDED(IDirectSoundBuffer_Restore(pDSB)) &&
				DSFillSoundBuffer(pDSB, pbWaveData, cbWaveSize))
			{
				result = TRUE;
			}
		}
		return result;
	}

//-----------------------------------------------------------------------------
//
// name:	DSGetWaveResource
//
//-----------------------------------------------------------------------------

	BOOL DSGetWaveResource(HMODULE hModule, LPCTSTR lpName,WAVEFORMATEX **ppWaveHeader,
						   BYTE **ppbWaveData, DWORD *pcbWaveSize)
	{
		HRSRC hResInfo;
		HGLOBAL hResData;
		void *pvRes;

		if ((hResInfo = FindResource(hModule, "Splash", c_szWAV)) != NULL)
		{
			if	((hResData = LoadResource(hModule, hResInfo)) != NULL) 
			{
				if	((pvRes = LockResource(hResData)) != NULL) 
				{
					if	(DSParseWaveResource(pvRes, ppWaveHeader, ppbWaveData, pcbWaveSize))
					{
						return TRUE;
					}
					else
						OutputDebugString("Erro no ParseWaveResource");
				}
				else
					OutputDebugString("Erro no LockResource");
			}
			else
				OutputDebugString("Erro no LoadResource");
		}
		else
			OutputDebugString("Erro no FindResource");
		return FALSE;
	}

//-----------------------------------------------------------------------------
//
// name:	SndObjCreate
//
//-----------------------------------------------------------------------------

	SNDOBJ *SndObjCreate(IDirectSound *pDS, LPCTSTR lpName, int iConcurrent)
	{
		SNDOBJ *pSO = NULL;
		LPWAVEFORMATEX pWaveHeader;
		BYTE *pbData;
		DWORD cbData;

		if (DSGetWaveResource(NULL, lpName, &pWaveHeader, &pbData, &cbData))
		{
			if (iConcurrent < 1)
				iConcurrent = 1;

			if ((pSO = (SNDOBJ *)LocalAlloc(LPTR, sizeof(SNDOBJ) +
				(iConcurrent-1) * sizeof(IDirectSoundBuffer *))) != NULL)
			{
				int i;

				pSO->iAlloc = iConcurrent;
				pSO->pbWaveData = pbData;
				pSO->cbWaveSize = cbData;
				pSO->Buffers[0] = DSLoadSoundBuffer(pDS, lpName);

				for (i=1; i<pSO->iAlloc; i++)
				{
					if (FAILED(IDirectSound_DuplicateSoundBuffer(pDS,
						pSO->Buffers[0], &pSO->Buffers[i])))
					{
						pSO->Buffers[i] = DSLoadSoundBuffer(pDS, lpName);
						if (!pSO->Buffers[i])
						{
							SndObjDestroy(pSO);
							pSO = NULL;
							break;
						}
					}
				}
			}
		}
		else
			OutputDebugString("PROBLEMA COM O UNISGNED\n");

		return pSO;
	}

//-----------------------------------------------------------------------------
//
// name:	SndObjDestroy
//
//-----------------------------------------------------------------------------

	void SndObjDestroy(SNDOBJ *pSO)
	{
		if (pSO!=NULL)
		{
			int i;

			for (i=0; i<pSO->iAlloc; i++)
			{
				if (pSO->Buffers[i])
				{
				IDirectSoundBuffer_Release(pSO->Buffers[i]);
				pSO->Buffers[i] = NULL;
				}
			}
			LocalFree((HANDLE)pSO);
		}
	}

//-----------------------------------------------------------------------------
//
// name:	SndObjGetFreeBuffer
//
//-----------------------------------------------------------------------------

	IDirectSoundBuffer *SndObjGetFreeBuffer(SNDOBJ *pSO)
	{
		IDirectSoundBuffer *pDSB;

		if (pSO == NULL)
		return NULL;

		if (pDSB = pSO->Buffers[pSO->iCurrent])
		{
			HRESULT hres;
			DWORD dwStatus;

			hres = IDirectSoundBuffer_GetStatus(pDSB, &dwStatus);

			if (FAILED(hres))
				dwStatus = 0;

			if ((dwStatus & DSBSTATUS_PLAYING) == DSBSTATUS_PLAYING)
			{
				if (pSO->iAlloc > 1)
				{
					if (++pSO->iCurrent >= pSO->iAlloc)
						pSO->iCurrent = 0;

					pDSB = pSO->Buffers[pSO->iCurrent];
					hres = IDirectSoundBuffer_GetStatus(pDSB, &dwStatus);

					if (SUCCEEDED(hres) && (dwStatus & DSBSTATUS_PLAYING) == DSBSTATUS_PLAYING)
					{
						IDirectSoundBuffer_Stop(pDSB);
						IDirectSoundBuffer_SetCurrentPosition(pDSB, 0);
					}
				}
				else
				{
					pDSB = NULL;
				}
			}

			if (pDSB && (dwStatus & DSBSTATUS_BUFFERLOST))
			{
				if (FAILED(IDirectSoundBuffer_Restore(pDSB)) ||
				!DSFillSoundBuffer(pDSB, pSO->pbWaveData, pSO->cbWaveSize))
				{
					pDSB = NULL;
				}
			}
		}

		return pDSB;
	}

//-----------------------------------------------------------------------------
//
// name:	SndObjPlay
//
//-----------------------------------------------------------------------------

BOOL SndObjPlay(SNDOBJ *pSO, DWORD dwPlayFlags)
{
    BOOL result = FALSE;

    if (pSO == NULL)
	return FALSE;

    if ((!(dwPlayFlags & DSBPLAY_LOOPING) || (pSO->iAlloc == 1)))
    {
		IDirectSoundBuffer *pDSB = SndObjGetFreeBuffer(pSO);
		if (pDSB != NULL) 
		{
			result = SUCCEEDED(IDirectSoundBuffer_Play(pDSB, 0, 0, dwPlayFlags));
		}
    }

    return result;
}

//-----------------------------------------------------------------------------
//
// name:	SndObjStop
//
//-----------------------------------------------------------------------------

BOOL SndObjStop(SNDOBJ *pSO)
{
    int i;

    if (pSO == NULL)
	return FALSE;

    for (i=0; i<pSO->iAlloc; i++)
    {
		IDirectSoundBuffer_Stop(pSO->Buffers[i]);
		IDirectSoundBuffer_SetCurrentPosition(pSO->Buffers[i], 0);
    }

    return TRUE;
}

//-----------------------------------------------------------------------------
//
// name:	DSFillSoundBuffer
//
//-----------------------------------------------------------------------------

BOOL DSFillSoundBuffer(IDirectSoundBuffer *pDSB, BYTE *pbWaveData, DWORD cbWaveSize)
{
    if (pDSB && pbWaveData && cbWaveSize)
    {
		LPVOID pMem1, pMem2;
		DWORD dwSize1, dwSize2;

		if (SUCCEEDED(IDirectSoundBuffer_Lock(pDSB, 0, cbWaveSize,
			&pMem1, &dwSize1, &pMem2, &dwSize2, 0)))
		{
			CopyMemory(pMem1, pbWaveData, dwSize1);

			if ( 0 != dwSize2 )
				CopyMemory(pMem2, pbWaveData+dwSize1, dwSize2);

			IDirectSoundBuffer_Unlock(pDSB, pMem1, dwSize1, pMem2, dwSize2);
			return TRUE;
		}
    }

    return FALSE;
}

//-----------------------------------------------------------------------------
//
// name:	DSParseWaveResource
//
//-----------------------------------------------------------------------------

BOOL DSParseWaveResource(void *pvRes, WAVEFORMATEX **ppWaveHeader, BYTE **ppbWaveData,DWORD *pcbWaveSize)
{
    DWORD *pdw;
    DWORD *pdwEnd;
    DWORD dwRiff;
    DWORD dwType;
    DWORD dwLength;

    if (ppWaveHeader)
	*ppWaveHeader = NULL;

    if (ppbWaveData)
	*ppbWaveData = NULL;

    if (pcbWaveSize)
	*pcbWaveSize = 0;

    pdw = (DWORD *)pvRes;
    dwRiff = *pdw++;
    dwLength = *pdw++;
    dwType = *pdw++;

    if (dwRiff != mmioFOURCC('R', 'I', 'F', 'F'))
	goto exit;      // not even RIFF

    if (dwType != mmioFOURCC('W', 'A', 'V', 'E'))
	goto exit;      // not a WAV

    pdwEnd = (DWORD *)((BYTE *)pdw + dwLength-4);

    while (pdw < pdwEnd)
    {
		dwType = *pdw++;
		dwLength = *pdw++;

		switch (dwType)
		{
		case mmioFOURCC('f', 'm', 't', ' '):
			if (ppWaveHeader && !*ppWaveHeader)
			{
				if (dwLength < sizeof(WAVEFORMAT))
					goto exit;      // not a WAV

				*ppWaveHeader = (WAVEFORMATEX *)pdw;

				if ((!ppbWaveData || *ppbWaveData) &&
					(!pcbWaveSize || *pcbWaveSize))
				{
					return TRUE;
				}
			}
			break;

		case mmioFOURCC('d', 'a', 't', 'a'):
			if ((ppbWaveData && !*ppbWaveData) ||
			(pcbWaveSize && !*pcbWaveSize))
			{
				if (ppbWaveData)
					*ppbWaveData = (LPBYTE)pdw;

				if (pcbWaveSize)
					*pcbWaveSize = dwLength;

				if (!ppWaveHeader || *ppWaveHeader)
					return TRUE;
				}
				break;
			}

		pdw = (DWORD *)((BYTE *)pdw + ((dwLength+1)&~1));
    }

	exit:
		OutputDebugString("Erro no parse do RESOURCE");
		return FALSE;
}

//----------------------------------------------------------------------------------------------//
//										COMPLISHMENT OF THE FILE    							//
//----------------------------------------------------------------------------------------------//