void ThreadProc::StatusEndProc ()
{
    GetEndTime ();
    UIFreshFoo(theTaskList.length ()-1);
    GameOver ();
    return;
}

void LifeCounter::Die() {
	if (lives == 0) {
		GameOver();
	} else {
		lives--;
	}
}

void Game::GameOver()
{
    sf::Texture BackgroundTexture;
    sf::Sprite BackgroundSprite;
    BackgroundTexture.loadFromFile("Graphics/MainMenu.jpg");
    BackgroundSprite.setTexture(BackgroundTexture);
    sf::Text GameOver("Game Over...", Font, 90U);
    GameOver.setStyle(sf::Text::Bold);
    GameOver.setPosition(300, 320);

    sf::Event Event;
    while(Window.isOpen()) 
    {
        while(Window.pollEvent(Event))
        {
            if(Event.type == sf::Event::KeyPressed)
            {
                exit(0);
            }
        }
        Window.clear();
        Window.draw(BackgroundSprite);
        Window.draw(GameOver);
        Window.display();
    }
}

void CTetrisDlg::OnTimer(UINT_PTR nIDEvent)
{
    if(m_pBlock->canMoveDown())
    {
        m_pBlock->moveDown();
    }
    else
    {
        for(CHAR i = ROW - 1; i >= 0; --i)
        {
            if(CheckLine(i))
            {
                RemoveLine(i);
                ++i;
            }
        }
        MSG msg;
        while(::PeekMessage(&msg, m_hWnd, 0, 0, PM_REMOVE));
        if(IsGameOver(m_gameParam & 0xE0))
        {
            GameOver();
        }
        else
        {
            delete m_pBlock;
            m_pBlock = BlockFromIndex(m_gameParam & 0xE0);
            NextRandomBlock();
            m_nextColor = NextRandomColor();
        }
    }
    Invalidate(FALSE);
    CDialog::OnTimer(nIDEvent);
}

void MyPS2Application::Update()
{
	// Tell DMAC to send previous graphics data to Graphics Synthesiser (GS)
	VIFDynamicDMA.Fire();
	
	// Read the control pad into data buffer
	pad_update(PAD_0);
	
	// Check for exit condition
	if((pad[0].buttons & PAD_START)&&(pad[0].buttons & PAD_SELECT)) quitting_ = true;

	// State Handler
	switch (game_state)
	{
	case INTRO:
		Intro();
		break;
	
	case MENU:
		Menu();
		break;
		
	case GAME:
		Game();
		break;
		
	case GAME_OVER:
		GameOver();
		break;
	}
	
	DSP0.HandleAudio();
	DSP1.HandleAudio();
}

// Handle the gameflow, start, restartm die...etc.
void ShipRace::Update()
{
	// Get the button to start the game if the game is not already started...Meh !
	if (gDInput->keyPressed(DIK_SPACE) && !mGameStarted)
	{
		// Init the game
		InitGame();
	}
	
	// If gameOver...
	if (!mGameOver)
	{
		// and the game is started...
		if (mGameStarted)
		{
			// and the ship is dead
			if (ship->GetIsDead())
			{
				// Gameover !
				GameOver();
			}
		}
	}
	// Else if space is pressed and it is gameover
	else if (gDInput->keyPressed(DIK_SPACE) && mGameOver)
	{
		// Restart the game
		RestartGame();
	}
	
}

bool GameClassic::doRun()
{
	SDL_Event event;
	if(SDL_PollEvent(&event))
	{
		switch(event.type)
		{
			case SDL_QUIT:
			{
				return false;
				break;
			}
			case SDL_KEYDOWN:
			{
				if ( event.key.keysym.sym == SDLK_ESCAPE ) 
				{
					m_mgr->SetActiveModule(MAINMENU);
					return true;
				} 
				if ( event.key.keysym.sym == SDLK_p || event.key.keysym.sym == SDLK_SPACE) 
				{
					doPause();
				} 
				if ( event.key.keysym.sym == SDLK_UP && snake->GetDirection()!=Down) 
				{
					snake->SetDirection(Up);
				} 
				if ( event.key.keysym.sym == SDLK_DOWN && snake->GetDirection()!=Up) 
				{
					snake->SetDirection(Down);
				} 
				if ( event.key.keysym.sym == SDLK_LEFT && snake->GetDirection()!=Right) 
				{
					snake->SetDirection(Left);
				} 
				if ( event.key.keysym.sym == SDLK_RIGHT && snake->GetDirection()!=Left) 
				{
					snake->SetDirection(Right);
				} 
				break;
			}
		}

	}
	if(snake->Move())
	{
		Converter.Convert();
		DrawField();
		DrawTop();
		SDL_Delay(50);
	}
	else
	{
		Converter.Convert();
		DrawField();
		DrawTop();
		GameOver();		
	}
	return true;
}

int main(void)
{
	int menu;
	FsOpenWindow(32, 32, winWidth, winHeight, 1); // 800x600 pixels, useDoubleBuffer=1

	int listBase;
	listBase=glGenLists(256);
	YsGlUseFontBitmap8x12(listBase);
	glListBase(listBase);

	glDisable(GL_DEPTH_TEST);
	glDisable(GL_LIGHTING);
	glDepthFunc(GL_ALWAYS);

	while(1)
	{
		menu=Menu();
		if(menu==1)
		{
			int score;
			score=Game();
			GameOver(score);
		}
		else if(menu==eStop)
		{
			break;
		}
	}

	return 0;
}

void Level::Update(float dt)
{
    world->Step((dt / 100), 5, 5);
    if (player->GetYPos() > lvlHeight)
    {

        GameOver();
    }
}

void ControlTetris::siguientePieza(){
	posX = 3;
	posY = 1;
	if(p != NULL) delete p;
	p = pSig;
	if(!mt->pintaPiezaEn(*p,posY,posX))	throw(GameOver(*mt));
	pSig = piezaAleatoria();
	mt->pintaPiezaSig(*pSig);
}

void StepManiaLanServer::ParseData(PacketFunctions& Packet, const unsigned int clientNum)
{
	int command = Packet.Read1();
	switch (command)
	{
	case NSCPing:
		// No Operation
		SendValue(NSServerOffset + NSCPingR, clientNum);
		break;
	case NSCPingR:
		// No Operation response
		break;
	case NSCHello:
		// Hello
		Hello(Packet, clientNum);
		break;
	case NSCGSR:
		// Start Request
		Client[clientNum]->StartRequest(Packet);
		CheckReady();  //This is what ACTUALLY starts the games
		break;
	case NSCGON:
		// GameOver 
		GameOver(Packet, clientNum);
		break;
	case NSCGSU:
		// StatsUpdate
		Client[clientNum]->UpdateStats(Packet);
		if (!Client[clientNum]->lowerJudge)
			CheckLowerJudge(clientNum);
		break;
	case NSCSU:
		// Style Update
		Client[clientNum]->StyleUpdate(Packet);
		SendUserList();
		break;
	case NSCCM:
		// Chat message
		AnalizeChat(Packet, clientNum);
		break;
	case NSCRSG:
		SelectSong(Packet, clientNum);
		break;
	case NSCSMS:
		ScreenNetMusicSelectStatus(Packet, clientNum);
		break;
	case NSCUPOpts:
		Client[clientNum]->Player[0].options = Packet.ReadNT();		
		Client[clientNum]->Player[1].options = Packet.ReadNT();		
		break;
	default:
		break;
	}
}	 

void Grid::drop()
{
	if(GameOver())
	{
		return;
	}

	while(!collision())
	{
		current->nudge(0,-1);
	}
}

// 블럭 상태 및 스테이지 업뎃
void Tetris::Update()
{
	int key = KeyInput();
	switch( stage )
	{
	case INIT :
		press_any_key( key );
		break;
	case READY :
		level_select( key );
		break;
	case RUNNING :
		m_block->Move( key );

		// 블럭이 바닥이나 다른 블럭에 닿았다면 합침
		if( m_block->GetBlockState() == 2 )
			merge_block( m_block->GetBlockX(), m_block->GetBlockY() );

		// 꽉 찬 라인이 있는지 확인
		m_full_line_num = check_full_line();
		if( m_full_line_num != 0 )
			full_line_Set();

		if( stage_data[m_level].clear_line == m_line )
		{
			++m_level;
			if( m_level >= MAX_STAGE )
			{
				stage = SUCCESS;
			}
			m_line = 0;
		}

		// 게임 오버~
		if( GameOver() )
			stage = FAILED;
		break;
	case SUCCESS:
	case FAILED:
		if( key == 'y' || key == 'Y' )
		{
			stage = READY;
			Init();
		}
		if( key == 'n' || key == 'N' )
			stage = RESULT;
		break;
	case RESULT:
			m_bIsGameOver = true;
		break;
	}
}

void Grid::spin()
{
	if(GameOver())
	{
		return;
	}

	if (current)
	{
		SoundManager::instance()->playSound(spinfx);
		current->spin();
	}
}

void GameLayer::update(float dt){
    if (!HeadCollideBody(head->getDirec()) && !OutofRange()) {
         MoveStep();
        if(ifGetFood()){
            AddBody();
            SetFood();
        }
        lastbodyposi = body.at(body.size()-1)->getPosition();
    }
    else{
        GameOver();
    }
}

void byoSnake::Died()
{
    if ( --m_Lives == 0 )
    {
        Refresh();
        GameOver();
        return;
    }

    InitializeSnake();
    RandomizeApple();
    StartSnake();
}

void CGame::Play()
{
	CBoard *Board = new CBoard;
	Board->DrawBoard();
	delete Board;
	CSnake *Snake = new CSnake;
	//sets difficulty
	switch(dif_lvl)
	{
	case easy:
		CSnake::delay = 160;
		CSnake::multiplier = 1;
		break;
	case medium:
		CSnake::delay = 140;
		CSnake::multiplier = 1;
		break;
	case hard:
		CSnake::delay = 120;
		CSnake::multiplier = 0.9;
		break;
	case extreme:
		CSnake::delay = 100;
		CSnake::multiplier = 0.8;
		break;
	}
	while(Snake->Move() != 0)
	{
		if(GetAsyncKeyState(VK_UP) & 0x8000)
		{
			Snake->ChangeDirection(up);
		}
		else if(GetAsyncKeyState(VK_DOWN) & 0x8000)
		{
			Snake->ChangeDirection(down);
		}
		else if(GetAsyncKeyState(VK_LEFT) & 0x8000)
		{
			Snake->ChangeDirection(static_cast<Direction>(2));
		}
		else if(GetAsyncKeyState(VK_RIGHT) & 0x8000)
		{
			Snake->ChangeDirection(static_cast<Direction>(3));
		}
		else if(GetAsyncKeyState(VK_ESCAPE) & 0x8000)
			break; 
	}
	int score = Snake->GetScore();
	delete Snake;
	GameOver(score);
}

void GameScene::Update( float elapsedTime )
{
	GameStateModel::Update(elapsedTime);
	if (GameStateModel::TimeRemaining() <= 0) {
		GameOver();
		return;
	}

	ScoreView::Update(elapsedTime);
	TimerController::Update(elapsedTime);
	BoardView::get()->Update(elapsedTime);
	SelectedTextLabel::get()->Update(elapsedTime);
	TimeTankView::Update(elapsedTime);
}

void GameManager::AI()
{
	CheckKey();
	if (GameStart() && !GamePause() && !GameOver())
	{
		Produce(_T("Enemy"));
		Produce(_T("Cloud"));
		Produce(_T("Angela"));
		CheckCollision();
		MoveIt();
		Fire();
		TrashRecycle();
	}
}

// This is my primary Event Loop. This is where most of the fun stuff happens ;)
void Megamaniac() {
    // WTF does this do? Something to do with my Data Structure I assume...
    Game game;

	while (true) {
	    // Let's run our initial setup to get everything for the game ready.
	    SetupGame(&game);

	    // Do we need to change the level? Not really but we should probably start at Level 1.
	    ChangeLevel(&game);

		// This is where the Event Loop actually starts. This will run repeatedly until our game is over.
	    while (!game.game_over) {
		    clear_screen();
		    GameStats(&game);
			int userInput = UserInput(&game);
		    MovementPlayer(&game, userInput);
			MovementMissiles(&game, userInput);
		    MovementAliens(&game);
			MovementBombs(&game);
			MovementBonuses(&game);

			CollisionMissiles(&game);
			CollisionAliens(&game);
		    CollisionBombs(&game);
			CollisionBonuses(&game);

			UpdateScreen(&game);
		    show_screen();
		    timer_pause(25);
	    }

		GameOver(&game);

		int userInput = wait_char();
		while (userInput != 'r' && userInput >= 0) {
			if (userInput == 'q') {
				exit(0);
			}
			if (userInput == 'r') {
				Megamaniac();
			}
			userInput = wait_char();
		}
	}
}