//********************************************************************
// main()
//********************************************************************
int main(){
//instantiate log object and log
CLog *pLog = CLog::Instance();
pLog->Log("*********************************************************");
pLog->Log("Program starting..................");
pLog->SetDelimiter(':');
pLog->LogDate();
pLog->LogTime();
pLog->Log("************************ *********************************");
cout << "Enter name: ";
cin >> g_playerName;
//system("cls");
//initialize console
Console con(80, 25);//50);
con.SetConsolePosition(0,0);
con.CenterConsoleWindow();
con.cls();
Initialize();
CONSOLE_SCREEN_BUFFER_INFO csbi = con.GetScreenBufferInfo();
pLog->LogPair("Screen Buffer Size",csbi.dwSize.X, csbi.dwSize.Y);
pLog->LogPair("Window Size",csbi.dwMaximumWindowSize.X, csbi.dwMaximumWindowSize.Y);
pLog->LogPair("Left-Top",csbi.srWindow.Left, csbi.srWindow.Top);
pLog->LogPair("Right-Bottom",csbi.srWindow.Right, csbi.srWindow.Bottom);
pLog->LogPair("Maximum Window Size", csbi.dwMaximumWindowSize.X, csbi.dwMaximumWindowSize.Y);
COORD maxSize = con.GetMaximumScreenSize();
pLog->LogPair("Max Size",maxSize.X, maxSize.Y);
//game timer
CTimer loopTimer;
CTimer renderTimer;
loopTimer.Initialize();
renderTimer.Initialize();
double timeDelta = 0;
char buffer[] = "Chuck's Factory Game";
con.setTitle(buffer);
//main game loop
//********************************************
bool quit = false;
while(!quit){
timeDelta = loopTimer.GetTimeDifference();
g_pNext = g_pCurrent->Update(timeDelta);
if(NULL != g_pNext)
{
g_pCurrent = g_pNext;
}
if(g_pCurrent == g_pStateQuit )
quit = true;
// Render our current game object
//if(renderTimer.GetTimer(0.1)== true)
g_pCurrent->Render(con);
}
//********************************************
//end game loop
//free resources
delete g_pStateIntro;
delete g_pStateMenu;
delete g_pStateQuit;
delete g_pStateRules;
delete g_pStateScore;
delete g_pStatePlay;
for(int i = 0; i < 9; ++i)
g_audio.StopSoundClip(i);
system("cls");
//normal termination of game
pLog->Log("*********************************************************");
pLog->Log("Program terminating normally..................");
pLog->SetDelimiter(':');
pLog->LogTime();
pLog->Log("*********************************************************");
return 0;
}
/***********************************************************************************
WinMain - Entry point for program.
***********************************************************************************/
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
CLog *pLog = CLog::Instance();
pLog->Log(" ");
pLog->Log("***************************************");
pLog->Log("Program Start");
pLog->LogDate();
pLog->Log("***************************************");
//request player choose fullscreen or windowed mode
CConfigData cfg;
cfg.LoadConfigFile("assets//data//config.cfg");
bool bFullscreen = false;
bFullscreen = cfg.FullScreen;
int msgReturn = ::MessageBox(NULL, "Fullscreen? (Y/N)", "Select Display Option", MB_YESNO);
if(msgReturn == IDYES)
bFullscreen = true;
//variable declarations
CGameData gameData;
CTimer gTimerFPS;
int gLoopCount = 0;
int gSecondCount = 0;
bool g_bRunning = true;
bool gExitProgram = false; //this is set true with ESC, for rendering to stop properly
if(bFullscreen == true)
gameData.m_windowedYOffset = 0;
else
gameData.m_windowedYOffset = 21;
//determine if we play new or saved game
/*
gameData.m_playNewGame = true;
HRESULT hr = ::MessageBox(0, "Play new game?", "New or saved game!", MB_YESNO);
if(hr == IDYES)
gameData.m_playNewGame = true;
else
gameData.m_playNewGame = false;
*/
//gameData.m_playNewGame = true;
//setup game data
pLog->Log("Program Name", cfg.ProgramName);
pLog->Log("Version", cfg.ProgramVersion);
//create window
HWND hWnd;
WNDCLASSEX wc;
ZeroMemory(&wc, sizeof(WNDCLASSEX));
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC)WindowProc;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = "WindowClass";
wc.hIconSm = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_ICON1));
RegisterClassEx(&wc);
/*
//screen data - need at least 800x600
int cxScreen = ::GetSystemMetrics(SM_CXFULLSCREEN);
int cyScreen = ::GetSystemMetrics(SM_CYFULLSCREEN);
if(cfg.ScreenWidth < 800 || cfg.ScreenWidth > cxScreen)
cfg.ScreenWidth = cxScreen;
if(cfg.ScreenHeight < 600 || cfg.ScreenHeight > cyScreen)
cfg.ScreenHeight = cyScreen;
cfg.ScreenLeft = cxScreen/2 - cfg.ScreenWidth/2;
cfg.ScreenTop = cyScreen/2 - cfg.ScreenHeight/2;
*/
if(!bFullscreen)
{
if(cfg.ScreenWidth < 800)
{
cfg.ScreenWidth = 800;
}
if(cfg.ScreenHeight < 600)
{
cfg.ScreenHeight = 600;
}
}
cfg.ScreenLeft = 0;
cfg.ScreenTop = 0;
/*
// set up and initialize Direct3D
CGraphics con();// cfg.FullScreen);
int screenWidth = 0;
int screenHeight = 0;
if(con.InitializeDirectX(screenWidth, screenHeight, bFullscreen) == false){
pLog->Log("Failure initializing DirectX!");
::MessageBox(0,"Failed to initialize DirectX", "Error", 0);
return 0;
}
pLog->Log("DirectX Initialized");
*/
int cxScreen = ::GetSystemMetrics(SM_CXFULLSCREEN);
int cyScreen = ::GetSystemMetrics(SM_CYFULLSCREEN);
if(cfg.ScreenWidth < 800 || cfg.ScreenWidth > cxScreen)
cfg.ScreenWidth = cxScreen;
if(cfg.ScreenHeight < 600 || cfg.ScreenHeight > cyScreen)
cfg.ScreenHeight = cyScreen;
cfg.ScreenLeft = cxScreen/2 - cfg.ScreenWidth/2;
cfg.ScreenTop = cyScreen/2 - cfg.ScreenHeight/2;
//create window
std::string sCaption = cfg.ProgramName + " - " + cfg.ProgramVersion;
hWnd = CreateWindowEx(NULL,
"WindowClass",
sCaption.c_str(), //cfg.ProgramVersion.c_str(),
bFullscreen == true ? WS_EX_TOPMOST | WS_POPUP : WS_BORDER | WS_CAPTION | WS_SYSMENU,
cfg.ScreenLeft, cfg.ScreenTop,
/*0, 0, screenWidth, screenHeight,*/
bFullscreen == true ? CW_USEDEFAULT : cfg.ScreenWidth,
bFullscreen == true ? CW_USEDEFAULT : cfg.ScreenHeight,
NULL,NULL,hInstance,NULL);
ShowWindow(hWnd, nCmdShow);
pLog->Log("Window Loaded and Displayed!");
gameData.m_hWnd = hWnd;
/*
// set up and initialize Direct3D
CGraphics con(hWnd, cfg.ScreenWidth, cfg.ScreenHeight,bFullscreen);// cfg.FullScreen);
if(con.InitializeDirectX() == false){
pLog->Log("Failure initializing DirectX!");
::MessageBox(hWnd,"Failed to initialize DirectX", "Error", 0);
return 0;
}
pLog->Log("DirectX Initialized");
*/
CGraphics con(hWnd, cfg.ScreenWidth, cfg.ScreenHeight, bFullscreen);
if(con.InitializeDirectX() == false)
{
::MessageBox(hWnd, "Failed to Create IDirect3D9 Interface.", "Error", 0);
return 0;
}
if(con.IsDisplayModeSupported() == false)
{
::MessageBox(hWnd, "Display mode not supported.", "Error", 0);
return 0;
}
if(con.InitializeDevice() == false)
{
::MessageBox(hWnd, "Could not create IDirect3DDevice9 Device.", "Error", 0);
return 0;
}
//load framework assets
if(con.LoadAssetFile(cfg.FrameworkAssetFile) == false){
pLog->Log("Failure loading " + cfg.FrameworkAssetFile);
::MessageBox(hWnd,"Failed to load editor.dat file", "Error", 0);
return 0;
}
else
pLog->Log(cfg.FrameworkAssetFile + " (frame graphics) was loaded successfully!");
//load game play assets
if(con.LoadAssetFile(cfg.GamePlayAssetFile) == false){
pLog->Log("Failure loading " + cfg.GamePlayAssetFile);
::MessageBox(hWnd,"Failed to load assets.dat file", "Error", 0);
return 0;
}
else
pLog->Log(cfg.GamePlayAssetFile + " (game play graphics) was loaded successfully!");
//load objects
//***************************************************************************
if(gameData.LoadObjectFile(cfg.GameObjectFile) == false){
pLog->Log("Failure loading " + cfg.GameObjectFile);
//::MessageBox(hWnd,"Failed to load objects.dat file", "Error", 0);
// return 0;
}
else{
pLog->Log(cfg.GameObjectFile + " (objects file) was loaded successfully!");
// for(int i = 0; i < gameData.m_catalog.GetTableSize();++i){
// pLog->Log("object", gameData.m_catalog.GetTerm(i, 0), gameData.m_catalog.GetTerm(i, 2));
// }
}
gTimerKey.Initialize();
gTimerKey.ResetTimer();
mouse.SetHandle(hWnd);
gTimerFPS.Initialize();
//game timer for update
CTimer timerGame;
timerGame.Initialize();
//define events for changing game states
//*************************************************************************
//g_pStateIntro->AddTransitionEvent(EVENT_GO_PLAY1, g_pStatePlay1);
//g_pStatePlay1->AddTransitionEvent(EVENT_GO_CREDITS, g_pStateCredits);
g_pStateIntro->AddTransitionEvent(EVENT_GO_MAIN, g_pStateMain);
g_pStateMain->AddTransitionEvent(EVENT_GO_PLAY1, g_pStatePlay1);
g_pStateMain->AddTransitionEvent(EVENT_GO_HELP, g_pStateHelp);
g_pStateMain->AddTransitionEvent(EVENT_GO_CREDITS, g_pStateCredits);
g_pStatePlay1->AddTransitionEvent(EVENT_GO_QUIT, g_pStateQuit);
//g_pStatePlay1->AddTransitionEvent(EVENT_GO_MAIN, g_pStateMain);
g_pStateHelp->AddTransitionEvent(EVENT_GO_MAIN, g_pStateMain);
g_pStateCredits->AddTransitionEvent(EVENT_GO_QUIT, g_pStateQuit);
g_pCurrent = g_pStatePlay1;// g_pStateIntro;
// enter the main loop
//************************************** M A I N L O O P *****************
MSG msg;
pLog->Log("Entering Main Control Loop");
float timeDiff = 0.0f;
g_pCurrent->Activate(gameData, cfg, con);
while(g_bRunning)
{
DWORD starting_point = GetTickCount();
::Sleep(0);
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
//manage frame count determination
gLoopCount++;
if(gTimerFPS.getTimer(1.0) == true){
gameData.m_FPS = static_cast<float>(gLoopCount);
gLoopCount = 0;
gSecondCount++;
if(gSecondCount > 30){ //log every 30 seconds
gSecondCount = 0;
if(cfg.LogDebugInfo == true)
pLog->Log("FPS",gameData.m_FPS);
}
}
//stores mouse button status for use in other classes
gameData.m_bLeftMouseDown = mouse.LeftButtonDown();
gameData.m_bRightMouseDown = mouse.RightButtonDown();
//update
g_pLast = g_pCurrent;
g_pNext = g_pCurrent->Update(timerGame.getTimeDifference(), gameData, cfg, con);
if(g_pNext == g_pStateQuit)
g_bRunning = false;
else if(NULL != g_pNext)
{
if(g_pNext != g_pLast){
g_pLast->Deactivate(gameData, cfg, con);
g_pCurrent = g_pNext;
g_pCurrent->Activate(gameData, cfg, con);
}
}
//render
g_pCurrent->Render(con, gameData, cfg);
// check the 'escape' key
if(g_bRunning == false){
gExitProgram = true;
PostMessage(hWnd, WM_DESTROY, 0, 0);
}
}
pLog->Log("Exited main loop");
// clean up DirectX and COM
con.CleanupDirectX();
Shutdown();
pLog->Log("DirectX Cleaned Up");
pLog->Log("Shutdown complete!");
pLog->Log("***************************************");
pLog->Log(" Program Terminated Normally");
pLog->Log("***************************************");
return static_cast<int>(msg.wParam);
}
/************************************************************************************************
WinMain (...)
************************************************************************************************/
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
// Always perform a leak check just before app exits.
int nDbgFlags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
nDbgFlags |= _CRTDBG_LEAK_CHECK_DF;
_CrtSetDbgFlag(nDbgFlags);
//instantiate log object and log
CLog *pLog = CLog::Instance();
pLog->Log("*********************************************************");
pLog->Log("Program starting..................");
pLog->SetDelimiter(':');
pLog->LogDate();
pLog->LogTime();
pLog->Log("************************ *********************************");
pLog->Log ("***********************************************");
pLog->Log("Game Challenge 6");
pLog->LogDate();
pLog->LogTime();
pLog->Log("***********************************************");
Graphics g_con;
CAudioManager *pAudio = CAudioManager::Instance();
//***********************************************************************
//read config.ini file
// C O N F I G . I N I
//***********************************************************************
pLog->Log("************ Config.ini ************");
CINIReader config; //reads and stores INI file data
config.LoadFile("config.ini");
std::string sValue;
std::string sParameter;
int nParameterValue;
//default values
g_Global.g_screenWidth = 1024;
g_Global.g_screenHeight = 768;
if(config.IsValid() == true){
pLog->Log("Valid config.ini file");
pLog->Log("Numbers of lines in config file",config.GetNumberOfLines());
for(int j=0; j< config.GetNumberOfLines();j++){
sParameter = config.GetTerm(config.GetLineFromFile(j),1);
sValue = config.GetTerm(config.GetLineFromFile(j),2);
nParameterValue = atoi(sValue.c_str());
pLog->Log(sParameter, nParameterValue);
//load g_Global object with config.ini data
if(sParameter == "WindowedMode" && nParameterValue == 1)
g_Global.g_WindowedMode = true;
else if(sParameter == "WindowedMode" && nParameterValue == 0)
g_Global.g_WindowedMode = false;
//else if(sParameter == "ScreenWidth" && nParameterValue > 0)
// g_Global.g_screenWidth = nParameterValue;
//else if(sParameter == "ScreenHeight" && nParameterValue > 0)
// g_Global.g_screenHeight = nParameterValue;
//else if(sParameter == "GameLevel" && nParameterValue > 0 && nParameterValue < 6)
// g_Global.g_GameLevel = nParameterValue;
//else if(sParameter == "GameSnow" && nParameterValue == 1)
// g_Global.g_bGameSnow = true;
//else if(sParameter == "GameSnow" && nParameterValue == 0)
// g_Global.g_bGameSnow = false;
else if(sParameter == "GameAudio" && nParameterValue == 1)
g_Global.g_bGameAudio = true;
else if(sParameter == "GameAudio" && nParameterValue == 0)
g_Global.g_bGameAudio = false;
else if(sParameter == "FrameRate" && nParameterValue == 1)
g_Global.g_bDisplayFramerate = true;
else if(sParameter == "FrameRate" && nParameterValue == 0)
g_Global.g_bDisplayFramerate = false;
}
}
pLog->Log("Reading Config.ini file is complete!");
// Break on specific memory allocation number
//_CrtSetBreakAlloc(175);
MSG msg;
g_bRunning = true;//Start program running
//Make a window and initialize DirectX in windowed mode
MakeWindow(hInstance, g_Global.g_WindowedMode, g_con);
//map game state information
g_pStateIntro->addTransitionEvent(EVENT_GO_MAIN, g_pStateMain);
g_pStateMain->addTransitionEvent(EVENT_GO_HISTORY, g_pStateHistory);
g_pStateMain->addTransitionEvent(EVENT_GO_RELOAD, g_pStateReload);
g_pStateMain->addTransitionEvent(EVENT_GO_CREDITS, g_pStateCredits);
g_pStateMain->addTransitionEvent(EVENT_GO_SELECT, g_pStateSelect);
g_pStateHistory->addTransitionEvent(EVENT_GO_MAIN, g_pStateMain);
g_pStateReload->addTransitionEvent(EVENT_GO_MAIN, g_pStateMain);
g_pStateCredits->addTransitionEvent(EVENT_GO_END, g_pStateEnd);
g_pStateSelect->addTransitionEvent(EVENT_GO_AWARDS, g_pStateAwards);
g_pStateAwards->addTransitionEvent(EVENT_GO_SELECT, g_pStateSelect);
g_pStateSelect->addTransitionEvent(EVENT_GO_PLAY, g_pStatePlay);
g_pStateSelect->addTransitionEvent(EVENT_GO_MAIN, g_pStateMain);
g_pStatePlay->addTransitionEvent(EVENT_GO_WIN, g_pStateWin);
g_pStatePlay->addTransitionEvent(EVENT_GO_LOSE, g_pStateLose);
g_pStateWin->addTransitionEvent(EVENT_GO_SELECT, g_pStateSelect);
g_pStateLose->addTransitionEvent(EVENT_GO_SELECT, g_pStateSelect);
g_pStatePlay->addTransitionEvent(EVENT_GO_SELECT, g_pStateSelect);
g_pStatePlay->addTransitionEvent(EVENT_GO_CONTROL, g_pStateControl);
//sonar transitions
g_pStateSonar->addTransitionEvent(EVENT_GO_RADAR, g_pStateRadar);
g_pStateSonar->addTransitionEvent(EVENT_GO_FIRECONTROL, g_pStateFireControl);
g_pStateSonar->addTransitionEvent(EVENT_GO_STATUS, g_pStateStatus);
g_pStateSonar->addTransitionEvent(EVENT_GO_CHART, g_pStateChart);
g_pStateSonar->addTransitionEvent(EVENT_GO_CONTROL, g_pStateControl);
//radar transitions
g_pStateRadar->addTransitionEvent(EVENT_GO_SONAR, g_pStateSonar);
g_pStateRadar->addTransitionEvent(EVENT_GO_FIRECONTROL, g_pStateFireControl);
g_pStateRadar->addTransitionEvent(EVENT_GO_STATUS, g_pStateStatus);
g_pStateRadar->addTransitionEvent(EVENT_GO_CHART, g_pStateChart);
g_pStateRadar->addTransitionEvent(EVENT_GO_CONTROL, g_pStateControl);
//scope transitions
g_pStateScope->addTransitionEvent(EVENT_GO_CONTROL, g_pStateControl);
g_pStateScope->addTransitionEvent(EVENT_GO_WIN, g_pStateWin);
g_pStateScope->addTransitionEvent(EVENT_GO_LOSE, g_pStateLose);
//conn transitions
g_pStateControl->addTransitionEvent(EVENT_GO_PLAY, g_pStatePlay);
g_pStateControl->addTransitionEvent(EVENT_GO_SONAR, g_pStateSonar);
g_pStateControl->addTransitionEvent(EVENT_GO_RADAR, g_pStateRadar);
g_pStateControl->addTransitionEvent(EVENT_GO_FIRECONTROL, g_pStateFireControl);
g_pStateControl->addTransitionEvent(EVENT_GO_STATUS, g_pStateStatus);
g_pStateControl->addTransitionEvent(EVENT_GO_CHART, g_pStateChart);
g_pStateControl->addTransitionEvent(EVENT_GO_SCOPE, g_pStateScope);
g_pStateControl->addTransitionEvent(EVENT_GO_SELECT, g_pStateSelect);
g_pStateControl->addTransitionEvent(EVENT_GO_WIN, g_pStateWin);
g_pStateControl->addTransitionEvent(EVENT_GO_LOSE, g_pStateLose);
//fire control transitions
g_pStateFireControl->addTransitionEvent(EVENT_GO_SONAR, g_pStateSonar);
g_pStateFireControl->addTransitionEvent(EVENT_GO_RADAR, g_pStateRadar);
g_pStateFireControl->addTransitionEvent(EVENT_GO_STATUS, g_pStateStatus);
g_pStateFireControl->addTransitionEvent(EVENT_GO_CHART, g_pStateChart);
g_pStateFireControl->addTransitionEvent(EVENT_GO_CONTROL, g_pStateControl);
//status transitions
g_pStateStatus->addTransitionEvent(EVENT_GO_SONAR, g_pStateSonar);
g_pStateStatus->addTransitionEvent(EVENT_GO_RADAR, g_pStateRadar);
g_pStateStatus->addTransitionEvent(EVENT_GO_FIRECONTROL, g_pStateFireControl);
g_pStateStatus->addTransitionEvent(EVENT_GO_CHART, g_pStateChart);
g_pStateStatus->addTransitionEvent(EVENT_GO_CONTROL, g_pStateControl);
//chart transitions
g_pStateChart->addTransitionEvent(EVENT_GO_SONAR, g_pStateSonar);
g_pStateChart->addTransitionEvent(EVENT_GO_RADAR, g_pStateRadar);
g_pStateChart->addTransitionEvent(EVENT_GO_FIRECONTROL, g_pStateFireControl);
g_pStateChart->addTransitionEvent(EVENT_GO_STATUS, g_pStateStatus);
g_pStateChart->addTransitionEvent(EVENT_GO_CONTROL, g_pStateControl);
g_pStateChart->addTransitionEvent(EVENT_GO_WIN, g_pStateWin);
g_pStateChart->addTransitionEvent(EVENT_GO_LOSE, g_pStateLose);
g_Timer.initialize();
g_LoopTimer.initialize();
g_FPS_Timer.initialize();
g_con.InitD3D (g_hWnd, g_Global.g_WindowedMode);
//***********************************************************************
//load textures from graphics file
// G R A P H I C F I L E S . D A T
//***********************************************************************
pLog->Log("************ Graphicfiles.dat ************");
CFileReader* cfr = new CFileReader;
cfr->LoadFile("data\\graphicfiles.dat");
int fileNumber;
std::string fileName;
if(cfr->IsValid()== true){
pLog->Log("Numbers of lines in file",cfr->GetNumberOfLines());
for(int j=0; j< cfr->GetNumberOfLines();j++){
sValue =cfr->GetTerm(cfr->GetLineFromFile(j),1);
fileNumber = atoi(sValue.c_str());
sValue = cfr->GetTerm(cfr->GetLineFromFile(j),2);
fileName = "assets\\artwork\\";
fileName = fileName + sValue;
//pLog->Log("Loaded file",fileName);
pLog->Log(fileName, fileNumber);
g_con.LoadTexture(fileName, fileNumber);
}
}
else{
pLog->Log("ERROR****************** Failure to load textures (graphicfiles.dat)");
delete cfr;
g_con.CloseD3D();
pLog->Log("DirectX closed!");
Shutdown();
return 0;
}
if(g_Sprite.LoadSprites() == true){
pLog->Log("Sprites loaded!");
}
else{
pLog->Log("ERROR****************** Failure to sprite data (sprites.dat)");
}
//used for framerate display
std::ostringstream oss;
std::string sFramerate;
std::string sText;
int nDisplayFPSCount = 0;
//initialize audio manager
//***************************************************************
if(g_Global.g_bGameAudio == true){
pLog->Log("Loading audio clip...");
if(pAudio->IsValidSound())
pLog->Log("Audio system is okay!");
else
pLog->Log("Audio system failure!");
//load sounds
pAudio->LoadSample(SOUND_BEEP, "assets\\sounds\\beep-03.wav");
pAudio->LoadSample(SOUND_REMEMBER, "assets\\sounds\\remember.mp3");
pAudio->LoadSample(SOUND_HYMN, "assets\\sounds\\navy_hymn.mp3");
pAudio->LoadSample(SOUND_PERISCOPE, "assets\\sounds\\periscop.wav");
pAudio->LoadSample(SOUND_BUTTON_CLICK, "assets\\sounds\\button_click.wav");
pAudio->LoadSample(SOUND_DEPTH_CHARGE1,"assets\\sounds\\dc1.mp3");
pAudio->LoadSample(SOUND_DEPTH_CHARGE2,"assets\\sounds\\dc2.mp3");
pAudio->LoadSample(SOUND_TORPEDO1,"assets\\sounds\\torpedo3.mp3");
pAudio->LoadSample(SOUND_TORPEDO2,"assets\\sounds\\torpedo4.mp3");
pAudio->LoadSample(SOUND_AMBIENCE1,"assets\\sounds\\ambience1.mp3");
pAudio->LoadSample(SOUND_CLEAR_BRIDGE,"assets\\sounds\\clear_bridge.wav");
pAudio->LoadSample(SOUND_DIVING,"assets\\sounds\\diving.mp3");
pAudio->LoadSample(SOUND_GQ,"assets\\sounds\\general_quarters.wav");
pAudio->LoadSample(SOUND_ANCHORS,"assets\\sounds\\AnchorsAway.mp3");
pAudio->LoadSample(SOUND_TAPS,"assets\\sounds\\Taps.mp3");
pAudio->LoadSample(SOUND_SINKING,"assets\\sounds\\sinking2.mp3");
pAudio->LoadSample(SOUND_ANTHEM,"assets\\sounds\\USA.mp3");
pAudio->LoadSample(SOUND_FUNERAL,"assets\\sounds\\fnrlMrch.wav");
pAudio->LoadSample(SOUND_PING,"assets\\sounds\\sonar1.mp3");
//load stream
pAudio->LoadStream(SOUND_BIO, "assets\\sounds\\fish.mp3");
pAudio->AddStreamClip(SOUND_BIO1, SOUND_BIO, 0, 17708);
pAudio->AddStreamClip(SOUND_BIO2, SOUND_BIO, 17708, 26434);
pAudio->AddStreamClip(SOUND_BIO3, SOUND_BIO, 26434, 42859);
pAudio->AddStreamClip(SOUND_BIO4, SOUND_BIO, 42859, 59541);
pAudio->AddStreamClip(SOUND_BIO5, SOUND_BIO, 59541, 80073);
for(int i = 0; i < pAudio->Size(); i++){
pLog->Log(pAudio->GetFilename(i), i); //write filename and file index to log file
}
}
else{
pLog->Log("Audio disabled");
}
pLog->Log("Main game loop entered!");
::ShowCursor(false);
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Version Number
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Version Number
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Version Number
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Version Number
g_strFPS = "Game Challenge 6 (Chuck Bolin) - \"Sinking of the Rising Sun\", v0.047 Final Version";
::SetWindowText(g_hWnd, g_strFPS.c_str());
double timeDelta;
g_con.InitializePyro();
//Main application loop
//*******************************************************
while (g_bRunning)
{
//Handle messages
if (PeekMessage (&msg,NULL,0,0,PM_REMOVE)){
TranslateMessage (&msg);
DispatchMessage (&msg);
}
else{}
timeDelta = g_LoopTimer.getTimeDifference();
g_pNext = g_pCurrent->update(timeDelta);
if(g_pNext == g_pStateEnd)
g_bRunning = false;
else if(NULL != g_pNext)
{
g_pCurrent->deactivate();
g_pCurrent = g_pNext;
g_pCurrent->activate();
}
// Render our current game object
g_pCurrent->render(g_con);
//call each second update FPS
nDisplayFPSCount++;
if(g_FPS_Timer.getTimer(1)){
//g_FPS_Counter++;
oss.str(""); //clear oss
oss << (int) nDisplayFPSCount;
//if(g_FPS_Counter > 60){ //call every 60 seconds
// pLog->Log("FPS",oss.str());
// g_FPS_Counter == 0;
//}
// update our FPS string.
// This thing can be rendered inside any of the game objects.
g_strFPS = "FPS " + oss.str();
g_Global.g_strFPS = "FPS " + oss.str();
nDisplayFPSCount=0;//reset frame count
}
}//while(...
g_con.ClosePyro();
g_con.CloseD3D();
pLog->Log("DirectX closed!");
Shutdown();
return 0;//(int)msg.wParam; //returns exit code to operating system
}