eventwindow.java

国外人写的操作感挺好的一款滑雪游戏.结构也比较清楚

	
			m_aSprites[iAthlete][SPRITE_SKATING].m_bLooping = true;
		
			// load the starting sprite
//#ifdef _IS_NokiaS60
//			src = TorinoCanvas.loadPackedPalPixels( RESFILE_SKATING, 0/*@RES_SKATESTART*/,
//													RESFILE_SKATING, iPal );
//			abyData = TorinoCanvas.loadPackedResource( RESFILE_SKATING, 2/*@RES_STARTDAT*/ );
//#else
			src = TorinoCanvas.loadPackedPalImage( RESFILE_GFX, 0/*@RES_SKATESTART*/, RESFILE_COUNTRY, 2/*@RES_SKATEPAL*/ + iPal );
			abyData = TorinoCanvas.loadPackedResource( RESFILE_GFX, 2/*@RES_STARTDAT*/ );
//#endif

			
			m_aSprites[iAthlete][SPRITE_START] = new Sprite( src, abyData );
			
			m_aSprites[iAthlete][SPRITE_START].setPosition((FP.toInt(m_aSim[iAthlete].getPos(0/*@AXIS_X*/)) * 16/*@PIXEL_PER_M*/)
														    + m_aiSkaterXPos[iAthlete], m_aiSkaterYPos[iAthlete]);

			m_aSprites[iAthlete][SPRITE_START].setFPS(7);
			//m_aSprites[iAthlete][SPRITE_START].m_bLooping = false;
			
			if( m_data.bInitialized )
			{
				m_aiCurrentSprite[iAthlete] = SPRITE_START;
				
				if( m_data.aiAthleteState[iAthlete] > ATHLETE_SET )
					m_aiCurrentSprite[iAthlete] = SPRITE_SKATING;
				else if( m_data.aiAthleteState[iAthlete] == ATHLETE_SET )
					m_aSprites[iAthlete][m_aiCurrentSprite[iAthlete]].setFrame( 1 );
					
				
			}
		}
		
		if( m_sign1 == null )
		{
			// set coordinates for ice
			m_iIceY = m_canvas.getCanvasHeight() - 42/*@ICE_HEIGHT*/;
			
			// load the sign bitmaps - these are expected to be the same size
			m_sign1 = TorinoCanvas.loadPackedImage( RESFILE_COMMON, 0/*@RES_SIGN1*/ );				// 1.51 KB
//#ifndef _LOW_DETAIL
//			m_sign2 = TorinoCanvas.loadPackedImage( RESFILE_COMMON, RES_SIGN2 );			// 1.38 KB
//#endif
			m_iSignY = m_iIceY - m_sign1.getHeight();
			
			// load the crowd bitmap
//#ifndef _LOW_DETAIL
//			m_crowd = TorinoCanvas.loadPackedImage( RESFILE_COMMON, RES_CROWD );				// 760 bytes
//			
//			m_iCrowdY = m_iSignY - m_crowd.getHeight();
//	
//			if( (m_iCrowdY + 12/*@TREES_CROWD_OVERLAP*/) > 0 )
//#else
			if( ((m_iSignY - 11) + 12/*@TREES_CROWD_OVERLAP*/) > 0 )
//#endif
			{				
				// load the background trees
				m_farTrees = TorinoCanvas.loadPackedImage( RESFILE_COMMON, 2/*@RES_TREESFAR*/ );		// 2.81 KB
//#ifndef _LOW_DETAIL
//				m_iFarTreesY = m_iCrowdY - m_farTrees.getHeight() + 7/*@FAR_TREES_CROWD_OVERLAP*/;
//#else
				m_iFarTreesY = m_iSignY - m_farTrees.getHeight();
//#endif
				
				// load the tree bitmap
				m_tree = TorinoCanvas.loadPackedImage( RESFILE_COMMON, 1/*@RES_TREE*/ );				// 1.96 KB
//#ifndef _LOW_DETAIL
//				m_iTreeY = m_iCrowdY - m_tree.getHeight() + 12/*@TREES_CROWD_OVERLAP*/;
//#else
				m_iTreeY = m_iSignY - m_tree.getHeight() + 4;
//#endif
		
//#ifndef _LOW_DETAIL
//				if (m_iFarTreesY > 0)
//				{
//					m_sky = TorinoCanvas.loadPackedImage( RESFILE_COMMON, RES_SKY );			// 1.95 KB
//					m_iSkyY = m_iFarTreesY - m_sky.getHeight();
//				}
//#endif
			}
		}
	}

	private void setState_skating( int iState, int iCurrentTime ) throws IOException
	{
		switch (m_data.iState)
		{
		case STATE_READY:
			athleteReady_skating(0/*@PLAYER*/);
			athleteReady_skating(1/*@AI_PLAYER*/);
			m_aSprites[0/*@PLAYER*/][m_aiCurrentSprite[0/*@PLAYER*/]].setPosition(
									FP.toInt(m_aSim[0/*@PLAYER*/].getPos(0/*@AXIS_X*/) * 16/*@PIXEL_PER_M*/) + m_aiSkaterXPos[0/*@PLAYER*/],
									m_aiSkaterYPos[0/*@PLAYER*/] );
			m_aSprites[1/*@AI_PLAYER*/][m_aiCurrentSprite[1/*@AI_PLAYER*/]].setPosition(
									FP.toInt(m_aSim[1/*@AI_PLAYER*/].getPos(0/*@AXIS_X*/) * 16/*@PIXEL_PER_M*/) + m_aiSkaterXPos[1/*@AI_PLAYER*/],
									m_aiSkaterYPos[1/*@AI_PLAYER*/] );
			m_iXD = 0;
			setClockTime( 0, 0/*@CLOCK*/ );
			update( iCurrentTime );
			setCursor( 417/*@TIME_DELAY_SKATING*/ );
			m_sMarker.m_bVisible = false;
			break;
		case STATE_SET:
			m_data.aiAthleteState[0] = ATHLETE_SET;
			m_aSprites[0][SPRITE_START].setFrame(1);
			m_data.aiAthleteState[1] = ATHLETE_SET;
			m_aSprites[1][SPRITE_START].setFrame(1);
			break;
		case STATE_FAULT:
			athleteStart_skating(0/*@PLAYER*/, iCurrentTime);
			m_canvas.playSound( 2/*@SOUND_FAULT*/, 0 );
			break;
		case STATE_GO:
			m_canvas.playSound( 3/*@SOUND_GUNSHOT*/, 0 );
			m_data.iLastUpdateTime = iCurrentTime;
			setClockTime( 0, 0 );
			//for( int i = 0; i < NUM_ATHLETES; i++)
			//{
			//	m_aSim[i].resetCrossings();
			//	m_aSim[i].setPosition(0,0);
			//	m_aSim[i].setVelocity(0,0);
			//	m_aSim[i].setTime(0);
			//}
			
			athleteStart_skating(1/*@AI_PLAYER*/, iCurrentTime);
			m_data.iPreviousTime[1/*@AI_PLAYER*/] = iCurrentTime;
			m_data.iTimeWindow[1] = 0;
			m_data.iCPUDeltaV = 0;
			break;
		case STATE_SKATING:
			athleteStart_skating(0/*@PLAYER*/, iCurrentTime);
			break;
		case STATE_ENDALL:		
		
			if ( m_data.iGameMode == 2/*@GAMEMODE_COMPETITION*/
//#ifndef _NO_GHOST 
//			  	 || ( m_data.iGameMode == 3/*@GAMEMODE_CHALLENGE*/ && m_data.iCurrentPlayer == 0/*@PLAYER*/ ) 
//#endif
			   )
			{
				m_canvas.competition_recordScore( m_data.iCurrentPlayer, 0/*@EVENT_SKATING*/,
												  m_aSim[0/*@PLAYER*/].getCrossingTime(0/*@AXIS_X*/) );
				int iPlayer = m_data.iNumPlayers + m_data.iCurrentPlayer;
				if ( iPlayer < m_data.iMaxPlayers 
//#ifndef _NO_GHOST
//					 && m_data.iGameMode != 3/*@GAMEMODE_CHALLENGE*/ 
//#endif
				   )
				{
					// record the score for the AI athlete (if valid)
					m_canvas.competition_recordScore( iPlayer, 0/*@EVENT_SKATING*/,
													  m_aSim[1/*@AI_PLAYER*/].getCrossingTime(0/*@AXIS_X*/) );
				}
			}
			break;
		}
		updateLabel_skating();
		m_data.iStateStartTime = iCurrentTime;
	}
	
	private void onIdle_skating() throws IOException
	{
		int iCurrentTime = getEventTime();
		int iStateTime = iCurrentTime - m_data.iStateStartTime;
		
		switch (m_data.iState)
		{
		case STATE_READY:
			if( iStateTime > 3000/*@READY_TIME*/ )
				setState( STATE_SET, iCurrentTime );
				
			break;
		case STATE_SET:
			if( iStateTime > 3000/*@SET_TIME*/ )
				setState( STATE_GO, iCurrentTime );

			if( m_data.iLastUpdateTime != 0 )
					m_data.iLastUpdateTime = 0;		// Reset last update time
					
			break;
		case STATE_FAULT:
			if (iStateTime > 3000/*@FAULT_TIME*/)
			{
				if ( m_data.bFault && (m_data.iGameMode == 2/*@GAMEMODE_COMPETITION*/) )
				{
					// disqualified
					m_canvas.competition_recordScore( m_data.iCurrentPlayer, 0/*@EVENT_SKATING*/, 0 );
					completeEvent( iCurrentTime );
					return;
				}
				else
				{
					m_data.bFault = true;
					m_aiCurrentSprite[0/*@PLAYER*/] = SPRITE_START;
					setState(STATE_READY, iCurrentTime);
				}
				break;
			}
			update( iCurrentTime );
			break;
		case STATE_GO:
			// ghost does not use AI
//#ifndef _NO_GHOST
//			if( m_data.iGameMode != 3/*@GAMEMODE_CHALLENGE*/ )
//#endif
				m_data.iTimeWindow[1/*@AI_PLAYER*/] += (iCurrentTime - m_data.iPreviousTime[1/*@AI_PLAYER*/]);
			
			update( iCurrentTime );
			break;
		case STATE_SKATING:
			m_data.iTimeWindow[0/*@PLAYER*/] += (iCurrentTime - m_data.iPreviousTime[0/*@PLAYER*/]);
			m_data.iCursorTime += (iCurrentTime - m_data.iPreviousTime[0/*@PLAYER*/]);
			
			// ghost does not use AI
//#ifndef _NO_GHOST
//			if( m_data.iGameMode != 3/*@GAMEMODE_CHALLENGE*/ )
//#endif
				m_data.iTimeWindow[1/*@AI_PLAYER*/] += (iCurrentTime - m_data.iPreviousTime[1/*@AI_PLAYER*/]);
			
			if( m_data.iTimeWindow[0/*@PLAYER*/] >= 833/*@MAX_TIME_WINDOW_SKATING*/ )
			{
				m_iDeltaV = m_aSim[0/*@PLAYER*/].getVelMax(0/*@AXIS_X*/) - m_aSim[0/*@PLAYER*/].getVel(0/*@AXIS_X*/);
				m_aSim[0/*@PLAYER*/].applyImpulse( 0/*@AXIS_X*/, m_iDeltaV>>5 );
				m_data.iTimeWindow[0/*@PLAYER*/] -= 833/*@MAX_TIME_WINDOW_SKATING*/;
	
				if( m_data.iNextButton == 0x1000/*@VKEY_LEFT*/ )
					m_data.iNextButton = 0x2000/*@VKEY_RIGHT*/;
				else
					m_data.iNextButton = 0x1000/*@VKEY_LEFT*/;
			}
		default:
			update( iCurrentTime );
			break;
		}
	
		// Make AI calculation if needed
		if( (m_data.iCPUDeltaV <= 0) && (m_data.iTimeWindow[1/*@AI_PLAYER*/] > 0) )
		{			
				m_data.iCPUDeltaV = m_aSim[1/*@AI_PLAYER*/].getVelMax(0/*@AXIS_X*/) - m_aSim[1/*@AI_PLAYER*/].getVel(0/*@AXIS_X*/);
	
				// *magic* formula
				m_data.iCPUDeltaTime = FP.div( 417/*@TIME_DELAY_SKATING*/ - 
					m_canvas.getRand( 250 - 5/*@AI_FACTOR*/ * 
						(3*TorinoCanvas.m_aiAITable[m_data.iAINation][0/*@EVENT_SKATING*/]
						+ 5*m_data.iDifficulty)), 
					417/*@TIME_DELAY_SKATING*/ );
	
				// use a square relation for impulse
				m_data.iCPUDeltaTime = FP.mul( m_data.iCPUDeltaTime, m_data.iCPUDeltaTime );				
		}
	
		if( m_data.iTimeWindow[1/*@AI_PLAYER*/] > 417/*@TIME_DELAY_SKATING*/ )
		{			
			// ** USE THIS TO DETERMINE BEST POSSIBLE TIME:
			//m_apSim[1]->applyImpulse( Axis_X, ((m_iDeltaV[1]*5)>>4));
			// **
			
			m_aSim[1/*@AI_PLAYER*/].applyImpulse( 0/*@AXIS_X*/, FP.mul( FP.mul(m_data.iCPUDeltaV,39977/*@IMPULSE_FACTOR*/),
												m_data.iCPUDeltaTime ) );
			m_data.iCPUDeltaV = 0;
			m_data.iTimeWindow[1/*@AI_PLAYER*/] -= 833/*@MAX_TIME_WINDOW_SKATING*/;
		}
	
		m_data.iPreviousTime[0/*@PLAYER*/] = iCurrentTime;
		m_data.iPreviousTime[1/*@AI_PLAYER*/] = iCurrentTime;
	
		iStateTime = iCurrentTime - m_data.iStateStartTime;
	
		if ( m_data.iState == STATE_ENDALL && iStateTime > 3000/*@END_TIME_SKATING*/)
		{
			completeEvent(iCurrentTime);
			return;
		}
		
		updateTimingBar( iCurrentTime );
	
		m_canvas.m_bNeedPaint = true;		
	}
	
	private void handleKey_skating( int iKeyCode, int iGameAction ) throws IOException
	{
		int iCurrentTime = getEventTime();
	
		// handle keys
		switch (iGameAction)
		{
		case 0x2000/*@VKEY_RIGHT*/:
			switch (m_data.iState)
			{
			case STATE_SET:
				setState( STATE_FAULT, iCurrentTime );
				break;
			case STATE_GO:
				setState( STATE_SKATING, iCurrentTime );
				m_data.iPreviousTime[0/*@PLAYER*/] = iCurrentTime;
				break;
			}
		//fall through to case VKEY_LEFT
		case 0x1000/*@VKEY_LEFT*/:			
			switch (m_data.iState)
			{			
			case STATE_SKATING:
				// impulse
				if( iGameAction == m_data.iNextButton )
				{
					if( m_data.iTimeWindow[0/*@PLAYER*/] > 0 && m_data.iTimeWindow[0/*@PLAYER*/] < 833/*@MAX_TIME_WINDOW_SKATING*/ )
					{
						m_iDeltaV = m_aSim[0/*@PLAYER*/].getVelMax(0/*@AXIS_X*/) - m_aSim[0/*@PLAYER*/].getVel(0/*@AXIS_X*/);
					
						if( 417/*@TIME_DELAY_SKATING*/ > m_data.iTimeWindow[0/*@PLAYER*/] ) 
							m_aiDeltaTime[0/*@PLAYER*/] = FP.div( m_data.iTimeWindow[0/*@PLAYER*/], 417/*@TIME_DELAY_SKATING*/ );
						else
							m_aiDeltaTime[0/*@PLAYER*/] = FP.div( (833/*@MAX_TIME_WINDOW_SKATING*/-m_data.iTimeWindow[0/*@PLAYER*/]),
															417/*@TIME_DELAY_SKATING*/ );
					
						// use a square relation for impulse
						m_aiDeltaTime[0/*@PLAYER*/] = FP.mul( m_aiDeltaTime[0/*@PLAYER*/], m_aiDeltaTime[0/*@PLAYER*/] );
	
						// ** USE THIS TO DETERMINE BEST POSSIBLE TIME:
						//m_apSim[0]->applyImpulse( Axis_X, ((m_iDeltaV[0]*5)>>4)); // Best time = 34+ seconds
						// **
						m_aSim[0/*@PLAYER*/].applyImpulse( 0/*@AXIS_X*/, FP.mul( FP.mul(m_iDeltaV,39977/*@IMPULSE_FACTOR*/),
																	 m_aiDeltaTime[0/*@PLAYER*/] ) );   // actual function
						m_data.iTimeWindow[0/*@PLAYER*/] -= 833/*@MAX_TIME_WINDOW_SKATING*/;
	
						if (!m_bPlayerDone[0/*@PLAYER*/])
						{	
							setMarker( m_data.iCursorTime, iCurrentTime );
						}
	
						if( m_data.iNextButton == 0x1000/*@VKEY_LEFT*/ )
							m_data.iNextButton = 0x2000/*@VKEY_RIGHT*/;
						else
							m_data.iNextButton = 0x1000/*@VKEY_LEFT*/;
					}
					break;
				}
			}
			break;
		case 0x200000/*@VKEY_SELECT*/:
		case 0x10000/*@VKEY_FIRE*/:
			if (m_data.iState == STATE_ENDALL)
			{
				completeEvent(iCurrentTime);
				return;
			}
			break;
		}
	}
	
	private void update_skating( int iCurrentTime ) throws IOException
	{
		// Use this if statement to auto-start the human player
		if ( m_data.iState == STATE_GO && 
			iCurrentTime - m_data.iStateStartTime > 2000/*@AUTO_START_TIME*/)
		{
			// auto-start the human athlete
			setState( STATE_SKATING, iCurrentTime );
			m_data.iPreviousTime[0/*@PLAYER*/] = iCurrentTime;
		}
	
		int iDeltaTime;
		int i;
		if( m_data.iLastUpdateTime == 0 ) 
			iDeltaTime = 25;
		else
			iDeltaTime = iCurrentTime - m_data.iLastUpdateTime;
		
		for ( i = 0/*@PLAYER*/; i <= 1/*@AI_PLAYER*/; i++ )
		{
			if( (m_data.aiAthleteState[i] == ATHLETE_STARTING) && 
				(m_aSprites[i][m_aiCurrentSprite[i]].m_iCurrentFrame == m_aSprites[i][m_aiCurrentSprite[i]].m_iSequenceLength - 1))
			{
				m_data.aiAthleteState[i] = ATHLETE_SKATING;
			
				// change the athlete sprite
				m_data.iGoTime[i] = iCurrentTime;
				m_aiCurrentSprite[i] = SPRITE_SKATING;				
			}
		}

		if( !(m_data.bWasPaused) )
		{
			m_aSim[0/*@PLAYER*/].update( iDeltaTime );
			m_aSim[1/*@AI_PLAYER*/].update( iDeltaTime );
		}
		else
		{
			m_data.bWasPaused = false;
		}

		if( m_data.aiAthleteState[0/*@PLAYER*/] > ATHLETE_SET )
			m_aSprites[0/*@PLAYER*/][m_aiCurrentSprite[0/*@PLAYER*/]].setTime( iCurrentTime - m_data.iGoTime[0/*@PLAYER*/] );
			
		m_aSprites[0/*@PLAYER*/][m_aiCurrentSprite[0/*@PLAYER*/]].setPosition(
								FP.toInt(m_aSim[0/*@PLAYER*/].getPos(0/*@AXIS_X*/) * 16/*@PIXEL_PER_M*/) + m_aiSkaterXPos[0/*@PLAYER*/],
								m_aiSkaterYPos[0/*@PLAYER*/]);
								
		if( m_data.aiAthleteState[1/*@AI_PLAYER*/] > ATHLETE_SET && m_data.iState != STATE_FAULT )
		{
			m_aSprites[1/*@AI_PLAYER*/][m_aiCurrentSprite[1/*@AI_PLAYER*/]].setTime( iCurrentTime - m_data.iGoTime[1/*@AI_PLAYER*/] );
			
			m_aSprites[1/*@AI_PLAYER*/][m_aiCurrentSprite[1/*@AI_PLAYER*/]].setPosition(
									FP.toInt(m_aSim[1/*@AI_PLAYER*/].getPos(0/*@AXIS_X*/) * 16/*@PIXEL_PER_M*/) + m_aiSkaterXPos[1/*@AI_PLAYER*/],
									m_aiSkaterYPos[1/*@AI_PLAYER*/]);	
		}

		if( m_data.iState != STATE_FAULT )
			m_iXD = (m_aSim[0/*@PLAYER*/].getPos(0/*@AXIS_X*/) * 16/*@PIXEL_PER_M*/) >> 16;  // to int
	
		for( i = 0; i < 2/*@NUM_ATHLETES*/; i++ )
		{
			if( m_aSim[i].getPos(0/*@AXIS_X*/) >= m_aSim[i].getPosConstraint(0/*@AXIS_X*/) )
				m_bPlayerDone[i] = true;
			if ( m_bPlayerDone[0/*@PLAYER*/] )
				updateLabel_skating();
		}
	
		// ** This only works for 2 skaters **
		if( m_bPlayerDone[0/*@PLAYER*/] && m_bPlayerDone[1/*@AI_PLAYER*/] && (m_data.iState != STATE_ENDALL) )
		{
			setState(STATE_ENDALL, iCurrentTime);
		}
	
		// update the power meter
		int fpMin = m_aSim[0/*@PLAYER*/].getVelMin(0/*@AXIS_X*/);
		int fpMax = m_aSim[0/*@PLAYER*/].getVelMax(0/*@AXIS_X*/);
	
		if (!m_bPlayerDone[0/*@PLAYER*/])
		{
			setCursor( m_data.iCursorTime );
		}
	
		//if ( m_data.iState >= STATE_GO )
		//{
		int iRaceTime = m_aSim[0/*@PLAYER*/].getCrossingTime(0/*@AXIS_X*/);