csplash.cpp

我在资源网上发布的一个brickshorterjr的代码

#include	"CSplash.h"
#include	"g_info.h"

static	const	char	BrickName[][256] = {	"Red",
												"Blue",
												"Green",
												"Skyyellow",
												"Yellow",
												"Gray",
												"Cyan",
												"Pink"
											};


CSplashBrick::CSplashBrick( HGE *hgeEngine , hgeResourceManager *resMgr )
{
	m_hgeEngine    =  hgeEngine;
	m_resMgr       =  resMgr;
	m_SplashBrick  =  NULL;
		
	m_x            =  0;
	m_y            =  0;
	m_vx           =  0;
	m_vy           =  0;
	m_color        =  0;
	m_state        =  0;
	m_direction    =  0;
	m_exist        =  false;
}

bool    CSplashBrick::Init()
{
	m_direction  =  rand()%4;
	m_color  =  rand()%SplashBrickTypeCount;
	m_state  =  rand()%SplashBrickStateCount;
	
	switch( m_direction )
	{
	case SPLASH_RIGHT:
		m_x   =  0;
		m_vx  =  rand()%300 + 300;
		
		m_y   =  rand()%WINDOW_HEIGHT;
		m_vy  =  0;
		break;

	case SPLASH_LEFT:
		m_x   =  WINDOW_WIDTH;
		m_vx  =  -(rand()%300 + 300);
		
		m_y   =  rand()%WINDOW_HEIGHT;
		m_vy  =  0;
		break;	
	
	case SPLASH_UP:
		m_x   =  rand()%WINDOW_WIDTH;
		m_vx  =  0;
		
		m_y   =  WINDOW_HEIGHT;
		m_vy  =  -(rand()%300 + 300);
		break;		
	
	case SPLASH_DOWN:
		m_x   =  rand()%WINDOW_WIDTH;
		m_vx  =  0;
		
		m_y   =  WINDOW_HEIGHT;
		m_vy  =  rand()%300 + 300;
		break;				
	}

	char	name[64] = {0};
	sprintf( name, "%s%d", BrickName[m_color], m_state );
	m_SplashBrick  =  m_resMgr->GetSprite( name );

	return true;
}

void    CSplashBrick::Release()
{
	
}

bool    CSplashBrick::Update()
{
	if( !m_exist )
		return false;

	float dt = m_hgeEngine->Timer_GetDelta();

	m_x += m_vx * dt;
	m_y += m_vy * dt;
	
	switch( m_direction )
	{
	case SPLASH_RIGHT:
		if( m_x > WINDOW_WIDTH )
		{
			m_exist  =  false;
			return true;
		}
		break;
	case SPLASH_LEFT:
		if( m_x < 0 )
		{
			m_exist  =  false;
			return true;
		}
		break;
	case SPLASH_UP:
		if( m_y < 0 )
		{
			m_exist  =  false;
			return true;
		}
		break;
	case SPLASH_DOWN:
		if( m_y > WINDOW_HEIGHT )
		{
			m_exist  =  false;
			return true;
		}
		break;			
	}

	return false;
}

void    CSplashBrick::Render()
{
	m_SplashBrick->Render( m_x, m_y );	
}






//=========================================================================
//	Name:CSplash
//	Desc:Constructors
//
//=========================================================================
CSplash::CSplash( HGE *hgeEngine , hgeResourceManager *resMgr )
{
	m_hgeEngine  =  hgeEngine;
	m_resMgr     =  resMgr;
	m_render     =  NULL;

	m_SplashBrick.clear();

	m_ExplState  =  false;
	m_beginTime  =  m_hgeEngine->Timer_GetTime();

	m_SplashBomb   =  NULL;
	m_SplashExpl   =  NULL;

	m_SplashchlBomb = NULL;
}


//=========================================================================
//	Name:Init
//	Desc:Init the Splash's data
//
//=========================================================================
bool    CSplash::Init()
{		
	m_render     =  new  CRender( m_hgeEngine , m_resMgr );
	m_render->Init();

	m_render->AddSplashPar( SPLASH_BOMB );

	m_SplashBomb  =  m_resMgr->GetEffect( "splashSndBomb" );
	m_SplashExpl  =  m_resMgr->GetEffect( "splashSndExpl" );
	
	m_SplashchlBomb = m_hgeEngine->Effect_PlayEx( m_SplashBomb, 50, 0, 1, true );

	return true;
}

//=========================================================================
//	Name:Release
//	Desc:
//
//=========================================================================
void    CSplash::Release()
{
	//delete the render
	if( m_render != NULL )
		m_render->Release();
	SAFE_DELETE( m_render );
	
	if( !m_SplashBrick.empty() )
	{
		for( list<CSplashBrick*>::iterator i = m_SplashBrick.begin();  i != m_SplashBrick.end(); i++ )
		{
			(*i)->Release();
			SAFE_DELETE( (*i) );
			i = m_SplashBrick.erase( i );
		}
	}
}


//=========================================================================
//	Name:Update
//	Desc:Update the Splash's data
//
//=========================================================================
bool    CSplash::Update()
{
	if( !m_ExplState && m_hgeEngine->Input_GetKey() != 0 )
	{
		m_ExplState = true;
		m_beginTime = m_hgeEngine->Timer_GetTime();
		m_render->AddSplashPar( SPLASH_EXPL );

		m_hgeEngine->Channel_Stop( m_SplashchlBomb );
		
		m_hgeEngine->Effect_PlayEx( m_SplashExpl, 80, 0, 1 );

	}

	if( m_ExplState && m_hgeEngine->Timer_GetTime() - m_beginTime > 2 )
	{
		this->Render( *m_render->GetSaveTargetSave() );
		m_render->SaveToTextureSave();
		return true;
	}

	if( rand()%100 > 93  && m_SplashBrick.size() < 20 )
	{
		CSplashBrick *splashBrick  =  new  CSplashBrick( m_hgeEngine , m_resMgr );
		splashBrick->Init();
		splashBrick->Play();
		m_SplashBrick.push_back(splashBrick);
	}

	if( !m_SplashBrick.empty() )
	{
		for( list<CSplashBrick*>::iterator i = m_SplashBrick.begin();  i != m_SplashBrick.end(); i++ )
		{
			if( (*i)->IsAlive() )
			{
				(*i)->Update();
			}
			else
			{
				(*i)->Release();
				SAFE_DELETE( (*i) );
				i = m_SplashBrick.erase( i );
			}
		}
	}

	return false;
}

//=========================================================================
//	Name:Render
//	Desc:Render the Splash
//
//=========================================================================
void    CSplash::Render( HTARGET target )
{
	if( target == 0 )
	{
		m_hgeEngine->Gfx_BeginScene();
	}
	else
	{
		m_hgeEngine->Gfx_BeginScene( target );
	}

	m_hgeEngine->Gfx_Clear( 0 );
	
	m_render->RenderSplashBack();
	
	if( !m_SplashBrick.empty() )
	{
		for( list<CSplashBrick*>::iterator i = m_SplashBrick.begin();  i != m_SplashBrick.end(); i++ )
		{
			(*i)->Render();
		}
	}
	
	m_render->RenderSplashWord();
	m_render->RenderPar();
	
	m_hgeEngine->Gfx_EndScene();
}