player.cpp

网络泡泡被.net管理

// Player.cpp: implementation of the CPlayer class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Player.h"

#define CONST_GRAVITY	90.0F

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPlayer::CPlayer(CGsEngine*	pEngine)
{
	m_pEngine	= pEngine;
	m_angle		= const_PI_DIV_2;

	m_ap_bubble	= NULL;

	m_ptr_bubble_current	= NULL;
	m_ptr_bubble_next	= NULL;
	m_scale	= 1.0f;
	memset(&m_control_pointer, 0, sizeof(m_control_pointer));

	m_ptr_texture_score	= NULL;
	m_ptr_texture_state	= NULL;
	m_is_end	= false;
	m_is_scene_shaking	= FALSE;
	m_is_shoot_shaking	= FALSE;
	m_tick_power_shooter	= 0;
	m_tick_lost_control		= 0;
	m_tick_blind			= 0;
}

CPlayer::~CPlayer()
{
}
void CPlayer::Clearup()
{
	if(m_ap_bubble)
	{
		for(int i=0; i<m_width*m_height; i++)
		{
			if(m_ap_bubble[i])
				delete(m_ap_bubble[i]);
		}
	}
	std::list<CBubble*>::iterator	it = m_lst_pop.begin();
	while (m_lst_pop.end()!=it)
	{
		if(*it)
			delete(*it);
		it	= m_lst_pop.erase(it);
	}
	std::list<_FALL_BUBBLE>::iterator	it_f = m_lst_spread.begin();
	while (m_lst_spread.end()!=it_f)
	{
		if(it_f->p_bubble)
			delete(it_f->p_bubble);
		it_f	= m_lst_spread.erase(it_f);
	}
	SAFE_DELETE(m_ptr_bubble_current);
	SAFE_DELETE(m_ptr_bubble_next);
	m_angle		= const_PI_DIV_2;
	m_ap_bubble	= NULL;
	m_ptr_bubble_current	= NULL;
	m_ptr_bubble_next	= NULL;
//	m_scale	= 1.0f;
	SAFE_DELETE(m_ptr_texture_score);
	SAFE_DELETE(m_ptr_texture_state);
	BubbleScene::Clearup();
	std::list<_EFFECT_TIP>::iterator it_et	= m_lst_effect_tip.begin();
	while (it_et!=m_lst_effect_tip.end())
	{
		SAFE_DELETE(it_et->pTexture);
		it_et	= m_lst_effect_tip.erase(it_et);
	}
	m_is_end	= false;
	m_tick_power_shooter	= 0;
	m_tick_lost_control		= 0;
	m_tick_blind			= 0;

}

bool CPlayer::Create(uint8 width, uint8 height)
{
	if(m_pEngine==NULL)
		return FALSE;
	bool bRet	= BubbleScene::Create(width, height);
	m_ani_pointer.SetGsEngine(m_pEngine);
	m_ani_pointer.Create("crossbow.txg");
	m_ani_ready.SetGsEngine(m_pEngine);
	m_ani_ready.Create("ready.txg");
	m_ani_effect_blind.SetGsEngine(m_pEngine);
	m_ani_effect_blind.Create("ani\\confusion.txg");
	m_ani_effect_blind.Play();
	m_ani_face.SetGsEngine(m_pEngine);
	m_ani_face.Create(g_get_str_shows_res(0));
	if(bRet)
	{
		m_ap_bubble	= new CBubble*[width*height];
		memset(m_ap_bubble, 0, sizeof(CBubble*)*width*height);
	}
	return bRet;
}


HRESULT CPlayer::Render(LONG x, LONG y)
{
	GRECT rc(x-m_scale*GetCol(), y-m_scale*(GetHeight()+1),x+m_scale*GetCol(), y + m_scale);

	m_pEngine->PreparePaint();
	m_pEngine->Render_DrawRectEx(&rc, TRUE,
								 D3DRGBA(0.0f, 0.0f, 0.3f, 0.5f), D3DRGBA(0.0f, 0.0f, 0.3f, 0.5f),
								 D3DRGBA(0.0f, 0.0f, 0.3f, 0.8f), D3DRGBA(0.0f, 0.0f, 0.3f, 0.8f));

	if(m_ptr_texture_state)
	{
		m_pEngine->Render_Paint(x, y - (m_fHeight+5.32f)*m_scale , m_ptr_texture_state, 1.0f, m_scale/MAIN_SCALE, m_scale/MAIN_SCALE);
	}
	CGsTexture* pTex;
	pTex	= m_ani_face.GetCurrentFrame();
	if(pTex)
	{
		float fa = 1.0f;
		if (m_state==PLAYER_STATE_LOST || m_state==PLAYER_STATE_WIN || m_state==PLAYER_STATE_PLAYING)
		{
			fa	= 0.25f;
		}
		pTex->UpdateFromCache();
		m_pEngine->Render_ClipPaintFast(x - pTex->GetWidthEx()/2, 
										y - pTex->GetHeightEx() - (m_scale*GetHeight() - pTex->GetHeightEx())/2, 
										rc, pTex, 1.0f, 1.0f, 1.0f, fa);
		float fr = m_scale/MAIN_SCALE;
		GRECT rc_face(x + m_scale*m_width - 50*fr, y - (m_fHeight+1.22f)*m_scale - 5 - 55*fr,
					  x + m_scale*m_width, y - (m_fHeight+1.22f)*m_scale - 5);
		//m_pEngine->Render_DrawRect(&rc_face, TRUE);
		m_pEngine->Render_ClipPaintFast(rc_face.left - 46*fr, 
										rc_face.top - 52*fr, 
										rc_face, pTex, 1.0f, fr, fr);
	}

	if (m_state==PLAYER_STATE_LOST || m_state==PLAYER_STATE_WIN || m_state==PLAYER_STATE_PLAYING)
	{
		m_pEngine->PreparePaint(D3DBLEND_SRCCOLOR, D3DBLEND_ONE);
		for(int i=0; i<m_height*m_width; i++)
		{
			float fshake = 0;
			if (m_is_scene_shaking && m_state==PLAYER_STATE_PLAYING)
			{
				fshake = m_pEngine->ValueCycle(-0.1*m_scale, 0.1*m_scale, 0, 100);
			}
			if(m_ap_bubble[i])
			{
				m_ap_bubble[i]->Render(x, y+fshake, m_scale);
			}
		}
		std::list<CBubble*>::iterator	it_b = m_lst_pop.begin();
		while (m_lst_pop.end()!=it_b)
		{
			if(*it_b)
			{
				(*it_b)->Render(x, y, m_scale);
			}
			it_b++;
		}
		std::list<_FALL_BUBBLE>::iterator	it_f = m_lst_spread.begin();
		while (m_lst_spread.end()!=it_f)
		{
			if(it_f->p_bubble)
			{
				it_f->p_bubble->Render(x, y, m_scale);
			}
			it_f++;
		}	
	}
	{//render shooter
		m_pEngine->PreparePaint();
		float	fr = 0.5f;
		if (IsSuperShooter())
		{
			if (m_pEngine->m_dwEngineTime < m_tick_power_shooter + TIME_KEEP_SUPER_SHOOTER - 2000)
				fr	= m_pEngine->ValueCycle(0.60f, 1.0f, m_tick_power_shooter, 120);
			else
				fr	= m_pEngine->ValueCycle(0.5f, 1.0f, m_tick_power_shooter, 60);
			STRUCT_SHOOT_DATA shoot;
			shoot.x_org	= 0;
			shoot.y_org	= 0;
			shoot.shoot_cmd	= 0;
			shoot.bubble	= 0;
			shoot.ftan	= tan(m_angle);
			CaleShoot(shoot);
			float f_dif		= 0.2f*sin(m_angle);
			float f_y = m_pEngine->ValueLoop(0, f_dif*2, m_tick_power_shooter, 1000);
			while (f_y<shoot.f_stop)
			{
				m_pEngine->Render_DrawLine(x + TrackFun(&shoot, f_y)*m_scale, y - f_y*m_scale,
										   x + TrackFun(&shoot, f_y+f_dif)*m_scale, y - (f_y+f_dif)*m_scale,
										   D3DRGBA(1.0f, 1.0f, 1.0f, 0.7f)
										   );
				f_y += f_dif;
				f_y += f_dif;
			}
		}
		m_ani_pointer.Draw(x, y, 0.0f, m_scale/17, m_scale/17, 1.0f, const_PI_DIV_2-m_angle, D3DRGBA(fr, fr, fr, 1.0f));
		if (IsSuperShooter())
		{
			float	fs = m_pEngine->ValueLoop(0.99f, 2.6f, m_tick_power_shooter, 700);
			m_ani_pointer.Draw(x, y, 0.0f, m_scale/17*fs, m_scale/17*fs, 0.8f-fs/3.0f, const_PI_DIV_2-m_angle);
		}
		m_pEngine->PreparePaint(D3DBLEND_SRCCOLOR, D3DBLEND_ONE);
	}
	BOOL bBlind	= IsBlind();
	if(m_ptr_bubble_next)
		m_ptr_bubble_next->Render(x, y, m_scale, !bBlind);
	if(m_ptr_bubble_current)
	{
		float fshake = 0;
		if (m_is_shoot_shaking && m_state==PLAYER_STATE_PLAYING)
		{
			fshake = m_pEngine->ValueCycle(-0.1*m_scale, 0.1*m_scale, 0, 100);
		}
		m_ptr_bubble_current->Render(x, y+fshake, m_scale, !bBlind);
	}
	m_pEngine->PreparePaint();
	if (bBlind)
	{
		float fr = m_scale/MAIN_SCALE*0.5f;
		m_ani_effect_blind.Update();
		m_ani_effect_blind.Draw(x, y, 0.0f, fr, fr);
		m_ani_effect_blind.Draw(x - m_fWidth*m_scale, y, 0.0f, fr, fr);
	}
	if(m_state==PLAYER_STATE_LOST || m_state==PLAYER_STATE_WIN)
	{
		m_pEngine->Render_LightRect(&rc, 
									 0.6f);
	}

	m_pEngine->PreparePaint();
	if(m_ptr_texture_score && (m_state==PLAYER_STATE_LOST || m_state==PLAYER_STATE_WIN))
	{
		m_pEngine->Render_Paint(x, y - m_fHeight/2*m_scale, m_ptr_texture_score, 0.0f, m_scale/3, m_scale/3, 1.0f, 0.0f);
		
	}

	if (m_state==PLAYER_STATE_READY)
	{
		float a	= m_pEngine->ValueLoop(0, 8, 0, 8, 400);
		float scale;
		if (a==0)
		{
			scale = m_pEngine->ValueCycle(1, 1.15f, 0, 100);
		}
		else
		{
			scale = 1;
		}
		m_ani_ready.Draw(x, y - m_fHeight/3*m_scale, 0.0f, m_scale/6*scale, m_scale/6*scale, 1.0f, 0);
	}

	std::list<_EFFECT_CARDS>::iterator it_ec = m_lst_effect_cards.begin();
	float fsign = 1;
	while (it_ec!=m_lst_effect_cards.end())
	{
		if (m_pEngine->m_dwEngineTime - it_ec->tick >= 1000)
		{
			it_ec	= m_lst_effect_cards.erase(it_ec);
			continue;
		}
		float fs = it_ec->scale;
		float	fa = it_ec->alpha;
		float fy = it_ec->ay;
		if (m_pEngine->m_dwEngineTime - it_ec->tick > 550)
		{
			//fs = m_pEngine->ValueCycle(0.0f, it_ec->scale, it_ec->tick, 1000); 
			fa = m_pEngine->ValueLoop(it_ec->alpha, 0.2f, it_ec->tick, 100); 
		}
		fy = m_pEngine->ValueLoop(it_ec->ay, it_ec->ay + fsign, it_ec->tick, 1000); 
		m_pEngine->Render_Paint(x + (it_ec->ax)*70*m_scale/MAIN_SCALE, y - m_fHeight/2*m_scale - fy*40*m_scale/MAIN_SCALE, 
								g_get_ani_card(it_ec->card_type), 
								1.0f, 
								fs*m_scale/MAIN_SCALE, 
								2.0f*m_scale/MAIN_SCALE, 
								fa,
								0.0f,
								D3DRGBA(0.5F, 0.5F, 0.5F, 1.0F));
		fsign*=-1.0f;
		it_ec++;
	}

	//画效果文字
	{
		std::list<_EFFECT_TIP>::iterator	it = m_lst_effect_tip.begin();
		while(it!=m_lst_effect_tip.end())
		{
			float fangle	= m_pEngine->ValueCycle(-const_PI_DIV_4/2, const_PI_DIV_4/2, 0, 1000);
			float fr		= m_pEngine->ValueCycle(0.3f, 0.8f, 0, 100);
			float fs		= m_pEngine->ValueCycle(0.95f*m_scale/MAIN_SCALE*it->scale, 1.05f*m_scale/MAIN_SCALE*it->scale, 0, 800)*3.5f;
#define SSE_T_0	2000
#define SSE_V_0	0.01f
			float t_	= SSE_T_0 - m_pEngine->m_dwEngineTime + it->start_time;
			if (t_>SSE_T_0)
			{
				t_ = 0;
			}
			float	fx,fy;
			if (t_>0)
			{
				fx		= it->pt_dest.x - (SSE_V_0*t_ + (it->pt_dest.x - it->pt_src.x - SSE_V_0*SSE_T_0)/SSE_T_0/SSE_T_0*t_*t_);
				fy		= it->pt_dest.y - (SSE_V_0*t_ + (it->pt_dest.y - it->pt_src.y - SSE_V_0*SSE_T_0)/SSE_T_0/SSE_T_0*t_*t_);
			}
			else
			{
				fx	= it->pt_dest.x;
				fy	= it->pt_dest.y;
			}
			m_pEngine->Render_Paint(x + fx*m_scale, y - fy*m_scale, it->pTexture, 1.0f, fs, fs, 1.0f, 0.0f, D3DRGBA(fr, fr, fr, 1.0f));
			if (t_<=0)
			{
				delete(it->pTexture);
				it	= m_lst_effect_tip.erase(it);
				continue;
			}
			it++;
		}
	}
	return S_OK;
}

FLAG CPlayer::Update()
{
	FLAG	flag_ret	= 0;
	std::list<_SHOOT_BUBBLE>::iterator it = m_lst_shoot.begin();
	float fsec	= m_pEngine->m_dwPassTime/1000.0f;
	while(it!=m_lst_shoot.end())
	{
		_SHOOT_BUBBLE* psb	= &(*it);
		if(m_ap_bubble[psb->idx]==NULL)
		{
			it = m_lst_shoot.erase(it);
			continue;
		}
		psb->y_pos += fsec*psb->y_speed;
		if(psb->y_pos>=psb->shoot.f_stop)
		{//停下
// 			SetBubble(psb->shoot.x_stop, psb->shoot.y_stop, 1);
			float	fx = psb->shoot.x_stop,
					fy	= psb->shoot.y_stop;
			GetBubbleCenter(fx,fy);
			m_ap_bubble[psb->idx]->m_pos_x	= fx;
			m_ap_bubble[psb->idx]->m_pos_y	= fy;
			//m_ap_bubble[psb->idx]->m_pos_x *= m_scale;
			//m_ap_bubble[psb->idx]->m_pos_y *= m_scale;
			m_ap_bubble[psb->idx]->SetStop(TRUE);
			if (psb->shoot.shoot_cmd%10==0)
			{
				BOOL bHasCard = FALSE;
				BYTE cards_trigger[WAY_SIZE];
				for (int i=0; i<WAY_SIZE; i++)
				{//记录触发的卡片效果
					int idx	= GetIndexAround(psb->shoot.x_stop, psb->shoot.y_stop, i);
					if (idx>=0)
					{
						if (GetBubble(idx)%10==GetBubble(psb->shoot.x_stop, psb->shoot.y_stop)%10 && GetBubble(idx)>10)
						{//有卡片
							cards_trigger[i]	= GetBubble(idx);
							bHasCard	= TRUE;
							continue;
						}
					}
					cards_trigger[i]	= 0;
				}
				int nPop = PopBubble(psb->shoot.x_stop, psb->shoot.y_stop);
				if(nPop!=psb->shoot.num_pop)
				{//同步错误，请求更新数据
					flag_ret	= -1;
				}
				if(nPop>=3)
				{
					if(num_bubble_store + nPop>255)
					{
						num_bubble_store	= 255;
					}
					else
					{
						num_bubble_store	+= nPop - 3;
					}
					if (this==g_ptr_main_game->GetPlayer())
					{
						if (bHasCard)
						{
							NET_Packet* pPacket		= new NET_Packet;
							pPacket->setCmd(GSP_TRIGGER_CARDS);
							pPacket->write32(g_ptr_main_game->m_id_player);
							pPacket->writeData(cards_trigger, WAY_SIZE);
							if(false==g_ptr_main_game->SendPacket(pPacket))
								delete pPacket;
						}
					}
					if (nPop>3)
					{
						char str[50];
						sprintf(str, "+%d", nPop-3);
						add_effect_tip(str, 
										GPOINT(fx,fy),
										GPOINT(-GetWidth()-1, GetHeight()),
										RGBA_MAKE(0, 255, 0, 200),
										1.0f
										);
					}
				}
				if (nPop==0 && m_scale==MAIN_SCALE)
				{
					g_ptr_main_game->play_sound("bubble_sound\\stop");
				}
			}
			else
			{
			}
			it = m_lst_shoot.erase(it);
			continue;
		}
		m_ap_bubble[psb->idx]->m_pos_x	= TrackFun(&psb->shoot, psb->y_pos);
		m_ap_bubble[psb->idx]->m_pos_y	= psb->y_pos;
		it++;
	}

	std::list<CBubble*>::iterator	it_b = m_lst_pop.begin();
	while (m_lst_pop.end()!=it_b)
	{
		if(*it_b)
		{
			(*it_b)->m_alpha	-= fsec*2.5;
			if((*it_b)->m_alpha<=0.0f)
			{
				delete(*it_b);
				it_b	= m_lst_pop.erase(it_b);
			}
		}
		it_b++;
	}
	std::list<_FALL_BUBBLE>::iterator	it_f = m_lst_spread.begin();
	while (m_lst_spread.end()!=it_f)
	{
		if(it_f->p_bubble)
		{
			float t = sqrt(2*(it_f->h - it_f->p_bubble->m_pos_y)/CONST_GRAVITY) + it_f->fall*fsec;
			if(t<0.0f)
				t = 0.0f;
			it_f->p_bubble->m_pos_y	= it_f->h - 0.5f*CONST_GRAVITY*t*t;
			it_f->p_bubble->m_pos_x	+= it_f->v_x*fsec;
			if(it_f->p_bubble->m_pos_x>m_fWidth)
			{
				it_f->p_bubble->m_pos_x -= it_f->p_bubble->m_pos_x - m_fWidth;
				it_f->v_x	= - it_f->v_x;
			}
			if(it_f->p_bubble->m_pos_x<-m_fWidth)
			{
				it_f->p_bubble->m_pos_x += -it_f->p_bubble->m_pos_x - m_fWidth;
				it_f->v_x	= - it_f->v_x;
			}

			if(it_f->fall>0 && it_f->p_bubble->m_pos_y<=0)
			{
				it_f->p_bubble->m_pos_y	= 0;
				it_f->fall	= -it_f->fall;
				it_f->h		*= 0.6 + rnd()*0.2;
				if(rnd()>0.3)
				{
					//if (m_scale==MAIN_SCALE)
					//{
					//	g_ptr_main_game->play_sound("bubble_sound\\pop");
					//}
					m_lst_pop.push_back(it_f->p_bubble);
					it_f	= m_lst_spread.erase(it_f);
					continue;
				}
			}
			else if(it_f->fall<0 && it_f->p_bubble->m_pos_y>=it_f->h)
			{
				it_f->p_bubble->m_pos_y	= it_f->h;
				it_f->fall	= -it_f->fall;
			}
		}
		else
		{
			it_f	= m_lst_spread.erase(it_f);
			continue;
		}
		it_f++;
	}

	if (GetState()==PLAYER_STATE_PLAYING)
	{
		if (IsLostControl())
		{
			m_angle	= m_pEngine->ValueCycle(0.2f, const_PI - 0.2f, m_tick_lost_control, 1500);
		}
		else
		{
		//更新指针指向
			if(m_control_pointer.key==1)
			{
				float	ft = (m_pEngine->m_dwEngineTime-m_control_pointer.tick_base)/1000.0f;
				if(ft>0.2f)
				{	
					m_angle	= m_control_pointer.angle_base + (ft-0.2f)*2.2f + 0.24f;
				}
				else
				{
					m_angle	= m_control_pointer.angle_base + 0.5f*10.0f*ft*ft + 0.2f*ft;
				}
				if(m_angle>const_PI - 0.2f)
					m_angle = const_PI - 0.2f;
					
			}
			else if(m_control_pointer.key==2)
			{
				float	ft = (m_pEngine->m_dwEngineTime-m_control_pointer.tick_base)/1000.0f;
				if(ft>0.2f)
				{	
					m_angle	= m_control_pointer.angle_base - (ft-0.2f)*2.2f - 0.24f;
				}
				else
				{
					m_angle	= m_control_pointer.angle_base - 0.5f*10.0f*ft*ft - 0.2f*ft;
				}