cbrick.cpp

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

#include    "CBrick.h"

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


CBrick::CBrick( HGE	*hgeEngine , hgeResourceManager *resMgr )
{
	m_hgeEngine = hgeEngine;
	m_resMgr = resMgr;
	m_sp = NULL;

	m_x = 0;
	m_y = 0;
	m_vx = 0;
	m_vy = 0;
	m_endX = 0;
	m_endY = 0;

	m_arrayX = 0;
	m_arrayY = 0;
	m_NewArrayX = 0;
	m_NewArrayY = 0;
	
	m_visible = false;
	m_moving  = false;
	m_bCheckLinked = false;
	
	m_direction = BRICK_NODIR1;
	m_type = BRICK_RED;
	m_state = STATE_SLEEP;
	m_stateStep = 0;

	m_Newdirection = BRICK_NODIR1;
	m_Newtype = BRICK_RED;
	m_Newstate = STATE_SLEEP;
}

bool    CBrick::Init( int arrayX, int arrayY, e_BrickDirection direction, e_BrickType type, e_BrickState state,bool visible )
{
	int temp_type = type;
	if( temp_type > 12 )
	{
		temp_type  =  temp_type%8;
		type       =  (e_BrickType)temp_type;
	}
	


	m_arrayX  =  m_NewArrayX  =  arrayX;
	m_arrayY  =  m_NewArrayY  =  arrayY;
	
	this->ArrayToSrc();

	m_direction  =  m_Newdirection  =  direction;
	m_type      =  m_Newtype  =  type;
	m_state      =  m_Newstate  =  state;
	m_stateStep  =  (float)state;
	
	m_visible    =  visible;
	
	this->LoadRes();
	
	return true;
}

void    CBrick::Release()
{
	//do nothing
}

void    CBrick::LoadRes()
{
	char	name[64] = {0};
	sprintf( name, "%s%d", BrickName[ m_type ], m_state );
	m_sp		=	m_resMgr->GetSprite( name );	
}

void    CBrick::UpdateFace()
{
	m_direction  =  m_Newdirection;
	m_type       =  m_Newtype;
	m_state      =  m_Newstate;	
	this->LoadRes();
}

bool    CBrick::Update()
{		

	//Play the brick Anmi
	if( m_type == BRICK_BOMB || m_type == BRICK_ARROW_CHANGER || m_type == BRICK_LIGHT || m_type == BRICK_COLOR )
	{
		float dt = m_hgeEngine->Timer_GetDelta();
		
		m_stateStep += 8*dt;
		m_state = (e_BrickState)(int)m_stateStep;
		if( m_state > 9 )
		{
			m_state = STATE_1;
			m_stateStep = 0;
		}
		
		this->LoadRes();		
	}
	
	//Play the moving brick
	if( m_moving )
	{
		float dt = m_hgeEngine->Timer_GetDelta();

		switch( m_direction )
		{
		case BRICK_LEFT:
			m_x += m_vx * dt;
			if( m_x < m_endX )
			{
				m_x = m_endX;
				//m_arrayX = m_NewArrayX;
				m_moving = false;
				//this->UpdateFace();
			}
			break;
		
		case BRICK_RIGHT:
			m_x += m_vx * dt;
			if( m_x > m_endX )
			{
				m_x = m_endX;
				//m_arrayX = m_NewArrayX;
				m_moving = false;
			}
			break;
		
		case BRICK_UP:
			m_y += m_vy * dt;
			if( m_y < m_endY )
			{
				m_y = m_endY;
				//m_arrayY = m_NewArrayY;
				m_moving = false;
			}
			break;

		case BRICK_DOWN:
			m_y += m_vy * dt;
			if( m_y > m_endY )
			{
				m_y = m_endY;
				//m_arrayY = m_NewArrayY;
				m_moving = false;
			}
			break;
		}
	}

	return false;
}

void    CBrick::Render()
{
	m_sp->Render(m_x, m_y);

	if( m_direction == BRICK_NODIR1 ||
		m_direction == BRICK_NODIR2 )
	{
		m_hgeEngine->Gfx_RenderLine( m_x, m_y+1, m_x + BRICK_WIDTH, m_y+1, ARGB( 255, 255, 255, 255 ) );
		m_hgeEngine->Gfx_RenderLine( m_x, m_y+2, m_x + BRICK_WIDTH, m_y+2, ARGB( 255, 255, 255, 255 ) );

		m_hgeEngine->Gfx_RenderLine( m_x+1, m_y, m_x+1, m_y + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		m_hgeEngine->Gfx_RenderLine( m_x+2, m_y, m_x+2, m_y + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		
		m_hgeEngine->Gfx_RenderLine( m_x+2 + BRICK_WIDTH, m_y, m_x+2 + BRICK_WIDTH, m_y + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		m_hgeEngine->Gfx_RenderLine( m_x+1 + BRICK_WIDTH, m_y, m_x+1 + BRICK_WIDTH, m_y + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		
		m_hgeEngine->Gfx_RenderLine( m_x, m_y+1 + BRICK_HEIGHT, m_x+2 + BRICK_WIDTH, m_y+1 + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		m_hgeEngine->Gfx_RenderLine( m_x, m_y+2 + BRICK_HEIGHT, m_x+2 + BRICK_WIDTH, m_y+2 + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );		
	}	
}

void    CBrick::RenderToBuffer()
{
	float x = m_x - AREA_BEGIN_X - TILE_SIZE*3;
	float y = m_y - AREA_BEGIN_Y - TILE_SIZE*3; 
	
	m_sp->Render(x, y);

	if( m_direction == BRICK_NODIR1 ||
		m_direction == BRICK_NODIR2 )
	{
		m_hgeEngine->Gfx_RenderLine( x, y+1, x + BRICK_WIDTH, y+1, ARGB( 255, 255, 255, 255 ) );
		m_hgeEngine->Gfx_RenderLine( x, y+2, x + BRICK_WIDTH, y+2, ARGB( 255, 255, 255, 255 ) );

		m_hgeEngine->Gfx_RenderLine( x+1, y, x+1, y + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		m_hgeEngine->Gfx_RenderLine( x+2, y, x+2, y + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		
		m_hgeEngine->Gfx_RenderLine( x+2 + BRICK_WIDTH, y, x+2 + BRICK_WIDTH, y + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		m_hgeEngine->Gfx_RenderLine( x+1 + BRICK_WIDTH, y, x+1 + BRICK_WIDTH, y + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		
		m_hgeEngine->Gfx_RenderLine( x, y+1 + BRICK_HEIGHT, x+2 + BRICK_WIDTH, y+1 + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );
		m_hgeEngine->Gfx_RenderLine( x, y+2 + BRICK_HEIGHT, x+2 + BRICK_WIDTH, y+2 + BRICK_HEIGHT, ARGB( 255, 255, 255, 255 ) );		
	}	
}


void    CBrick::RenderRotate(float angle)
{
	m_sp->SetHotSpot( TILE_SIZE/2, TILE_SIZE/2 );
	m_sp->RenderEx( m_x + TILE_SIZE/2, m_y + TILE_SIZE/2,angle  );
	m_sp->SetHotSpot( 0, 0 );
}


void    CBrick::SrcToArray()
{
	//m_arrayX  =   

}

void    CBrick::ArrayToSrc()
{
	m_x  =	(float)AREA_BEGIN_X + TILE_SIZE * m_arrayX;	
	m_y  =	(float)AREA_BEGIN_Y + TILE_SIZE * m_arrayY;	
	
	if( m_arrayX >=0 && m_arrayX <= 2 )
		m_x -= 2;

	if( m_arrayX >=11 && m_arrayX <= 13 )
		m_x += 2;

	if( m_arrayY >=0 && m_arrayY <= 2 )
		m_y -= 2;

	if( m_arrayY >=11 && m_arrayY <= 13 )
		m_y += 2;

}

void    CBrick::MoveTo( e_BrickDirection direction, int newArrayX, int newArrayY, float vx, float vy )
{
	m_direction = direction;
	m_arrayX = newArrayX;
	m_arrayY = newArrayY;
	m_endX = (float)(m_arrayX) * TILE_SIZE + AREA_BEGIN_X;
	m_endY = (float)(m_arrayY) * TILE_SIZE + AREA_BEGIN_Y;
	m_vx = vx;
	m_vy = vy;
	
	if( m_arrayX >=0 && m_arrayX <= 2 )
		m_endX -= 2;

	if( m_arrayX >=11 && m_arrayX <= 13 )
		m_endX += 2;

	if( m_arrayY >=0 && m_arrayY <= 2 )
		m_endY -= 2;

	if( m_arrayY >=11 && m_arrayY <= 13 )
		m_endY += 2;
	
	this->Play();
}

void    CBrick::SetNotSleepState()
{
	int state;
	while(1)
	{
		state = rand()%6;
		if( state != 5 )
		{
			break;
		}
	}
	m_state = (e_BrickState)(state);
	this->LoadRes();
}

void    CBrick::SetState( e_BrickState state )
{
	m_state = state;
	this->LoadRes();
}

void    CBrick::RandSetType()
{
	int type = rand()%8;
	m_type = (e_BrickType)type;
	this->LoadRes();
}

void    CBrick::RandSetState()
{
	if( rand()%10000 > 10 )
		return;

	int state;
	while(1)
	{
		state = rand()%7;
		if( state != (int)STATE_SLEEP )
			break;
	}
	m_state = (e_BrickState)state;
	this->LoadRes();
}