l3lib/l3lib_vc3/frm/llfrm_waveplayer.h

//
// G A M E.O.N.E - LOW LEVEL LIB V1.0
// Copyright (C) 2001 LEVEL ONE ENTERTAINMENT, 
// Licensed under the terms of LGPL.
//:---------------------------------------------------------------------------
//:Description
//
// FRAMEWORK global object waveplayer
// 
// CActor
//   +--CWavePlayer : CAWave
//
// Loads and plays wave files named by an alias
// 
//////////////////////////////////////////////////////////////////////

#ifndef _WAVEPLAYER_H
#define _WAVEPLAYER_H

#include "../lib_base.h"
#include "../llsound.h"
#include "llfrm_actor.h"
#include "../llirq.h"

#define MAX_EFFEKT (8)	// Anzahl simultaner explosionen

enum {
	EFFEKTRULE_FIRST = 0,
	EFFEKTRULE_STILL,
	EFFEKTRULE_LAST,
	EFFEKTRULE_RANDOM
};


class CAWave
{
public:
	char *		m_wave_name;
	llsound_id	m_array[MAX_EFFEKT];
	int			m_cnt_channels;			// anzahl Effekte gleichzeitig
	int			m_rule;					// Bei voller Anzahl von Channels
										// rule 0 = der längst gespielte wird ersetzt
										// rule 1 = keiner wird ersetzt
										// rule 2 = der jüngste wird ersetzt
										// rule 3 = per Zufall wird ersetzt
										
	CAWave()
	{
		int i = MAX_EFFEKT;
		while( i-- > 0 )
			m_array[i] = 0;
		m_wave_name = 0;
		m_rule = EFFEKTRULE_FIRST;
	}

	~CAWave()
	{
		ReleaseAll();
	}

	void ReleaseAll()
	{
		if(m_wave_name) 
			free(m_wave_name);
		m_wave_name = 0;
		
		int i = m_cnt_channels;
		while( i-- > 0 )
		{
			llsound_ReleaseSnd(m_array[i]);
			m_array[i] = 0;
		}
	}

	void PlayOneofArray(int mode)
	{
		int i = m_cnt_channels;
		while( i-- > 0 )
		{
			if( 0 == llsound_GetStatus(m_array[i]) )
			{
				llsound_Play(m_array[i],mode);
				return;
			}
		}

		switch(m_rule){
		case EFFEKTRULE_FIRST:
			llsound_Play(GetSound_MaxPlaytime(),mode);
			break;
		case EFFEKTRULE_LAST:
			llsound_Play(GetSound_MinPlaytime(),mode);
			break;
		case EFFEKTRULE_RANDOM:
			llsound_Play(m_array[ llirq_GetRand()%m_cnt_channels ],mode);
			break;
		default:
		case EFFEKTRULE_STILL:
			break;
		}
	}

	void Stop(){
		//alle
		int i = m_cnt_channels;
		while( i-- > 0 )
		{
			llsound_Stop(m_array[i]);
		}
	}


	llsound_id GetSound_MaxPlaytime(){
		int i = m_cnt_channels;
		int index=0;
		int playtime = 0;
		while( i-- > 0 )
		{
			int pt = llsound_GetStatus(m_array[i]);
			if( pt > playtime )
			{
				playtime = pt;
				index = i;
			}
		}
		return m_array[index];
	}

	llsound_id GetSound_MinPlaytime(){
		int i = m_cnt_channels;
		int index=0;
		int playtime = 0;
		while( i-- > 0 )
		{
			int pt = llsound_GetStatus(m_array[i]);
			if( pt < playtime )
			{
				playtime = pt;
				index = i;
			}
		}
		return m_array[index];
	}

	void SetVolume(float volume )
	{
		int i = m_cnt_channels;
		while( i -- > 0 )
		{
			llsound_SetVolume(m_array[i],volume);
		}
	}


	void SetAlias(const char *name )
	{
		if( m_wave_name ) 
			free(m_wave_name);
		m_wave_name = strdup(name);
	}

	void FillSoundArray(llsound_id id, int channels )
	{
		m_array[0] = id;
		m_cnt_channels = channels;
		if( m_cnt_channels > MAX_EFFEKT )
			m_cnt_channels = MAX_EFFEKT;

		for(int i = 1 ; i < m_cnt_channels; i ++ )
		{
			m_array[i] = llsound_CloneSnd(id);
		}
	}
};



class CWavePlayer  : public CActor
{
public:
	CWavePlayer();
	virtual ~CWavePlayer();

	bool Message(const char * Type );

	void Init();
	
	void SetVolume( float volume ); // 0.0f - 1.0f
	void SetVolume( int volpercent); // 0 - 100
	
	float GetVolume();

	void Clear();
private:
	
	void FillSoundArray(llsound_id *array,int max_elements, const char * Filename );
	CAWave * FindWave(const char * wavename  );
	
	float		m_snd_volume;
	bool		m_enableOutput;
	
	queue<CAWave> m_waves;
};



#endif // _WAVEPLAYER_H