chvrmltransition.cpp

Windows上的MUD客户端程序

		return false;
	}
	else 
	{
		//TRACE3("Left Clicked. x = %d, y = %d, flags = %lx\n", m_ix, m_iy, m_mouseFlags);
		OnLeftClick(m_ix, m_iy, m_mouseFlags);
		return true;
	}
};	   

bool ChVrmlWalkSTM::LeftClickSlow()
{
	//TRACE1("Click time : %d\n", GetElapsedPressTicks() < maxClickTicks);
	if(IsWithinFastClickTime())
	{
		return LeftClick();
	}
	return true;
};	   


bool ChVrmlWalkSTM::RightClick()
{
	OnRightClick(m_ix, m_iy, m_mouseFlags);
	return true;
};	   

bool ChVrmlWalkSTM::RightClickSlow()
{
	if(m_mouseAvgVelocity.magnitude() > spinThresholdSpeed)
	{
		SetState(s_spinningBegin);
		return false;
	}                               
	else if(IsWithinFastClickTime())
	{
		return RightClick();
	}
	return true;
};	   

bool ChVrmlWalkSTM::GoTowardsStart()
{
#if !defined(CH_USE_3DR)
	GxVec3f	target;
	bool boolHit = m_pWnd->GetRenderContext()->GetHitPoint(m_ix, m_iy, target);

	if(boolHit)
	{
		RecordTime();
		//m_pWnd->GetCameraControl()->LookAt( target, false );	  // Turn towards it
		m_pWnd->GetCameraControl()->HeadsUp( );	  
		m_target = target;

		GxVec3f	camLoc = m_pWnd->GetRenderContext()->GetCameraLoc();
		target += camLoc;
		target *= .5;					// Go halfway there, not keeping y constant
		//target.y() = camLoc.y();		   

		m_startLook = ((ChQvPCameraRenderData *)(m_pWnd->GetRenderContext()->GetCurrentCamera()->GetRenderData()))->GetDir();
		m_destination = target;
		m_start = camLoc;
	}
	else
	{
		if(GetKeyState( VK_MENU ) & 0x8000) SetState(s_alt);
		else SetState(s_start);
		return false;
	}
#endif
	return true;
}

bool ChVrmlWalkSTM::GoTowards()
{
#if !defined(CH_USE_3DR)
	GxVec3f	camLoc = m_pWnd->GetRenderContext()->GetCameraLoc();
	GxVec3f	target = m_target;
	GxVec3f	start = m_start;
	GxVec3f	destination = m_destination;

	float perCent = GetElapsedTicks() / float(animMoveTowardsTicks);	// how far we 'oughta' be
	if(GetKeyState( VK_SHIFT ) & 0x8000) perCent *= 2;

	perCent = min(perCent, 1.0);
	perCent = Smooth(perCent);

	//camLoc.y() = destination.y() = start.y() = 0;	// ignore y

	GxVec3f v = destination;
	v -= start;			// vector to move total
	v *= perCent;		// vector we should have moved
	v += start;			// where we oughta be
	v -= camLoc;		// how far we have to go, vectorish

	// Now compute the new lookDirection; linearly interpolate from original
	// look direction to final, which is staring right at target
	GxVec3f startLook = m_startLook;

	GxVec3f endLook = m_target;
	endLook -= m_destination;
	endLook.normalize();

	startLook *= (1.0 - perCent);
	endLook *= perCent;

	GxVec3f lookDir = endLook;
	lookDir += startLook;

	lookDir.normalize;

	m_pWnd->GetCameraControl()->Shift( v.x(), v.y(), v.z(), false );
	m_pWnd->GetCameraControl()->SetLookDir( lookDir, false );	  // Turn towards it
	m_pWnd->GetCameraControl()->HeadsUp( );	  

	if(perCent >= 1.0)
	{
		if(GetKeyState( VK_MENU ) & 0x8000) SetState(s_alt);
		else SetState(s_start);
		return false;
	}
#endif
	return true;

}




// --------------------------------------------------------------------------
// Flier
// --------------------------------------------------------------------------

ChVrmlFlySTM::ChVrmlFlySTM(ChMazeWnd *pWnd) : ChVrmlStateTransition(pWnd) 
{
	Init();
}

void ChVrmlFlySTM::Init()
{

	// Now populate the STM
	// SetCell( int iState, int iEvent, int iNewState, ChTransitionActionHandler action)

	AddCell(s_start,	ep_alt,		s_alt, 		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_alt,		er_alt,		s_start, 	ChVrmlFlySTM,	DefaultHandler);
				
	// --			
	AddCell(s_start,	ep_up,		s_up, 		ChVrmlFlySTM,	TurnUpStart);
	AddCell(s_up, 		er_up,		s_start,	ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_up, 		e_tick,		s_up,		ChVrmlFlySTM,	TurnUp);
	AddCell(s_up, 		ep_alt,		s_moveUp,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_alt,		ep_up,		s_moveUp,	ChVrmlFlySTM,	MoveUpStart);
	AddCell(s_moveUp, 	er_up,		s_alt,		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_moveUp, 	e_tick,		s_moveUp,	ChVrmlFlySTM,	MoveUp);
	AddCell(s_moveUp, 	er_alt,		s_up,		ChVrmlFlySTM,	DefaultHandler);
	// --			
	AddCell(s_start,	ep_down,	s_down, 	ChVrmlFlySTM,	TurnDownStart);
	AddCell(s_down, 	er_down,	s_start,	ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_down, 	e_tick,		s_down,		ChVrmlFlySTM,	TurnDown);
	AddCell(s_down, 	ep_alt,		s_moveDown,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_alt,			ep_down,	s_moveDown,	ChVrmlFlySTM,	MoveDownStart);
	AddCell(s_moveDown, 	er_down,	s_alt,		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_moveDown, 	e_tick,		s_moveDown,	ChVrmlFlySTM,	MoveDown);
	AddCell(s_moveDown, 	er_alt,		s_down,		ChVrmlFlySTM,	DefaultHandler);
	// --			
	AddCell(s_start,		ep_left,	s_left,		ChVrmlFlySTM,	TurnLeftStart);
	AddCell(s_left, 		er_left,	s_start,	ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_left, 		e_tick,		s_left,		ChVrmlFlySTM,	TurnLeft);
	AddCell(s_left, 		ep_alt,		s_moveLeft,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_alt,			ep_left,	s_moveLeft,	ChVrmlFlySTM,	MoveLeftStart);
	AddCell(s_moveLeft, 	er_left	,	s_alt,		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_moveLeft, 	e_tick,		s_moveLeft,	ChVrmlFlySTM,	MoveLeft);
	AddCell(s_moveLeft, 	er_alt,		s_left,		ChVrmlFlySTM,	DefaultHandler);
	// --			
	AddCell(s_start,		ep_right,	s_right, 		ChVrmlFlySTM,	TurnRightStart);
	AddCell(s_right, 		er_right,	s_start,		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_right, 		e_tick,		s_right,		ChVrmlFlySTM,	TurnRight);
	AddCell(s_right, 		ep_alt,		s_moveRight,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_alt,			ep_right,	s_moveRight,	ChVrmlFlySTM,	MoveRightStart);
	AddCell(s_moveRight, 	er_right,	s_alt,			ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_moveRight, 	e_tick,		s_moveRight,	ChVrmlFlySTM,	MoveRight);
	AddCell(s_moveRight, 	er_alt,		s_right,		ChVrmlFlySTM,	DefaultHandler);
	// --			
	AddCell(s_start,			ep_thrustForward,		s_thrustForward, 	ChVrmlFlySTM,	MoveForwardStart);
	AddCell(s_thrustForward, 	er_thrustForward,		s_start,			ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_alt,				ep_thrustForwardAlt,	s_thrustForward, 	ChVrmlFlySTM,	MoveForwardStart);
	AddCell(s_thrustForward, 	er_thrustForwardAlt,	s_alt,				ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_thrustForward, 	e_tick,					s_thrustForward,	ChVrmlFlySTM,	MoveForward);
	// --			
	AddCell(s_start,		ep_thrustBack,		s_thrustBack, 	ChVrmlFlySTM,	MoveReverseStart);
	AddCell(s_thrustBack, 	er_thrustBack,		s_start,		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_alt,			ep_thrustBackAlt,	s_thrustBack, 	ChVrmlFlySTM,	MoveReverseStart);
	AddCell(s_thrustBack, 	er_thrustBackAlt,	s_alt,			ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_thrustBack, 	e_tick,				s_thrustBack,	ChVrmlFlySTM,	MoveReverse);
	// --			
	AddCell(s_start,			ep_rollRight,		s_rollRight, 	ChVrmlFlySTM,	RollRightStart);
	AddCell(s_rollRight, 	er_rollRight,		s_start,			ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_alt,				ep_rollRightAlt,	s_rollRight, 	ChVrmlFlySTM,	RollRightStart);
	AddCell(s_rollRight, 	er_rollRightAlt,	s_alt,				ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_rollRight, 	e_tick,					s_rollRight,	ChVrmlFlySTM,	RollRight);
	// --			
	AddCell(s_start,		ep_rollLeft,		s_rollLeft, 	ChVrmlFlySTM,	RollLeftStart);
	AddCell(s_rollLeft, 	er_rollLeft,		s_start,		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_alt,			ep_rollLeftAlt,	s_rollLeft, 	ChVrmlFlySTM,	RollLeftStart);
	AddCell(s_rollLeft, 	er_rollLeftAlt,	s_alt,			ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_rollLeft, 	e_tick,				s_rollLeft,	ChVrmlFlySTM,	RollLeft);
	//
	// -- Mouse stuff
	//			
	AddCell(s_start,	ep_lbutton,		s_lbuttondown, 		ChVrmlFlySTM,	FlyStart);
	AddCell(s_lbuttondown, 		er_lbutton,		s_start,	ChVrmlFlySTM,	LeftClick);
	AddCell(s_lbuttondown, 		e_tick,		s_lbuttondrag,		ChVrmlFlySTM,	TickFly);
	AddCell(s_lbuttondown, 		e_move,		s_lbuttondrag,		ChVrmlFlySTM,	DragFly);
	AddCell(s_lbuttondown, 		ep_alt,		s_lbuttondownMove,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_thrustBack,	ep_lbutton,		s_lbuttondown, 		ChVrmlFlySTM,	FlyStart);

	AddCell(s_alt,	ep_lbutton,		s_lbuttondownMove, 		ChVrmlFlySTM,	CrabbishStart);
	AddCell(s_lbuttondownMove, 		er_lbutton,		s_alt,	ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_lbuttondownMove, 		e_tick,		s_lbuttondragMove,		ChVrmlFlySTM,	TickCrabbishly);
	AddCell(s_lbuttondownMove, 		e_move,		s_lbuttondragMove,		ChVrmlFlySTM,	DragCrabbishly);
	AddCell(s_lbuttondownMove, 		er_alt,		s_lbuttondown,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_lbuttondrag, 		er_lbutton,		s_start,	ChVrmlFlySTM,	LeftClickSlow);
	AddCell(s_lbuttondrag, 		e_tick,		s_lbuttondrag,		ChVrmlFlySTM,	TickFly);
	AddCell(s_lbuttondrag, 		e_move,		s_lbuttondrag,		ChVrmlFlySTM,	DragFly);
	AddCell(s_lbuttondrag, 		ep_alt,		s_lbuttondragMove,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_lbuttondragMove, 		er_lbutton,		s_alt,	ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_lbuttondragMove, 		e_tick,		s_lbuttondragMove,		ChVrmlFlySTM,	TickCrabbishly);
	AddCell(s_lbuttondragMove, 		e_move,		s_lbuttondragMove,		ChVrmlFlySTM,	DragCrabbishly);
	AddCell(s_lbuttondragMove, 		er_alt,		s_lbuttondrag,	ChVrmlFlySTM,	DefaultHandler);

//
	AddCell(s_start,	ep_rbutton,		s_rbuttondown, 		ChVrmlFlySTM,	ExamineStart);
	AddCell(s_rbuttondown, 		er_rbutton,		s_start,	ChVrmlFlySTM,	RightClick);
	AddCell(s_rbuttondown, 		e_tick,		s_rbuttondrag,		ChVrmlFlySTM,	Examine);
	AddCell(s_rbuttondown, 		e_move,		s_rbuttondrag,		ChVrmlFlySTM,	Examine);
	AddCell(s_rbuttondown, 		ep_alt,		s_rbuttondownMove,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_alt,	ep_rbutton,		s_rbuttondownMove, 		ChVrmlFlySTM,	ExamineStart);
	AddCell(s_rbuttondownMove, 		er_rbutton,		s_alt,	ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_rbuttondownMove, 		e_tick,		s_rbuttondragMove,		ChVrmlFlySTM,	Examine);
	AddCell(s_rbuttondownMove, 		e_move,		s_rbuttondragMove,		ChVrmlFlySTM,	Examine);
	AddCell(s_rbuttondownMove, 		er_alt,		s_rbuttondown,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_rbuttondrag, 		er_rbutton,		s_start,	ChVrmlFlySTM,	RightClickSlow);
	AddCell(s_rbuttondrag, 		e_tick,		s_rbuttondrag,		ChVrmlFlySTM,	Examine);
	AddCell(s_rbuttondrag, 		e_move,		s_rbuttondrag,		ChVrmlFlySTM,	Examine);
	AddCell(s_rbuttondrag, 		ep_alt,		s_rbuttondragMove,	ChVrmlFlySTM,	DefaultHandler);

	AddCell(s_rbuttondragMove, 		er_rbutton,		s_alt,	ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_rbuttondragMove, 		e_tick,		s_rbuttondragMove,		ChVrmlFlySTM,	Examine);
	AddCell(s_rbuttondragMove, 		e_move,		s_rbuttondragMove,		ChVrmlFlySTM,	Examine);
	AddCell(s_rbuttondragMove, 		er_alt,		s_rbuttondrag,	ChVrmlFlySTM,	DefaultHandler);

	// We only get in or out of these states via goto's in actions
	AddCell(s_goTowardsBegin, 	e_tick,		s_goTowards,	ChVrmlFlySTM,	GoTowardsStart);
	AddCell(s_goTowards, 		e_tick,		s_goTowards,	ChVrmlFlySTM,	GoTowards);

	// We only get into these states via goto's in actions; we get out by events
	AddCell(s_spinningBegin, 	e_tick,		s_spinning,	ChVrmlFlySTM,	SpinStart);
	AddCell(s_spinning, 		e_tick,		s_spinning,	ChVrmlFlySTM,	Spin);

	AddCell(s_spinningBegin,	ep_alt,		s_alt, 		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_spinningBegin,	ep_up,		s_up, 		ChVrmlFlySTM,	TurnUpStart);
	AddCell(s_spinningBegin,	ep_down,	s_down, 	ChVrmlFlySTM,	TurnDownStart);
	AddCell(s_spinningBegin,	ep_left,	s_left,		ChVrmlFlySTM,	TurnLeftStart);
	AddCell(s_spinningBegin,	ep_right,	s_right, 		ChVrmlFlySTM,	TurnRightStart);
	AddCell(s_spinningBegin,	ep_thrustForward,		s_thrustForward, 	ChVrmlFlySTM,	MoveForwardStart);
	AddCell(s_spinningBegin,	ep_thrustBack,		s_thrustBack, 	ChVrmlFlySTM,	MoveReverseStart);
	AddCell(s_spinningBegin,	ep_lbutton,		s_lbuttondown, 		ChVrmlFlySTM,	FlyStart);
	AddCell(s_spinningBegin,	ep_rbutton,		s_rbuttondown, 		ChVrmlFlySTM,	ExamineStart);

	AddCell(s_spinning,	ep_alt,		s_alt, 		ChVrmlFlySTM,	DefaultHandler);
	AddCell(s_spinning,	ep_up,		s_up, 		ChVrmlFlySTM,	TurnUpStart);
	AddCell(s_spinning,	ep_down,	s_down, 	ChVrmlFlySTM,	TurnDownStart);
	AddCell(s_spinning,	ep_left,	s_left,		ChVrmlFlySTM,	TurnLeftStart);
	AddCell(s_spinning,	ep_right,	s_right, 		ChVrmlFlySTM,	TurnRightStart);
	AddCell(s_spinning,	ep_thrustForward,		s_thrustForward, 	ChVrmlFlySTM,	MoveForwardStart);
	AddCell(s_spinning,	ep_thrustBack,		s_thrustBack, 	ChVrmlFlySTM,	MoveReverseStart);
	AddCell(s_spinning,	ep_lbutton,		s_lbuttondown, 		ChVrmlFlySTM,	FlyStart);
	AddCell(s_spinning,	ep_rbutton,		s_rbuttondown, 		ChVrmlFlySTM,	ExamineStart);
}

bool ChVrmlFlySTM::TranslateKeyEvent(int keyMsg, int key, chuint32 modifiers, int &event, chuint32 *&pData)
{
	chflag32		flMods = 0;

	if (GetKeyState( VK_MENU ) & 0x8000)
	{
		flMods |= ACTION_MOD_ALT;
	}

	if (keyMsg == WM_KEYUP || keyMsg == WM_SYSKEYUP)
	{
		flMods |= ACTION_MOD_KEY_UP;
	}
	
	if (GetKeyState( VK_SHIFT ) & 0x8000)
	{
		flMods |= ACTION_MOD_SHIFT;
		m_keyFlags &= ~kd_shift;
	}

	if (GetKeyState( VK_CONTROL ) & 0x8000)
	{
		flMods |= ACTION_MOD_CONTROL;
		m_keyFlags &= ~kd_ctl;
	}

	bool boolFound = true;
	if(flMods & ACTION_MOD_KEY_UP)
	{
		switch(key)
		{
			case VK_UP:
			{
				event = er_up;
				m_keyFlags &= ~kd_up;
				break;
			}
			case VK_DOWN:
			{
				event = er_down;
				m_keyFlags &= ~kd_down;
				break;
			}
			case VK_LEFT:
			{
				event = er_left;
				m_keyFlags &= ~kd_left;
				break;
			}
			case VK_RIGHT:
			{
				event = er_right;
				m_keyFlags &= ~kd_right;
				break;
			}
			case 'A':
			{
				if(flMods & ACTION_MOD_ALT)
				{
					event = er_thrustForwardAlt;
				}
				else
				{
					event = er_thrustForward;
				}
				m_keyFlags &= ~kd_thrustForward;
				break;
			}
			case 'Z':
			{
				if(flMods & ACTION_MOD_ALT)
				{
					event = er_thrustBackAlt;
				}
				else
				{
					event = er_thrustBack;
				}
				m_keyFlags &= ~kd_thrustBack;
				break;
			}
			case 'Q':
			{
				if(flMods & ACTION_MOD_ALT)
				{
					event = er_rollLeftAlt;
				}
				else
				{
					event = er_rollLeft;
				}
				m_keyFlags &= ~kd_rollLeft;
				break;
			}
			case 'E':
			{
				if(flMods & ACTION_MOD_ALT)
				{
					event = er_rollRightAlt;
				}
				else
				{
					event = er_rollRight;
				}
				m_keyFlags &= ~kd_rollRight;
				break;
			}
			case VK_MENU:
			{
				event = er_alt;
				m_keyFlags &= ~kd_alt;
				break;
			}
			default:
			{
				boolFound = false;
			}
		}
	}
	else
	{
		switch(key)
		{
			case VK_UP:
			{
				event = ep_up;
				m_keyFlags |= kd_up;
				break;
			}
			case VK_DOWN:
			{
				event = ep_down;
				m_keyFlags |= kd_down;
				break;
			}
			case VK_LEFT:
			{
				event = ep_left;
				m_keyFlags |= kd_left;
				break;
			}
			case VK_RIGHT:
			{
				event = ep_right;
				m_keyFlags |= kd_right;
				break;
			}
			case 'A':
			{
				if(flMods & ACTION_MOD_ALT)
				{
					event = ep_thrustForwardAlt;
				}
				else
				{
					event = ep_thrustForward;
				}
				break;
				m_keyFlags |= kd_thrustForward;
			}
			case 'Z':
			{
				if(flMods & ACTION_MOD_ALT)
				{
					event = ep_thrustBackAlt;
				}
				else
				{
					event = ep_thrustBack;
				}
				m_keyFlags |= kd_thrustBack;
				break;
			}
			case 'Q':
			{
				if(flMods & ACTION_MOD_ALT)
				{
					event = ep_rollLeftAlt;
				}
				else
				{
					event = ep_rollLeft;
				}
				m_keyFlags |= kd_rollLeft;
				break;
			}
			case 'E':
			{
				if(flMods & ACTION_MOD_ALT)
				{
					event = ep_rollRightAlt;
				}
				else
				{
					event = ep_rollRight;
				}
				m_keyFlags |= kd_rollRight;
				break;
			}
			case VK_MENU:
			{
				event = ep_alt;
				m_keyFlags |= kd_alt;
				break;
			}
			default:
			{
				boolFound = false;
			}
		}
	}