gm_object.cpp

混乱竞技场的全套代码,客户端资源可以网上搜

// GM_Object.cpp: implementation of the GM_Object class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GM_Object.h"

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


GM_Object::GM_Object(GM_World* pWorld)
{
	assert(pWorld!=NULL);
	m_pWorld	= pWorld;
//	m_pWorld->AddObject(this);

	m_fPosX		= 0;
	m_fPosY		= 0;

	m_FlatX	= 0;
	m_FlatY	= 0;


	m_fZbuf		= 1.0f;

	m_force		= -1;

	m_gridX		= 0;
	m_gridY		= 0;

	m_bRender	= true;

	m_isDismiss	= false;

	for(int i=0; i<16; i++)
		m_relation[i]	= GSRELATION_NONE;

	SetSeize(32);//pWorld->GetCellWidth());


	m_pAnimation	= NULL;
	m_age						= 0;
	m_current_age				= 0;
	m_gscm						= GSCM_NO_CHANGE;


	m_current_alpha				=1.0f;
	m_current_scale				=1.0f;
	m_rotation					=1.0f;

	m_color						= RGB(128,128,128);

	m_speedX					= 0;
	m_speedY					= 0;
	m_speedH					= 0;
	m_acceleration				= 0;
	m_dest_posX					= 0;
	m_dest_posY					= 0;
	m_dest_posH					= 0;

	m_speed_rate				= 1.0f;

	m_flag					= GSSPR_NONE;

	m_pAnimation				= NULL;
	m_is_indispensable			= FALSE;
}

GM_Object::~GM_Object()
{
	Cleanup();
}

VOID GM_Object::Cleanup()
{


}




VOID GM_Object::SetSeize(FLOAT fSeize)
{
	if(fSeize<m_pWorld->GetCellWidth())
	{
		fSeize	= m_pWorld->GetCellWidth();
	}
	m_seize_x	= fSeize;
	m_seize_y	= fSeize/m_pWorld->GetCellRate();
}

BOOL GM_Object::TestSeize(LONG nX, LONG nY)
{
	m_pWorld->GridCenter(nX,nY);
	float a = (m_FlatX-nX)/m_seize_x;
	float b = (m_FlatY-nY)/m_seize_y;
	return (a*a + b*b <= 1);
}

BOOL GM_Object::TestRange(float fRange, LONG nX, LONG nY)
{
	float a = (m_FlatX-nX)/fRange;
	float b = (m_FlatY-nY)*m_pWorld->GetCellRate()/fRange;
	return (a*a + b*b <= 1);
}
BOOL GM_Object::TestRangeGrid(float fRange, LONG nX, LONG nY)
{
	m_pWorld->GridCenter(nX,nY);
	float a = (m_FlatX-nX)/fRange;
	float b = (m_FlatY-nY)*m_pWorld->GetCellRate()/fRange;
	return (a*a + b*b <= 1);
}

BOOL GM_Object::TestRange(float fRange, GM_Object* pObject)
{
	assert(NULL!=pObject);
	float a = (m_FlatX-pObject->m_FlatX)/(fRange);
	float b = (m_FlatY-pObject->m_FlatY)*m_pWorld->GetCellRate()/fRange;
	return (a*a + b*b <= 1);
}

VOID GM_Object::UpdateRoughPos()
{
	m_fPosX	= m_FlatX;
	m_fPosY	= m_FlatY+m_fHeight*2.0f;
}

VOID GM_Object::SetAlly(LONG force)
{
	if(force>15)
		return;
	m_relation[force] &= 0xfffffff0;
	m_relation[force] |= GSRELATION_ALLY;
}

VOID GM_Object::SetEnemy(LONG force)
{
	if(force>15)
		return;
	m_relation[force] &= 0xfffffff0;
	m_relation[force] |= GSRELATION_ENEMY;
}

DWORD GM_Object::GetZValue()
{
	return m_fZbuf*0xffff;
}


int GM_Object::SetDirectionFrame(int frame_in_direction, int direction)
{
	if(m_pAnimation)
	{
		return m_pAnimation->SetDirectionFrame(frame_in_direction);
	}
	else
	{
		return 0;
	}
}


VOID GM_Object::SetFaceToPoint( float f_look_at_x, float f_look_at_y, int frame_in_direction)
{
//	m_time_base	= 0;
	float	f_angle	;
	if(f_look_at_x==0)
	{
		if(f_look_at_y==0)
		{
			return;
		}
		else if(f_look_at_y>0)
			f_angle	= const_PI_DIV_2;
		else if(f_look_at_y<0)
			f_angle	= -const_PI_DIV_2;
	}
	else
	{
		f_angle	= atan(f_look_at_y/f_look_at_x);
	}

	if(f_look_at_x<0)
	{
		f_angle += const_PI;
	}
	else if(f_angle<0)
	{
		f_angle += const_2_PI;
	}

	if(m_pAnimation)
	{
		m_pAnimation->SetFaceTo(f_angle);
		if(frame_in_direction!=GSANI_FRAME_NOCHANGE)
		{
			m_pAnimation->SetDirectionFrame(frame_in_direction);
		}
	}
}

VOID GM_Object::SetFaceToAngle( float degree, int frame_in_direction)
{
	if(m_pAnimation)
	{
		m_pAnimation->SetFaceToDegree(degree);
		if(frame_in_direction!=GSANI_FRAME_NOCHANGE)
		{
			m_pAnimation->SetDirectionFrame(frame_in_direction);
		}
	}
}


VOID GM_Object::RunSpriteWait(int frame_in_direction, int act_count)
{

//	if(-1==SetDirectionFrame(frame_in_direction))
//	{
//		m_act_count	= 0;
//	}
//	else
//	{
//		if(act_count!=GSANI_ACT_COUNT_NOCHANGE)
//			m_act_count	= act_count;
//	}
	SetDirectionFrame(frame_in_direction);

	m_speedX					= 0;
	m_speedY					= 0;
	m_speedH					= 0;
	m_dest_posX					= m_fPosX;
	m_dest_posY					= m_fPosY;
	m_dest_posH					= m_fHeight;
	if(m_pAnimation)
	{
		m_pAnimation->Play(GS_ANI_PLAY_LOOP, FALSE, act_count);
	}

	m_flag	= GSSPR_KEY_FRAME_MEET;
}

VOID GM_Object::RunSprite(int frame_in_direction, int act_count)
{
	SetDirectionFrame(frame_in_direction);
	if(m_pAnimation)
	{
		m_pAnimation->Play(GS_ANI_PLAY_LOOP, FALSE, act_count);
	}
}


VOID GM_Object::RunSpriteMove( float degree, float speed_pps, float distance, BOOL bUpdateFaceTo, int frame_in_direction, int act_count)
{
//	m_time_base	= 0;
	if(bUpdateFaceTo)
		SetFaceToAngle(degree, frame_in_direction);

	m_dest_posH	= m_fHeight;
	m_speedX	= speed_pps*cos(D3DXToRadian(degree));
	m_speedY	= speed_pps*sin(D3DXToRadian(degree));
	m_speedH	= 0;
	if(m_pAnimation)
	{
		m_pAnimation->Play(GS_ANI_PLAY_LOOP, FALSE, act_count);
	}

	if(distance>0)
	{
		m_dest_posX	= m_FlatX + distance*cos(D3DXToRadian(degree));
		m_dest_posY	= m_FlatY + distance*sin(D3DXToRadian(degree));
		m_flag	= GSSPR_ARRIVE_MEET | GSSPR_KEY_FRAME_MEET | GSSPR_MOVE;
	}
	else
	{
		m_dest_posX	= 0;
		m_dest_posY	= 0;
		m_flag	= GSSPR_KEY_FRAME_MEET | GSSPR_MOVE;
	}
}

VOID GM_Object::RunSpriteMoveTo( float f_dest_x, float f_dest_y, float speed_pps, BOOL bUpdateFaceTo, int frame_in_direction, int act_count)
{
//	m_time_base	= 0;
	
	float d		= sqrt((f_dest_x - m_FlatX)*(f_dest_x - m_FlatX) + (f_dest_y - m_FlatY)*(f_dest_y - m_FlatY));
	float sx,sy;
	if(d==0)
	{
		sx	= 0;
		sy	= 0;
	}
	else
	{
		sx	= (f_dest_x - m_FlatX)*speed_pps/d;
		sy	= (f_dest_y - m_FlatY)*speed_pps/d;
	}
	if(bUpdateFaceTo)
		SetFaceToPoint(sx, sy, frame_in_direction);

	m_dest_posX	= f_dest_x;
	m_dest_posY	= f_dest_y;
	m_dest_posH	= m_fHeight;
	m_speedX	= sx;
	m_speedY	= sy;
	m_speedH	= 0;
	if(m_pAnimation)
	{
		m_pAnimation->Play(GS_ANI_PLAY_LOOP, FALSE, act_count);
	}

	m_flag	= GSSPR_ARRIVE_MEET | GSSPR_KEY_FRAME_MEET | GSSPR_MOVE;
}

VOID GM_Object::RunSpriteThrowTo(float f_dest_x, float f_dest_y, float f_dest_h, float f_speed_pps, float f_acceleration, int frame_in_direction, int act_count)
{
	float d		= sqrt((f_dest_x - m_FlatX)*(f_dest_x - m_FlatX) + (f_dest_y - m_FlatY)*(f_dest_y - m_FlatY));
	float sx,sy;
	if(d==0)
	{
		sx	= 0;
		sy	= 0;
	}
	else
	{
		sx	= (f_dest_x - m_FlatX)*f_speed_pps/d;
		sy	= (f_dest_y - m_FlatY)*f_speed_pps/d;
	}
	SetFaceToPoint(sx, sy, frame_in_direction);

	m_dest_posX	= f_dest_x;
	m_dest_posY	= f_dest_y;
	m_dest_posH	= m_fHeight;
	m_speedX	= sx;
	m_speedY	= sy;
	if(m_pAnimation)
	{
		m_pAnimation->Play(GS_ANI_PLAY_LOOP, FALSE, act_count);
	}

	float t		= d/f_speed_pps;
	m_acceleration	= f_acceleration;
	m_speedH	= (f_dest_h-m_fHeight)/t + 0.5f*f_acceleration*t;

	
	m_flag	= GSSPR_ARRIVE_MEET | GSSPR_KEY_FRAME_MEET | GSSPR_MOVE | GSSPR_THROW;
}

VOID GM_Object::RunSpriteThrow(float f_dest_x, float f_dest_y, float f_speed_pps, float f_speed_ppsH, float f_acceleration, int frame_in_direction, int act_count)
{
	float d		= sqrt((f_dest_x - m_FlatX)*(f_dest_x - m_FlatX) + (f_dest_y - m_FlatY)*(f_dest_y - m_FlatY));
	float sx,sy;
	if(d==0)
	{
		sx	= 0;
		sy	= 0;
	}
	else
	{
		sx	= (f_dest_x - m_FlatX)*f_speed_pps/d;
		sy	= (f_dest_y - m_FlatY)*f_speed_pps/d;
	}
	SetFaceToPoint(sx, sy, frame_in_direction);

	m_dest_posX	= f_dest_x;
	m_dest_posY	= f_dest_y;
	m_dest_posH	= m_fHeight;
	m_speedX	= sx;
	m_speedY	= sy;

	m_acceleration	= f_acceleration;
	m_speedH	= f_speed_ppsH;
	if(m_pAnimation)
	{
		m_pAnimation->Play(GS_ANI_PLAY_LOOP, FALSE, act_count);
	}
	
	m_flag	= GSSPR_ARRIVE_MEET | GSSPR_KEY_FRAME_MEET | GSSPR_MOVE | GSSPR_THROW;
}




LONG GM_Object::Update()
{
	LONG ret	= 0;
	if(m_pWorld==NULL || m_pWorld->GetGsEngine()==NULL)
		return -1;
	if(!m_is_indispensable && !m_pWorld->TestActiveRange(m_fPosX, m_fPosY))
	{
		return ret;
	}

	if(m_pAnimation)
	{
		FLAG flag	= m_pAnimation->Update();
		if(flag==GS_ANI_UPDATE_FINISH)
		{
			ret |= GSSPR_KEY_FRAME_MEET;
		}
	}



	float fSec	= m_pWorld->GetGsEngine()->m_dwPassTime/1000.0f;

	if((m_flag & GSSPR_MOVE) == GSSPR_MOVE)
	{
		if((m_flag & GSSPR_ARRIVE_MEET) != GSSPR_ARRIVE_MEET
			|| (sign(m_dest_posX - m_FlatX)==sign(m_speedX) && m_speedX!=0) 
			|| (sign(m_dest_posY - m_FlatY)==sign(m_speedY) && m_speedY!=0))
			//|| (SIGN(m_dest_posH - m_fHeight)==SIGN(m_speedH) && m_speedH!=0))
		{
			if((m_flag & GSSPR_THROW) == GSSPR_THROW)
			{
				m_speedH	-= m_acceleration*fSec;
			}
			m_FlatX	+= m_speedX*m_speed_rate*fSec;
			m_FlatY	+= m_speedY*m_speed_rate*fSec;
			m_fHeight	+= m_speedH*m_speed_rate*fSec;
		}
		else
		{
			m_FlatX	= m_dest_posX;
			m_FlatY	= m_dest_posY;
			m_fHeight	= m_dest_posH;
			m_speedX=0;
			m_speedY=0;
			m_speedH=0;
			if((m_flag & GSSPR_ARRIVE_MEET) == GSSPR_ARRIVE_MEET)
				ret |= GSSPR_ARRIVE_MEET;
		}
	}

//	D3DVECTOR vt(m_FlatX, m_FlatY, m_FlatY);
//	m_particle_effect.Update();
//	m_particle_effect.SetLocation(vt);


	if((m_flag & GSSPR_AGE_MEET) == GSSPR_AGE_MEET)
	{
		m_current_age	-= m_pWorld->GetGsEngine()->m_dwPassTime;
		if(m_current_age<=0)
		{
			m_age = 0;
			ret |= GSSPR_AGE_MEET;
		}
		else
			m_current_alpha	= (float)m_current_age/(float)m_age;
	}
	if((m_flag & GSSPR_COLOR_MODIFIER) == GSSPR_COLOR_MODIFIER)
	{
		D3DVECTOR color = D3DVECTOR(rnd(), rnd(), rnd());
		switch(m_gscm)
		{
			case 	GSCM_FULL_SATURATION:
				color /= Max(color);
				break;
			case 	GSCM_JEWEL_TONES:
				color -= Min(color);
				color /= Max(color);
				break;
			case 	GSCM_PASTELS:
				color -= Min(color);
				color /= Max(color);
				color = D3DVECTOR(0.6f) + 0.4f * color;

				break;
			case 	GSCM_BRIGHTER:
				color *= 1.2f;

				break;
			case 	GSCM_DARKER:
				color *= 0.2f;
				break;
			default:
				break;
		}
		m_color = D3DRGB(color[0], color[1], color[2]);
	}
	return ret;
}





CGsAnimation* GM_Object::GetAnimation()
{
	return m_pAnimation;
}


VOID GM_Object::RunSparkAge(int age)
{
	m_age	= age;
	m_current_age	= age;
	m_flag	|=	GSSPR_AGE_MEET;
}

VOID GM_Object::RunSparkGSCM(GSCM gscm)
{
	m_gscm	= gscm;
	m_flag	|=	GSSPR_COLOR_MODIFIER;
}



VOID GM_Object::SetSprite(GSANI*	pAnimation)
{
	assert(pAnimation!=NULL);
	if(!pAnimation->IsReady())
		return;
	if(pAnimation == m_pAnimation)
		return;

	if(m_pAnimation)
	{
		m_pAnimation->SetCurrentUse(FALSE);
		pAnimation->AttachAni(m_pAnimation);
//		m_pAnimation->ReleaseObjects();
	}
	m_pAnimation			= pAnimation;
	m_pAnimation->SetCurrentUse(TRUE);
	m_color						= RGB(128,128,128);

}

VOID GM_Object::SetSprite(float posX, float posY, float posH, GSANI*	pAnimation, DWORD dwFrameDelay)
{
	assert(pAnimation!=NULL);

	if(!pAnimation->IsReady())
		return;

	m_fPosX					= posX;
	m_fPosY					= posY;
	m_fHeight				= posH;
	m_speedX				= 0;
	m_speedY				= 0;
	m_speedH				= 0;
	m_dest_posX				= posX;
	m_dest_posY				= posY;
	m_dest_posH				= posH;
	m_color						= RGB(128,128,128);

	if(dwFrameDelay>0)
		pAnimation->SetFrameDelay(dwFrameDelay);

	if(m_pAnimation)
	{
		m_pAnimation->SetCurrentUse(FALSE);
		pAnimation->AttachAni(m_pAnimation);
	}
	
	m_pAnimation			= pAnimation;
	m_pAnimation->SetCurrentUse(TRUE);
}






float GM_Object::GetFaceToDegree()
{
	if(m_pAnimation)
	{
		return m_pAnimation->GetAngleFaceToDegree();
	}
	else
	{
		return 0;
	}
}

void GM_Object::SetParticleEffect(const char *strEff)
{
	if(m_pWorld)
	{
//		m_particle_effect.SetGsEngine(m_pWorld->GetGsEngine());
//		m_particle_effect.Create(strEff);
	}
}


void GM_Object::SetArriveMeet()
{
	m_FlatX	= m_dest_posX;
	m_FlatY	= m_dest_posY;
	m_fHeight	= m_dest_posH;
	m_speedX=0;
	m_speedY=0;
	m_speedH=0;
	ClearFlag(GSSPR_MOVE);
}