www.pudn.com > tankedazhan.rar > Sprite.cpp

// Sprite.cpp: implementation of the CSprite class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "Sprite.h" 
#include "Input.h" 
 
#define	MAX_X		416 
#define MAX_Y		416 
#define TILE_W		32 
#define TILE_H		32 
#define BULLET_W	8 
#define BULLET_H	8 
#define OFFSETX		100 
#define OFFSETY		48 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
CSprite::CSprite() 
{ 
 
} 
 
 
BOOL CSprite::HitTest( CSprite& sprite ) 
{ 
	if( !m_active || !sprite.m_active ) 
		return FALSE; 
	 
	RECT rc1, rc2, temp; 
	 
	rc1.left = (int)m_x; 
	rc1.right = rc1.left + m_width; 
	rc1.top = (int)m_y; 
	rc1.bottom = rc1.top + m_height; 
	 
	rc2.left = (int)sprite.m_x; 
	rc2.right = rc2.left + sprite.m_width; 
	rc2.top = (int)sprite.m_y; 
	rc2.bottom = rc2.top + sprite.m_height; 
 
	return IntersectRect( &temp, &rc1, &rc2 ); 
} 
 
 
void CSprite::Draw( LPDIRECTDRAWSURFACE pdds ) 
{ 
	if( !m_active ) 
		return; 
 
	int x = (int)m_x + OFFSETX; 
	int y = (int)m_y + OFFSETY; 
	pdds->BltFast( x, y, m_bmp, NULL, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
} 
 
 
void CBore::Draw( LPDIRECTDRAWSURFACE pdds ) 
{ 
	if( !m_active ) 
		return; 
 
	RECT rc; 
	rc.left = m_frame * m_width; 
	rc.right = rc.left + m_width; 
	rc.top = 0; 
	rc.bottom = rc.top + m_height; 
	int x = (int)m_x + OFFSETX; 
	int y = (int)m_y + OFFSETY; 
 
	pdds->BltFast( x, y, m_bmp, &rc, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
 
	if( timeGetTime() - m_time > 100 ) 
	{ 
		m_time = timeGetTime(); 
		if( m_bAdvance ) 
		{ 
			if( ++m_frame > 3 ) 
			{ 
				m_frame = 2; 
				m_bAdvance = FALSE; 
			} 
		} 
		else 
		{ 
			if( --m_frame < 0 ) 
			{ 
				m_frame = 1; 
				m_bAdvance = TRUE; 
			} 
		} 
	} 
} 
 
 
void CExplode::Draw( LPDIRECTDRAWSURFACE pdds ) 
{ 
	if( !m_active ) 
		return; 
 
	DWORD time = timeGetTime() - m_time; 
	int x = (int)m_x - 20 + OFFSETX; 
	int y = (int)m_y - 20 + OFFSETY; 
 
	if( m_bExplode ) 
	{ 
		if( time < 50 || time > 150 ) 
			CSprite::Draw( pdds ); 
		else 
			pdds->BltFast( x, y, m_explode, NULL, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
		if( time > 200 ) 
			m_active = FALSE; 
	} 
	else 
	{ 
		CSprite::Draw( pdds ); 
		if( time > 70 ) 
			m_active = FALSE; 
	} 
} 
 
 
void CBonus::Draw( LPDIRECTDRAWSURFACE pdds ) 
{ 
	static BOOL bShow; 
	 
	if( !m_active ) 
		return; 
	 
	if( timeGetTime() - m_flickerTime > 200 ) 
	{ 
		m_flickerTime = timeGetTime(); 
		bShow = !bShow; 
	}	 
	 
	if( bShow ) 
	{ 
		RECT rc; 
		rc.left = (int)m_type * m_width; 
		rc.right = rc.left + m_width; 
		rc.top = 0; 
		rc.bottom = m_height; 
 
		pdds->BltFast( (int)m_x + OFFSETX, (int)m_y + OFFSETY, 
			m_bmp, &rc, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
	} 
 
	if( timeGetTime() - m_lastTime > 10000 ) 
		m_active = FALSE; 
} 
 
 
CBullet::CBullet() 
{ 
	m_dir = DIR_UP; 
	m_speed = 0; 
} 
 
 
BOOL CBullet::Move() 
{ 
	if( !m_active ) 
		return FALSE; 
	 
	float offset = m_speed; 
	switch( m_dir ) 
	{ 
	case DIR_UP: 
		m_y -= offset; 
		break; 
	case DIR_DOWN: 
		m_y += offset; 
		break; 
	case DIR_LEFT: 
		m_x -= offset; 
		break; 
	case DIR_RIGHT: 
		m_x += offset; 
		break; 
	} 
	 
	if( m_x >= 0 && m_x + m_width <= MAX_X && 
		m_y >= 0 && m_y + m_height <= MAX_Y ) 
		return TRUE; 
 
	if( m_x < 0 ) 
		m_x = 0; 
	else if( m_x + m_width > MAX_X ) 
		m_x = MAX_X - m_width; 
	if( m_y < 0 ) 
		m_y = 0; 
	else if( m_y + m_height > MAX_Y ) 
		m_y = MAX_Y - m_height; 
 
	return FALSE; 
} 
 
 
void CBullet::Draw( LPDIRECTDRAWSURFACE pdds ) 
{ 
	if( !m_active ) 
		return; 
	 
	RECT rc; 
	rc.left = (int)m_dir * m_width; 
	rc.top = 0; 
	rc.right = rc.left + m_width; 
	rc.bottom = m_height; 
	int x = (int)m_x + OFFSETX; 
	int y = (int)m_y + OFFSETY; 
	 
	pdds->BltFast( x, y, m_bmp, &rc, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
} 
 
 
CTank::CTank() 
{ 
	m_bullet[0].Create( BULLET_W, BULLET_H, FALSE ); 
	m_bullet[1].Create( BULLET_W, BULLET_H, FALSE );	 
	m_time = 0; 
	m_frame = 0; 
} 
 
 
void CTank::ChangeDirection( DIRECTION dir ) 
{ 
	if( m_dir != dir ) 
	{ 
		m_dir = dir; 
		int row = (int)m_y / TILE_H; 
		int col = (int)m_x / TILE_W; 
		int xoffset = (int)m_x % TILE_W; 
		int yoffset = (int)m_y % TILE_H; 
		if( xoffset <= 10 ) 
			m_x = (float)(col * TILE_W + 2); 
		else if( xoffset < TILE_W - 6 ) 
			m_x = (float)(col * TILE_W + 18); 
		else 
			m_x = (float)(col * TILE_W + 34); 
 
		if( yoffset <= 10 ) 
			m_y = (float)(row * TILE_H + 2); 
		else if( yoffset < TILE_H - 6 ) 
			m_y = (float)(row * TILE_H + 18); 
		else 
			m_y = (float)(row * TILE_H + 34); 
	} 
} 
 
 
 
BOOL CTank::HitTest( CTank& sprite, int oldx, int oldy ) 
{ 
	if( !m_active || !sprite.m_active || 
		m_bBoring || sprite.m_bBoring ) 
		return FALSE; 
	 
	int x1 = (int)sprite.m_x; 
	int y1 = (int)sprite.m_y; 
	int x2 = x1 + sprite.m_width; 
	int y2 = y1 + sprite.m_height; 
	int newx = (int)m_x; 
	int newy = (int)m_y; 
	switch( m_dir ) 
	{ 
	case DIR_UP: 
		if( newx <= x2 && newx + m_width >= x1 && 
			oldy >= y2 && newy <= y2 ) 
			return TRUE; 
		break; 
	case DIR_DOWN: 
		if( newx <= x2 && newx + m_width >= x1 && 
			oldy + m_height <= y1 && newy + m_height >= y1 ) 
			return TRUE; 
		break; 
	case DIR_RIGHT: 
		if( newy <= y2 && newy + m_height >= y1 && 
			oldx + m_width <= x1 && newx + m_width >= x1 ) 
			return TRUE; 
		break; 
	case DIR_LEFT: 
		if( newy <= y2 && newy + m_height >= y1 && 
			oldx >= x2 && newx <= x2 ) 
			return TRUE; 
		break; 
	} 
 
	return FALSE; 
} 
 
 
void CTank::DrawShield( LPDIRECTDRAWSURFACE pdds ) 
{ 
	RECT rc; 
	rc.left = 0; 
	rc.top = m_bShield1 * 32; 
	rc.right = rc.left + 32; 
	rc.bottom = rc.top + 32; 
	int x = (int)m_x - 2 + OFFSETX; 
	int y = (int)m_y - 2 + OFFSETY; 
	 
	pdds->BltFast( x, y, m_bmpShield, &rc, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
	 
	if( timeGetTime() - m_flickerTime > 50 ) 
	{ 
		m_bShield1 = !m_bShield1; 
		m_flickerTime = timeGetTime(); 
	} 
	if( timeGetTime() - m_shieldTime > m_maxTime ) 
		m_bShield = FALSE; 
} 
 
 
void CEnemy::ChangeDirection() 
{ 
	CTank::ChangeDirection( (DIRECTION)(rand() % 4) ); 
} 
 
 
BOOL CEnemy::Fire() 
{ 
	if( m_bullet[0].m_active || 
		timeGetTime() - m_time < 150 ) 
		return FALSE; 
 
	m_time = timeGetTime(); 
	m_bullet[0].m_active = TRUE; 
	m_bullet[0].m_speed = 3.0f; 
	m_bullet[0].m_dir = m_dir; 
	 
	switch( m_dir ) 
	{ 
	case DIR_UP: 
		m_bullet[0].m_x = m_x + m_width/2 - 4; 
		m_bullet[0].m_y = m_y; 
		break; 
	case DIR_DOWN: 
		m_bullet[0].m_x = m_x + m_width/2 - 4; 
		m_bullet[0].m_y = m_y + m_height - 8; 
		break; 
	case DIR_LEFT: 
		m_bullet[0].m_x = m_x; 
		m_bullet[0].m_y = m_y + m_height/2 - 4; 
		break; 
	case DIR_RIGHT: 
		m_bullet[0].m_x = m_x + m_width - 8; 
		m_bullet[0].m_y = m_y + m_height/2 - 4; 
	} 
	return TRUE; 
} 
 
 
void CEnemy::Reborn() 
{  
	m_active = TRUE; 
	m_bShield = FALSE; 
	m_bBoring = TRUE; 
	m_bore.m_x = m_x - 2; 
	m_bore.m_y = m_y - 2; 
	m_bore.Bore(); 
	m_shieldTime = timeGetTime(); 
} 
 
 
void CEnemy::Draw( LPDIRECTDRAWSURFACE pdds ) 
{ 
	if( !m_active ) 
		return; 
 
	if( m_bBoring ) 
	{ 
		m_bore.Draw( pdds ); 
		if( timeGetTime() - m_shieldTime > 800 ) 
			m_bBoring = FALSE; 
		return; 
	} 
 
	if( m_bBonus && 
		timeGetTime() - m_redTime > 80 ) 
	{	 
		m_redTime = timeGetTime(); 
		m_bShowRed = !m_bShowRed; 
	} 
 
	int x = (int)m_x + OFFSETX; 
	int y = (int)m_y + OFFSETY; 
	RECT rc; 
	if( m_bBonus && m_bShowRed ) 
	{ 
		switch( m_type ) 
		{ 
		case 0: 
		case 1: 
			rc.top = (int)m_dir * m_height; 
			rc.left = (2 + m_frame + 4*m_type) * m_width; 
			break; 
		case 2: 
			rc.top = ((int)m_dir + 4) * m_height; 
			rc.left = 6 * m_width; 
			break; 
		} 
		rc.right = rc.left + m_width; 
		rc.bottom = rc.top + m_height; 
		pdds->BltFast( x, y, m_bmp, &rc, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
	} 
	else 
	{ 
		switch( m_type ) 
		{ 
		case 0: 
		case 1: 
			rc.top = (int)m_dir * m_height; 
			rc.left = (m_type * 4 + m_frame) * m_width; 
			break; 
		case 2: 
			rc.left = ((2-m_level)*2 + m_frame) * m_width; 
			rc.top = ((int)m_dir + 4) * m_height; 
			break; 
		} 
		rc.right = rc.left + m_width; 
		rc.bottom = rc.top + m_height; 
		pdds->BltFast( x, y, m_bmp, &rc, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
	} 
 
	if( m_bShield ) 
		DrawShield( pdds ); 
	m_bullet[0].Draw( pdds ); 
} 
 
 
BOOL CPlayer::Fire() 
{ 
	float speed; 
	switch( m_type ) 
	{ 
	case 0: 
		speed = 3.0f; 
		break; 
	case 1: 
		speed = 4.0f; 
		break; 
	case 2: 
	case 3: 
		speed = 10.0f; 
		break; 
	} 
 
	if( timeGetTime() - m_time < 200 ) 
		return FALSE; 
	 
	for( int i = 0; i < 2; i ++ ) 
		if( !m_bullet[i].m_active ) 
			break; 
	if( i >= 2 || 
		i != 0 && m_type < 2) 
		return FALSE; 
 
	m_time = timeGetTime(); 
	m_bullet[i].m_active = TRUE; 
	m_bullet[i].m_speed = speed; 
	m_bullet[i].m_dir = m_dir; 
	 
	switch( m_dir ) 
	{ 
	case DIR_UP: 
		m_bullet[i].m_x = m_x + m_width/2 - 4; 
		m_bullet[i].m_y = m_y + 4; 
		break; 
	case DIR_DOWN: 
		m_bullet[i].m_x = m_x + m_width/2 - 4; 
		m_bullet[i].m_y = m_y + m_height - 12; 
		break; 
	case DIR_LEFT: 
		m_bullet[i].m_x = m_x + 4; 
		m_bullet[i].m_y = m_y + m_height/2 - 4; 
		break; 
	case DIR_RIGHT: 
		m_bullet[i].m_x = m_x + m_width - 12; 
		m_bullet[i].m_y = m_y + m_height/2 - 4; 
	} 
	return TRUE; 
} 
 
 
 
BOOL CPlayer::ProcessInput( WORD input, DWORD time ) 
{ 
	if( !m_bLocked ) 
	{ 
		DIRECTION dir; 
		if( input & KEY_UP ) 
			dir = DIR_UP; 
		else if( input & KEY_DOWN ) 
			dir = DIR_DOWN; 
		else if( input & KEY_LEFT ) 
			dir = DIR_LEFT; 
		else if( input & KEY_RIGHT ) 
			dir = DIR_RIGHT; 
	 
		if( input & KEY_DIRECTION ) 
		{ 
			if( m_dir == dir ) 
				Move(); 
			else 
				ChangeDirection( dir ); 
		} 
	} 
 
	if( input & KEY_FIRE ) 
		return Fire(); 
 
	return FALSE; 
} 
 
 
void CPlayer::Reborn() 
{  
	m_active = TRUE; 
	m_bShield = TRUE; 
	m_bBoring = TRUE; 
	m_bLocked = FALSE; 
	m_bore.m_x = m_x - 2; 
	m_bore.m_y = m_y - 2; 
	m_bore.Bore(); 
	m_shieldTime = timeGetTime(); 
	m_dir = DIR_UP; 
	m_speed = 1.0f; 
} 
 
 
 
void CPlayer::Draw( LPDIRECTDRAWSURFACE pdds ) 
{ 
	if( !m_active ) 
		return; 
	 
	if( m_bBoring ) 
	{ 
		m_bore.Draw( pdds ); 
		if( timeGetTime() - m_shieldTime > 800 ) 
		{ 
			m_bBoring = FALSE; 
			Shield( 3000 ); 
		} 
		return; 
	} 
 
	if( m_bLocked ) 
	{ 
		if( timeGetTime() - m_flickerTime > 200 ) 
		{ 
			m_bShow = !m_bShow; 
			m_flickerTime = timeGetTime(); 
		} 
		else if( timeGetTime() - m_shieldTime > 5000 ) 
			m_bLocked = FALSE; 
	} 
	 
	if( !m_bLocked || m_bShow ) 
	{ 
		RECT rc; 
		rc.left = (m_type * 2 + m_frame) * m_width; 
		rc.top = (int)m_dir * m_height; 
		rc.right = rc.left + m_width; 
		rc.bottom = rc.top + m_height; 
		int x = (int)m_x + OFFSETX; 
		int y = (int)m_y + OFFSETY; 
 
		pdds->BltFast( x, y, m_bmp, &rc, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT ); 
	} 
		 
	if( m_bShield ) 
		DrawShield( pdds ); 
	m_bullet[0].Draw( pdds ); 
	m_bullet[1].Draw( pdds ); 
}