app.cpp

吃豆子游戏源码

/**
 *	File	:	App.cpp
 *  Author	:	Kevin Lynx
 *	Date	:	2007/8/1
 */
#include "stdafx.h"
#include "App.h"
#include "World.h"
#include "MastEventReceiver.h"
#include "Player.h"
#include "MonsterManager.h"
#include "Bullet.h"
#include "ResourceMgr.h"
#include "Effect.h"
#include "MainMenu.h"
#include "SoundManager.h"
#include "Bonus.h"
#include "ConfigReader.h"
#include "FadeImage.h"
#include <ctime>

#include "../build/resource.h"

App::App()
{
	mFrameStartTime = 0;
	mDeltaTime = 0;
	mCamera = 0;
	mLogo = 0;
}

App::~App()
{
	release();
}

bool	App::init()
{
	ConfigReader *config = new ConfigReader();
	config->read();

	new MastEventReceiver();
	mDevice = createDevice( (E_DRIVER_TYPE )config->mDeviceType, core::dimension2d<s32>(800, 600), config->mBits, 
		config->mbFullScreen, false, false, this );

	if( mDevice == 0 )
	{
		return false;
	}
	ISceneManager *smgr = mDevice->getSceneManager();
	IVideoDriver *driver = mDevice->getVideoDriver();

	if( config->mEnableLight )
	{
		createLights();
	}

	mCamera = smgr->addCameraSceneNode( 0, vector3df( 0, 500, 0 ), vector3df( 0, 0, 200 ) );

	srand( (unsigned int)time( 0 ) );

	new ResourceMgr( mDevice );
	ResourceMgr::GetSingletonPtr()->load();

	/// sound stuff
	new SoundManager();
	SoundManager::GetSingletonPtr()->init( config->mGlobalVolume ); 

	new MonsterManager( mDevice );

	new World( mDevice );
	World::GetSingletonPtr()->load(); 

	new BulletManager( mDevice );
	BulletManager::GetSingletonPtr()->init();

	new EffectManager( mDevice );
	EffectManager::GetSingletonPtr()->init();

	new BonusManager( mDevice );
	BonusManager::GetSingletonPtr()->init();

	new MainMenu( mDevice );
	MainMenu::GetSingletonPtr()->init();

	mLogo = new FadeImage( mDevice->getVideoDriver(), ResourceMgr::GetSingletonPtr()->mGUILogo,
		position2d<s32>( 133, 100 ), 200, 1.5f );

	ResourceMgr *resMgr = ResourceMgr::GetSingletonPtr(); 
	mFXGameOver.init( mDevice, resMgr->mGameOver );
	mFXLevelClear.init( mDevice, resMgr->mLevelClear );
	mFXTimeOut.init( mDevice, resMgr->mTimeOut );

#ifdef _DEBUG
	/// axis
	IAnimatedMesh* arrow = smgr->addArrowMesh("coord", 1,500,205,200,1,3, SColor(255,0,255,0), 
												SColor(255,0,255,0)); 
	ISceneNode* arrow_node = smgr->addMeshSceneNode( arrow->getMesh(0)); 
	arrow_node->setMaterialFlag(EMF_LIGHTING,false); 

	IAnimatedMesh* x_arrow = smgr->addArrowMesh("coord_x", 1,500,205,200,1,3, SColor(255,255,0,0), 
												SColor(255,255,0,0)); 
	ISceneNode* x_arrow_node = smgr->addMeshSceneNode( x_arrow->getMesh(0)); 
	x_arrow_node->setRotation( vector3df( 0, 0, -90 ) );
	x_arrow_node->setMaterialFlag( EMF_LIGHTING, false );

	IAnimatedMesh* z_arrow = smgr->addArrowMesh("coord_z", 1,500,205,200,1,3, SColor(255,0,0,255), 
												SColor(255,0,0,255)); 
	ISceneNode* z_arrow_node = smgr->addMeshSceneNode( z_arrow->getMesh(0)); 
	z_arrow_node->setRotation( vector3df( 90, 0, 0 ) );
	z_arrow_node->setMaterialFlag( EMF_LIGHTING, false );
#endif

	Player *player = new Player();
	player->init( smgr, resMgr->mPacMesh, resMgr->mPacTexture );		

	//smgr->addCameraSceneNodeFPS();
	//skybox
	smgr->addSkyDomeSceneNode( ResourceMgr::GetSingletonPtr()->mSkyboxText,
		40, 40, 1, 2.0f );
	
	//setGameState( GAME_STATE_MAIN_MENU );
	setGameState( GAME_STATE_SHOW_LOGO );

	/// hide the mouse ,and display a customer mouse cursor
	mDevice->getCursorControl()->setVisible( false );

	return true;
}

void	App::run()
{
	int lastFPS = -1;

	MastEventReceiver::GetSingletonPtr()->init();

	IVideoDriver *driver = mDevice->getVideoDriver();
	ISceneManager *smgr = mDevice->getSceneManager();

	mFrameStartTime = getRealTime();

	while( mDevice->run() )
	{
		
		MastEventReceiver::GetSingletonPtr()->endEventProcess();

		if (mDevice->isWindowActive())
		{
			/// logic
			switch( mGameState )
			{
			case GAME_STATE_SHOW_LOGO:
				_gameShowLogo();
				break;
				
			case GAME_STATE_MAIN_MENU:
				_gameMainMenu();
				break;

			case GAME_STATE_SHOW_HELP:
				_gameShowHelp();
				break;

			case GAME_STATE_SHOW_CREDITS:
				_gameShowCredits();
				break;

			case GAME_STATE_GAMEOVER:
			case GAME_STATE_TIMEOUT:
			case GAME_STATE_CLEAR:
			case GAME_STATE_NORMAL_PLAY:
				_gamePlay();
				break;
			}

			/// render
			driver->beginScene( true, true, video::SColor(255,0,0,0));
			
			if( mGameState >= GAME_STATE_PLAY_MIN &&
				mGameState <= GAME_STATE_PLAY_MAX )
			{
				smgr->drawAll();
				renderStatus();
			}
			if( mGameState == GAME_STATE_GAMEOVER )
			{
				mFXGameOver.render();
			}
			if( mGameState == GAME_STATE_CLEAR )
			{
				mFXLevelClear.render();
			}
			if( mGameState == GAME_STATE_TIMEOUT )
			{
				mFXTimeOut.render();
			}

			if( mGameState >= GAME_STATE_GUI_MIN &&
				mGameState <= GAME_STATE_GUI_MAX )
			{
				MainMenu::GetSingletonPtr()->render(); 
				mDevice->getGUIEnvironment()->drawAll();
	
				/// mouse cursor
				renderCursor();
			}
		
			if( mGameState == GAME_STATE_SHOW_LOGO )
			{
				mLogo->render();
			}

			driver->endScene();
			
			/// show fps
			int fps = driver->getFPS();

			if (lastFPS != fps)
			{
				core::stringw str = L"PacShooter Remade By Kevin Lynx 2007.7.29-8.3 [";
				str += driver->getName();
				str += "] FPS:";
				str += fps;

				mDevice->setWindowCaption(str.c_str());
				lastFPS = fps;
			}

			/// sound stuff
			SoundManager::GetSingletonPtr()->update( mCamera->getPosition(), mCamera->getTarget() ); 
		}
		mDeltaTime = getRealTime() - mFrameStartTime;
		mFrameStartTime += mDeltaTime;
		
		if( mGameState == GAME_STATE_NORMAL_PLAY )
		{
			mLevelTime -= mDeltaTime;
		}
		MastEventReceiver::GetSingletonPtr()->startEventProcess();
	}

}

void	App::release()
{
	delete ConfigReader::GetSingletonPtr(); 
	delete mLogo;
	delete MainMenu::GetSingletonPtr(); 
	delete BonusManager::GetSingletonPtr(); 
	delete SoundManager::GetSingletonPtr(); 
	delete EffectManager::GetSingletonPtr(); 
	delete ResourceMgr::GetSingletonPtr();
	delete BulletManager::GetSingletonPtr(); 
	delete MonsterManager::GetSingletonPtr(); 
	delete World::GetSingletonPtr();
	delete Player::GetSingletonPtr();
	delete MastEventReceiver::GetSingletonPtr(); 
	mDevice->drop();
}

u32		App::getRealTime()
{
	return mDevice->getTimer()->getRealTime();
}

void	App::updateCamera( const vector3df &pos, const vector3df &lookat )
{
	mCamera->setPosition( pos );
	mCamera->setTarget( lookat );
}

void	App::createLights()
{
	ISceneManager *smgr = mDevice->getSceneManager();

	smgr->setAmbientLight( SColorf( 0.5f, 0.5f, 0.5f, 1 ) );

	ILightSceneNode *lightNode1 = smgr->addLightSceneNode( 0, vector3df( -500, 100, -500 ) );
	SLight &lightData1 = lightNode1->getLightData();
	lightData1.AmbientColor = SColorf( 1, 1, 1, 1 ) ;
	lightData1.Radius = 25.0f;

	ILightSceneNode *lightNode2 = smgr->addLightSceneNode( 0, vector3df( 500, 100, -500 ) );
	SLight &lightData2 = lightNode2->getLightData();
	lightData2.AmbientColor = SColorf( 1, 1, 1, 1 ) ;
	lightData2.Radius = 25.0f;

	ILightSceneNode *lightNode3 = smgr->addLightSceneNode( 0, vector3df( -500, 100, 500 ) );
	SLight &lightData3 = lightNode3->getLightData();
	lightData3.AmbientColor = SColorf( 1, 1, 1, 1 ) ;
	lightData3.Radius = 25.0f;

	ILightSceneNode *lightNode4 = smgr->addLightSceneNode( 0, vector3df( 500, 100, 500 ) );
	SLight &lightData4 = lightNode4->getLightData();
	lightData4.AmbientColor = SColorf( 1, 1, 1, 1 ) ;
	lightData4.Radius = 25.0f;


}

void	App::renderText( int x, int y, const stringw &str )
{
	IGUIFont *font = ResourceMgr::GetSingletonPtr()->mBigFont ;

	dimension2d<s32> size = font->getDimension( str.c_str() ); 
	rect<s32> pos( x, y, size.Width + x, size.Height + y );
	ResourceMgr::GetSingletonPtr()->mBigFont->draw( str.c_str(), pos, SColor( 255, 255, 255, 0 ) ); 
}

void	App::renderImage( ITexture *texture, s32 x, s32 y, f32 xscale, f32 yscale )
{
	IVideoDriver *driver = mDevice->getVideoDriver();
	dimension2d<s32> imgSize = texture->getSize();
	
	if( equals( yscale, 0.0f ) )  
	{
		yscale = xscale;
	}
	driver->draw2DImage( texture, 
		rect<s32>( x, y, s32( imgSize.Width * xscale ), s32( imgSize.Height * yscale ) ), 
		rect<s32>( 0, 0, imgSize.Width, imgSize.Height ), 0, 0, true );
	
}

void	App::renderStatus()
{
	ResourceMgr *resMgr = ResourceMgr::GetSingletonPtr();
	IVideoDriver *driver = mDevice->getVideoDriver();
	Player *player = Player::GetSingletonPtr();

	/// life
	driver->draw2DImage( resMgr->mLifeSign, rect<s32>( 10, 10, 60, 60 ), rect<s32>(0,0,64,64), 
		0, 0, true );
	renderText( 70, 20, stringw( player->mLife ) );

	/// score
	driver->draw2DImage( resMgr->mScoreSign, rect<s32>( 250, 10, 310, 60 ), rect<s32>(0,0,32,64), 
		0, 0, true );
	renderText( 350, 20, stringw( player->mScore ) );

	/// bean count
	driver->draw2DImage( resMgr->mBeanSign, rect<s32>( 480, 20, 512, 52 ), rect<s32>(0,0,32,32), 
		0, 0, true );	
	renderText( 530, 20, stringw( World::GetSingletonPtr()->getBeanCount() ) ); 

	/// time
	s32 time = mLevelTime / 1000;
	s32 min = time / 60;
	s32 sec = time % 60;
	stringw timeInfo( min );
	timeInfo += ":";
	if( sec < 10 ) timeInfo += "0";
	timeInfo += sec;

	driver->draw2DImage( resMgr->mClockSign, rect<s32>( 650, 10, 700, 60 ), rect<s32>(0,0,64,64), 
		0, 0, true );	
	renderText( 710, 20, timeInfo );

	if( Player::GetSingletonPtr()->mbGOD )
	{
		renderText( 710, 80, L"GOD" );
	}
}

int		App::getGameState()
{
	return mGameState;
}

void	App::setGameState( int state )
{
	int lastState = mGameState;
	mGameState = state;

	if( mGameState == GAME_STATE_SHOW_LOGO )
	{
		SoundManager::GetSingletonPtr()->playSound( SoundManager::SND_LOGO ); 
	}

	if( mGameState == GAME_STATE_MAIN_MENU )
	{
		MainMenu::GetSingletonPtr()->enter(); 

		/// new music
		SoundManager::GetSingletonPtr()->playNextMusic(); 
	}
	else if( mGameState == GAME_STATE_NORMAL_PLAY &&
		lastState == GAME_STATE_MAIN_MENU )
	{
		/// new game, start at level 1
		World::GetSingletonPtr()->setLevelIndex( 1 );
		World::GetSingletonPtr()->load();
		BulletManager::GetSingletonPtr()->reset();
		EffectManager::GetSingletonPtr()->reset();
		BonusManager::GetSingletonPtr()->reset(); 
		Player::GetSingletonPtr()->reset(); 
		mFXGameOver.reset();
		mFXLevelClear.reset();
		mFXTimeOut.reset();

		/// new music
		SoundManager::GetSingletonPtr()->playNextMusic(); 
	}
	else if( mGameState == GAME_STATE_NORMAL_PLAY &&
		lastState == GAME_STATE_TIMEOUT )
	{
		/// restart the current level
		World::GetSingletonPtr()->load();
		BulletManager::GetSingletonPtr()->reset();
		BonusManager::GetSingletonPtr()->reset(); 
		EffectManager::GetSingletonPtr()->reset();
		Player::GetSingletonPtr()->reset( true ); 
		mFXGameOver.reset();
		mFXLevelClear.reset();
		mFXTimeOut.reset();
	}
	else if( mGameState == GAME_STATE_NORMAL_PLAY &&
		lastState == GAME_STATE_CLEAR )
	{
		/// start the next level
		World::GetSingletonPtr()->load( true );
		BulletManager::GetSingletonPtr()->reset();
		BonusManager::GetSingletonPtr()->reset(); 
		EffectManager::GetSingletonPtr()->reset();
		Player::GetSingletonPtr()->reset( true ); 
		mFXGameOver.reset();
		mFXLevelClear.reset();
		mFXTimeOut.reset();

	}
}

bool	App::OnEvent( SEvent event )
{
	bool r = false;
	if( event.EventType == EET_GUI_EVENT )
	{
		r = MainMenu::GetSingletonPtr()->OnEvent( event ); 
	}

	return r || MastEventReceiver::GetSingletonPtr()->OnEvent( event );
}

void	App::_gameShowLogo()
{
	float dt = getTimeFactor();
	if( mLogo->update( dt ) )
	{
		this->setGameState( GAME_STATE_MAIN_MENU );
	}
}

void	App::_gameMainMenu()
{
	MainMenu::GetSingletonPtr()->update( getTimeFactor() ); 
}

void	App::_gameShowHelp()
{
}

void	App::_gameShowCredits()
{
}

void	App::_gamePlay()
{
	float dt = getTimeFactor();

	if( mGameState == GAME_STATE_NORMAL_PLAY )
	{
		Player::GetSingletonPtr()->update( dt );
	}
	MonsterManager::GetSingletonPtr()->update( dt );
	BulletManager::GetSingletonPtr()->update( dt );
	BonusManager::GetSingletonPtr()->update( dt );
	EffectManager::GetSingletonPtr()->update();

	if( mGameState == GAME_STATE_NORMAL_PLAY )
	{
		if( isTimeOut() )
		{
			Player *player = Player::GetSingletonPtr();
			if( player->kill() )
			{
				setGameState( GAME_STATE_GAMEOVER );
			}
			else
			{
				setGameState( GAME_STATE_TIMEOUT );
			}
		}
	}

	if( mGameState == GAME_STATE_GAMEOVER )
	{
		if( mFXGameOver.update( dt ) )
		{
			/// gameover effect finished
			if( MastEventReceiver::GetSingletonPtr()->keyDown( KEY_RETURN ) )
			{
				setGameState( GAME_STATE_MAIN_MENU );
			}
		}
	}
	if( mGameState == GAME_STATE_TIMEOUT )
	{
		if( mFXTimeOut.update( dt ) )
		{
			/// timeout effect finished
			if( MastEventReceiver::GetSingletonPtr()->keyDown( KEY_RETURN ) )
			{
				setGameState( GAME_STATE_NORMAL_PLAY );
			}
		}
	}
	if( mGameState == GAME_STATE_CLEAR )
	{
		if( mFXLevelClear.update( dt ) )
		{
			/// levelclear effect finished
			if( MastEventReceiver::GetSingletonPtr()->keyDown( KEY_RETURN ) )
			{
				setGameState( GAME_STATE_NORMAL_PLAY );
			}
		}
	}
	if( MastEventReceiver::GetSingletonPtr()->keyDown( KEY_ESCAPE ) )
	{
		setGameState( GAME_STATE_MAIN_MENU );
	}
}

void	App::renderCursor()
{
	ICursorControl *cursor = mDevice->getCursorControl();

	position2d<s32> pos = cursor->getPosition();
	ITexture *texture = ResourceMgr::GetSingletonPtr()->mGUICursor ;

	mDevice->getVideoDriver()->draw2DImage( texture, pos, rect<s32>(0,0,64,64), 0, 
		SColor( 255, 255, 255, 255 ), true );
}

void	App::setIcon( HINSTANCE hInstance )
{
	irr::video::SExposedVideoData exposedData = mDevice->getVideoDriver()->getExposedVideoData(); 
	HWND hWnd = reinterpret_cast<HWND>(exposedData.D3D9.HWnd);  
	
	HICON	hNewIcon = ::LoadIcon( hInstance, (LPCTSTR) IDI_ICON1  );
	SendMessage( hWnd, WM_SETICON, true, (LPARAM)hNewIcon ); 
}

/*
 393,431 561,482 = 168, 51
*/