Пример #1
0
//private
void ReversiGame::setBoard(QSharedPointer<ReversiBoard> nBoard)
{
    if (nBoard.isNull())
        return;

    ReversiBoard * raw = nBoard.data();
    connect(raw,
            SIGNAL(moveMade(CELL_STATE,CELL_STATE)),
            this,
            SLOT(handleTurnTaken(CELL_STATE,CELL_STATE)));
    connect(raw,
            SIGNAL(moveMade(CELL_STATE,CELL_STATE)),
            this,
            SIGNAL(turnTaken(CELL_STATE,CELL_STATE)));
    connect(raw,
            SIGNAL(gameOver(CELL_STATE)),
            this,
            SLOT(handleGameOver(CELL_STATE)));
    connect(raw,
            SIGNAL(gameOver(CELL_STATE)),
            this,
            SIGNAL(gameOver(CELL_STATE)));
    connect(raw,
            SIGNAL(countChanged(quint16,quint16)),
            this,
            SLOT(handleScoreChanged(quint16,quint16)));
    connect(raw,
            SIGNAL(countChanged(quint16,quint16)),
            this,
            SIGNAL(scoreChanged(quint16,quint16)));

    this->board = nBoard;
}
Пример #2
0
void Game::onTouchEnded(Touch* touch, Event* unused_event)
{
    Point endTouch = touch->getLocation();
    endX = beginX-endTouch.x;
    endY = beginY-endTouch.y;
    
    if (abs(endX) > abs(endY)) {
        if(endX + 5>0){
        if (left()) {
           createCardNumber();
           gameOver();
           }
        }else
        {
            if (right()) {
                createCardNumber();
                gameOver();
            }
        }
    }else if (abs(endX)<abs(endY)){
        if (endY+5>0) {
            if (down()) {
                createCardNumber();
                gameOver();
            }
        }else{
            if (up()) {
                createCardNumber();
                gameOver();
            }
        }
    }
   
}
Пример #3
0
void MainWindow::validateConnection()
{
    if(ui->IPAddress->text().length() < 7)
    {
        QMessageBox msg;
        msg.setWindowTitle("Error");
        msg.setText("Skřítek v počítači přenesl data IP adresy a zjistil, že je prázdná nebo neni úplná.");
        msg.setIcon(QMessageBox::Information);

        msg.exec();

        return;
    }

    if(ui->ServerPort->text().length() < 1)
    {
        QMessageBox msg;
        msg.setWindowTitle("Error");
        msg.setText("Skřítek v počítači přenesl data cílového portu a zjistil, že je port prázdný. Port je třeba vyplnit, aby věděl kam má doručit data");
        msg.setIcon(QMessageBox::Information);

        msg.exec();

        return;
    }

    Client* client = new Client(ui->IPAddress->text(), ui->ServerPort->text().toInt(), this);

    if(client->connectToServer())
    {
        IP   = ui->IPAddress->text();
        port = ui->ServerPort->text().toInt();

        ui->action_rejoin->setEnabled(true);

        connect(ui->action_rejoin, SIGNAL(triggered()), this, SLOT(rejoin()));

        connect(client, SIGNAL(error(QString)), this, SLOT(showError(QString)));

        // Say hello to server
        client->sendPacket(Hello, QString("Hello"), client->toData(47777));

        setCentralWidget(NULL);

        if(surface)
            delete surface;

        surface = new Surface(client, this);

        setCentralWidget(surface);

        connect(this, SIGNAL(key(Qt::Key&)), surface, SLOT(keyPress(Qt::Key&)));

        connect(surface, SIGNAL(foodEaten()), this, SLOT(updateScore()));
        connect(surface, SIGNAL(gameOver()),  this, SLOT(gameOver()));

        score = -1;

        updateScore();
    }
Пример #4
0
Controller* PlayField::createController()
{
    // The client or server will overwrite this default configuration when 
    // the network messages are interchanged
    m_battle_ships_configuration = Settings::severalShips() ? 
    BattleShipsConfiguration::defaultMultipleShipsConfiguration(Settings::adjacentShips()):
    BattleShipsConfiguration::defaultSingleShipsConfiguration(Settings::adjacentShips());
    Controller* controller = new Controller(this, m_player, m_battle_ships_configuration);
    connect(controller, SIGNAL(gameOver(Sea::Player)),
            this, SLOT(gameOver(Sea::Player)));
    connect(controller, SIGNAL(restartRequested()),
            this, SLOT(restartRequested()));
    connect(controller, SIGNAL(compatibility(int)),
            this, SLOT(setCompatibility(int)));
    connect(controller, SIGNAL(nickChanged(int,QString)),
            this, SLOT(updateNick(int,QString)));
    connect(controller, SIGNAL(turnChanged(int)),
            this, SLOT(changeTurn(int)));
    connect(controller, SIGNAL(playerReady(int)),
            this, SLOT(playerReady(int)));
    connect(controller, SIGNAL(restartPlacingShips(Sea::Player)),
            this, SLOT(restartPlacingShips(Sea::Player)));
    connect(controller, SIGNAL(startPlacingShips(int)),
            this, SLOT(startPlacingShips()));

    return controller;
}
Пример #5
0
void GameLayer::roleJumpDownLogic() {
    
    /**
     1, 先判断是否到地面下了
     2, 检测右边的碰撞
     3, 检测下面的碰撞
     **/
    
    float roleY = mRole->getPositionY();
    roleY -= getRoleYSpeed();
    if (roleY < getGroundHeight()) {
        gameOver();
        CCLOG("正在下降, 撞地了");
        return;
    }
    
    BarPipe *willCollisionBar = getWillCollisionBar();
    if (isCollisionWithBar(COLL_STATE_RIGHT, willCollisionBar)) {
        gameOver();
        CCLOG("正在下降, 右边发生碰撞");
        return;
    }
    
    if (isCollisionWithBar(COLL_STATE_BOTTOM, willCollisionBar)) {
        gameOver();
        CCLOG("正在下降, 下边发生碰撞");
        return;
    }
    
    mRole->setPositionY(roleY);
    setRoleYSpeed(getRoleYSpeed() + getRoleAccelerate());
}
Пример #6
0
	bool SnakeLayer::testDie()
	{
		LineNode* n = static_cast<LineNode*>(*lineGroup->getChildren().rbegin());
		Point end = n->getEnd();
		if (!bounds.containsPoint(end))
		{
			gameOver();
			return true;
		}
		for (int i = 0; i < lineGroup->getChildrenCount(); i++)
		{
			LineNode* li = static_cast<LineNode*>(*(lineGroup->getChildren().begin() + i));
			for (int j = 0; j < lineGroup->getChildrenCount(); j++)
			{
				if (abs((int) i - (int) j) <= 1) continue;
				LineNode* lj = static_cast<LineNode*>(*(lineGroup->getChildren().begin() + j));
				if (linesIntersect(
					li->getStart(), li->getEnd(),
					lj->getStart(), lj->getEnd()))
				{
					gameOver();
					return true;
				}
			}
		}
		return false;
	}
Пример #7
0
void World::update()
{
	if (_playerBase == nullptr) {
		gameOver();
	} else if (_playerTank == nullptr) {
		if (_playerLife > 0) {
			_playerLife--;
			Tank *tank = new Tank;
			tank->setPos(_spawnPos[0]);
			_playerTank = tank;
			_tankList.append(tank);
		} else {
			gameOver();
		}
	} else if (_tankList.size() < 3) {
		if (_enemyLife > 0) {
			_enemyLife--;
			Tank *tank = new Tank;
			tank->setTeam(1);
			tank->setPos(_spawnPos[_tankList.size()]);
			tank->setAngle(2);
			_tankList.append(tank);
		}
	}
	if (_isVideo) {
		playVideo();
	} else {
		moveBots();
	}
	updateTanks();
	moveBullets();
}
Пример #8
0
void KReversiView::setGame(KReversiGame *game)
{
    // disconnect signals from previous game if they exist,
    // we are not interested in them anymore
    if (m_game) {
        disconnect(m_game, SIGNAL(boardChanged()), this, SLOT(updateBoard()));
        disconnect(m_game, SIGNAL(moveFinished()), this, SLOT(gameMoveFinished()));
        disconnect(m_game, SIGNAL(gameOver()), this, SLOT(gameOver()));
        disconnect(m_game, SIGNAL(whitePlayerCantMove()), this, SLOT(whitePlayerCantMove()));
        disconnect(m_game, SIGNAL(blackPlayerCantMove()), this, SLOT(blackPlayerCantMove()));
        delete m_game;
    }

    m_game = game;

    if (m_game) {
        connect(m_game, SIGNAL(boardChanged()), this, SLOT(updateBoard()));
        connect(m_game, SIGNAL(moveFinished()), this, SLOT(gameMoveFinished()));
        connect(m_game, SIGNAL(gameOver()), this, SLOT(gameOver()));
        connect(m_game, SIGNAL(whitePlayerCantMove()), this, SLOT(whitePlayerCantMove()));
        connect(m_game, SIGNAL(blackPlayerCantMove()), this, SLOT(blackPlayerCantMove()));

        m_game->setDelay(m_delay);
    }

    m_hint = KReversiMove();

    updateBoard();
}
Пример #9
0
void PD_UI_DissBattle::incrementConfidence(float _value){
	// Value > 0 means the player is attacking
	if(_value > 0) {
		// Factor in enemy's defense
		_value *= playerAttackMultiplier * playerComboMultiplier;
		playerComboMultiplier += playerComboIncrement;
	}else {
		_value *= enemyAttackMultiplier * enemyComboMultiplier;
		enemyComboMultiplier += enemyComboIncrement;
	}

	sweet::Event * e = new sweet::Event("confidence");
	e->setFloatData("value", _value);
	eventManager->triggerEvent(e);

	confidence = confidence + _value > 100.f ? 100.f : confidence + _value < 0.f ? 0.f : confidence + _value;

	if(confidence <= 0){
		// Check if out of lives
		if(lives.size() <= 0){
			gameOver(false);
		}else{
			lostLives.push_back(lives.back());
			lives.pop_back();
			lostLives.back()->background->mesh->replaceTextures(lifeTokensCrossed.at(lives.size()));
			confidence = 50.f;
		}
	}

	if(confidence >= 100){
		gameOver(true);
	}
}
Пример #10
0
void Game::dealGameResult(GameResult game_result)
{
	switch (game_result)
	{
	case Game::Result_Success:
		LOGD(TAG,"------------------------------Result_Success-------------------");
		gameArea->removeFromParentAndCleanup(true);
		gameArea = nullptr;
		if (step < 2){
			if (step == 0){
				starAtl->gotoFrameAndPlay(0, starEndFrame[0],false);
			}
			else {
				starAtl->gotoFrameAndPlay(starEndFrame[step - 1] + 1, starEndFrame[step], false);
			}
			step++;
			gameUIMgr->resetAll();
			gameArea = GameArea::create(gameUIMgr, guanQiaName[step]);
			gameNode->addChild(gameArea, Game::ZORDER_AREA, Game::TAG_AREA);
		}
		else {
			//成功 
			step++;
			gameOver(true);
		}
		break;
	case Game::Result_Fail:
		LOGD(TAG, "------------------------------Result_Fail-------------------");
		gameOver(false);
		break;
	default:
		break;
	}
}
Пример #11
0
static void eventHandler(objectKey key, windowEvent *event)
{
	int x = 0;
	int y = 0;

	// Check for window events.
	if (key == window)
	{
		// Check for window refresh
		if (event->type == EVENT_WINDOW_REFRESH)
			refreshWindow();

		// Check for the window being closed
		else if (event->type == EVENT_WINDOW_CLOSE)
			windowGuiStop();
	}

	// Only go through the array of buttons if the event was a mouse click
	else if (event->type == EVENT_MOUSE_LEFTUP)
	{
		for (x = 0; x < GRID_DIM; x++)
		{
			for (y = 0; y < GRID_DIM; y++)
			{
				if (key == gridButtons[x][y])
				{
					// If this spot is empty, invoke the clickEmpties function
					if (mineField[x][y] == -1)
					{
						clickEmpties(x, y);
					}
					else
					{
						if (mineField[x][y] == 9)
						{
							gameOver(0);
						}
						else
						{
							uncover(x, y);

							if (numUncovered >=
								((GRID_DIM * GRID_DIM) - NUM_MINES))
							{
								gameOver(1);
							}
						}
					}

					return;
				}
			}
		}
	}
}
Пример #12
0
MainWindow::MainWindow()
{
	setCaption(tr("GA Bots " VERSION));

	initActions();
	initMenuBar();
	initToolBar();
	initStatusBar();

	initGABotDoc();
	initView();

	ViewToolBar->setOn(true);
	ViewStatusBar->setOn(true);
	//ViewGame->setOn(true);

	connect(GABotDoc, SIGNAL(gameReady(bool)), this, SLOT(slotGameReady(bool)));
	connect(GABotDoc, SIGNAL(teamAScores()), View, SLOT(slotScoreA()));
	connect(GABotDoc, SIGNAL(teamBScores()), View, SLOT(slotScoreB()));
	connect(GABotDoc, SIGNAL(clearScores()), View, SLOT(slotClearScores()));

	connect(GABotDoc, SIGNAL(moveTeamA(Coordinate, Coordinate)), View,
		SLOT(slotMoveTeamA(Coordinate, Coordinate)));
	connect(GABotDoc, SIGNAL(moveTeamB(Coordinate, Coordinate)), View,
		SLOT(slotMoveTeamB(Coordinate, Coordinate)));
	connect(GABotDoc, SIGNAL(turnTeamA(Coordinate, Direction)), View,
		SLOT(slotTurnTeamA(Coordinate, Direction)));
	connect(GABotDoc, SIGNAL(turnTeamB(Coordinate, Direction)), View,
		SLOT(slotTurnTeamB(Coordinate, Direction)));

	connect(GABotDoc, SIGNAL(moveBall(Coordinate,Coordinate)), View,
		SLOT(slotMoveBall(Coordinate,Coordinate)));

	connect(GoGame, SIGNAL(activated()), this, SLOT(slotGoGame()));
	connect(GoGame, SIGNAL(activated()), GABotDoc, SLOT(slotStartTimer()));
	connect(StopGame, SIGNAL(activated()), GABotDoc, SLOT(slotStopTimer()));
	connect(StopGame, SIGNAL(activated()), this, SLOT(slotStopGame()));

	connect(View, SIGNAL(valueChanged(int)), this, SLOT(slotTickInterval(int)));
	connect(GABotDoc, SIGNAL(clearField()), View, SLOT(slotClearField()));

	connect(ResetScreen, SIGNAL(activated()), View, SLOT(slotClearField()));
//not sure if we should clear the field whenever regenerating the team
//	connect(TeamAGenerate,SIGNAL(activated()), View, SLOT(slotClearField()));
//	connect(TeamBGenerate,SIGNAL(activated()), View, SLOT(slotClearField()));

	connect(GABotDoc, SIGNAL(gameOver()), View, SLOT(slotClearField()));
	connect(GABotDoc, SIGNAL(gameOver()), View, SLOT(slotClearScores()));
	connect(GABotDoc, SIGNAL(gameOver()), this, SLOT(slotGameOver()));
	
}
Пример #13
0
void
	AIManager::Think(float time)
{
	
	if (OgreTrip::level <= 5)
	{
		spawnAnimalCD = 3 - OgreTrip::level*0.2;
		spawnStoneCD = 5 - OgreTrip::level*0.4;
	}
	
	spawnAnimal(time);
	spawnStone(time);
	for (std::size_t i = 0; i < mFoodList.size(); i++ )
	{
		if (mFoodList[i]->Think(time))
		{
			delete mFoodList[i];
			mFoodList.erase(mFoodList.begin()+i);
		}
	}
	for (int m = 0; m < animalNum; m++)
	{
		for (std::size_t i = 0; i < mAnimalList[m].size(); i++ )
		{
			if (mAnimalList[m][i]->Think(time))
			{
				gameOver();
				break;
			}
			if (mAnimalList[m][i]->getPosition().z < World::getSingleton()->getCarNode()->getPosition().z -100)
			{
				delete mAnimalList[m][i];
				mAnimalList[m].erase(mAnimalList[m].begin()+i);
			}
		}
	}
	for (std::size_t i = 0; i < mStoneList.size(); i++ )
	{
		if (mStoneList[i]->Think(time))
		{
			gameOver();
			break;
		}
		if (mStoneList[i]->getPosition().z < World::getSingleton()->getCarNode()->getPosition().z -100)
		{
			delete mStoneList[i];
			mStoneList.erase(mStoneList.begin()+i);
		}
	}
}
Пример #14
0
/*****************************************************************************
 Function: playGame
 Inputs:   node for this board, plus player (to get to this board)
 Returns:  nothing
 Description: play the game of TTT
 *****************************************************************************/
void playGame (NodeP node, char player) {

  int bestChild;   /* which of the children to move to */
  NodeP nextNode;  /* the node for that child */

  if (!gameOver(node)) { /* if we're not yet done */

    printNode(node);     /* print the board and scores */

    printf("Next move by player %c\n", player);
    
    lookahead(node, player, DEPTH);      /* construct the lookahead tree */

    bestChild = bestMove(node, player);  /* the best move for the player */
    nextNode = node->offspring[bestChild];

    /**** should free offspring of bestChild, plus all the other children */

    MoveCount++;
    playGame(nextNode, opponent(player));  /* recurse */
  }

  else {  /* game is over */
    printf("Final board is: \n");
    printNode(node);
  }

} /* end playGame */
Пример #15
0
void ofApp::updateEnemies( float dt )
{
  deque<ofPtr<DrawGame::CircleSprite> >::iterator itEnemy;  
  for(itEnemy=Enemies.begin();
    itEnemy!=Enemies.end();
    itEnemy++)
  {
    ofPtr<DrawGame::CircleSprite> En = *itEnemy;
    bool bWhite = En->getbWhite();
    if(!bWhite)
    {
      En->changeSize(dt*EnemyGrowthrate);
      En->changeRot(dt*90.0f);
      if(En->getSize()>100.0f)
      { 
        HP -= HPBeatAmt2;
        if(HP<=0.0f)
        {
          eraseEnemy(itEnemy,"Beat2");
          GameOverString = "You're Eaten!";
          gameOver();
        }                
        break;
      }
    }
    else
    {
      En->changeSize(-dt*EnemyGrowthrate);
      En->changeRot(-dt*90.0f);
    }    
  }
}
Пример #16
0
//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button){
  if(!bGameRunning)
  {
    if(button==0)
    {
      pRetryBtn->dragged(x,y);
    }
    return;
  }
  MousePos = ofVec2f(x,y);
  if(0==button)
  {
    ofVec2f PosLast = pPlayer->getPosition();
    ofVec2f PosNow = ofVec2f(x,y);
    float dist = PosNow.distance(PosLast);
    float sizePlayer = pPlayer->getSize();
    float DeltaHP = -sizePlayer*dist*0.001f*HPDecSpd;
    HP += DeltaHP;
    if(HP<=0.0f)
    {
      GameOverString = "You're Exhausted!";
      gameOver();
    }
    pPlayer->moveTo(PosNow);
  }
}
Пример #17
0
// -------------------------------------------------------------------------
// Strategy2005CL::emergencyStop
// -------------------------------------------------------------------------
// Quand le match est arrete avant la fin par l'arret d'urgence
// si on est arrete a presque 1 minute 30, c'est la fin du match
// -------------------------------------------------------------------------
void Strategy2005CL::emergencyStop()
{
    matchIsFinished_ = true;
    Move->stop();
    if (Timer->time()>TIME_MATCH*0.9) {
        // fin du match normale
        gameOver();
    } else {
        // on a arrete le robot avant la fin du match
        LOG_WARNING("EMERGENCY_STOP is pressed\n");
        Lcd->print("EMERGENCY STOP");
        Lcd->setLed(LCD_LED_GREEN, LCD_LED_OFF);
        Lcd->setLed(LCD_LED_RED,   LCD_LED_BLINK);
        Log->stopMatch();

        // unregister game over and emergency stop exceptions
	Events->registerCallback(EVENTS_EMERGENCY_STOP, this, NULL, "");
	Events->registerCallback(EVENTS_GAME_OVER, this, NULL, "");
	Events->registerCallback(EVENTS_TIMER_ALERT, this, NULL, "");
	
	Move->emergencyStop();
	MvtMgr->reset();
	//IOMGR->emergencyStop();
	
	Log->closeLogFile();
	Sound->play(SOUND_ANORMAL_EMERGENCY_STOP, SND_PRIORITY_URGENT);
	sleep(2);
	if (menu("SophiaTeam is\nthe best team!")) {
	    Sound->play(soundVictory_);
	} else {
	    Sound->play(soundDefeat_);
	}
    }
}
Пример #18
0
// ----------------------------------------------------------------------------
// Strategy2005CL::checkEndEvents
// ----------------------------------------------------------------------------
// Execute les commandes en cas d'arret d'urgence, de fin de match
// Retourne false si la strategy est terminee et qu'il faut retourner au menu
// endEvt=true si l'evenement a ete catche
// ----------------------------------------------------------------------------
bool Strategy2005CL::checkEndEvents()
{
    if (matchIsFinished_) {
        return true;
    }
#ifdef STOP_ON_EMERGENCY_STOP
    if (Events->isInWaitResult(EVENTS_EMERGENCY_STOP)
	|| Events->check(EVENTS_EMERGENCY_STOP)) {
        emergencyStop();
        return true;
    } else 
#endif
    if (Events->isInWaitResult(EVENTS_GAME_OVER)
	       || Events->check(EVENTS_GAME_OVER)) {
        gameOver();
        return true;
    } else if (Events->isInWaitResult(EVENTS_TIMER_ALERT)
	       || Events->check(EVENTS_TIMER_ALERT)) {
        return timerAlert();
    } else if (Events->isInWaitResult(EVENTS_USER_ABORT)
	       || Events->check(EVENTS_USER_ABORT)) {
        return true;
    }
    return false;
}
Пример #19
0
void MainWindow::onTimerTick()
{
    Figure newFig = *cur_figure;
    newFig.setPosition(newFig.getPosition().x(), cur_figure->getPosition().y() + 1);
    if (m_cup.hasPlace(newFig)) {
        delete cur_figure;
        cur_figure = new Figure(newFig);
    } else {
        m_cup.putFigure(*cur_figure);
        m_score += m_cup.clearedLines() * 100 + (m_cup.clearedLines() > 0 ? 100 : 0);
        if (m_score >= NEXTLEVELSCORE) {
            m_score = 0;
            if (m_level < MAX_LEVEL)
                m_level++;
            else
                endGame();
            init();
        }
        delete cur_figure;
        cur_figure = new Figure(m_cup);
        if (m_cup.filled())
            gameOver();
    }
    draw();
}
void MainContentComponent::buttonClicked (Button *button) {
    
    if (button == &startButton) {
        removeChildComponent(&startButton);
        
//        String myString = (chooseMidi->getSelectedFile(1)).getFullPathName();
//        std::cout<<myString<<std::endl;
//        myObstacle  = new ObstacleComponent((myString.toStdString()).c_str());
//         ypos       = myObstacle->getInitialHeight()-35;
        
        processingAudio = new AudioProcess(myObstacle->getStartNote()+12);
        deviceManager.initialise( 1, 2, 0, true, String::empty, 0 );
        deviceManager.addAudioCallback(processingAudio);
        
        gameStart();
    }
    if (button == &stopButton) {
        gameOver();
    }
    if (button == &restartButton) {
        removeAllChildren();
        stopTimer();
        reset();
        gameStart();
        
    }

}
void MainContentComponent::collisionDetection() {
    if (  obsX < (0.15*winWidth + 80)    ) {
        
        if ( (  curObsPos + 50 < ypos   ||   (curObsPos -50) > ypos  ) && curObsPos > 0 ){ //Within one semitone difference
            addAndMakeVisible(hitLabel);
            copterHits++;
            hitsDisplay = "Number of hits: ";
            hitsDisplay += copterHits;
            numHitsLabel.setText(hitsDisplay, dontSendNotification);
        }
        else if( curObsPos != -1 ){
            removeChildComponent(&hitLabel);
        }
        
    }
    
    if(copterHits > 50) {
        gameOver();
    }
    
    if( copterHits%10 == 0 && copterHits > 0 && (processingAudio->getTimeElapsed() - newlifeTime) > 1.0f){
        newLife();
    }
 
}
Пример #22
0
void MainWindow::on_btnNext_clicked()
{
    if(!solarSystem->setNextActive())
    {
        gameOver();
    }
}
Пример #23
0
void main()
{
    int i,j,boxidx;
    int driver=DETECT, mode=0;
    randomize();
    //registerbgidriver(EGAVGA_driver);
    initgraph(&driver,&mode,"");
    xyz:
    do
    {
	menu();
	init();
	boxidx=random(7);
	FORCOLOR2=random(7)+1;
    for(j=0;j<4;j++)
    for(i=0;i<4;i++)
    box2[j][i]=BOX[boxidx][j][i];
	do
	{
	    getMessage();
	    dispatchMessage();
	}while(!gameOver());
	highscore();
	OVER();
	getch();
    }while(1);
}
Пример #24
0
int     Game::run()
{
    while ((level->getSpawnList().size() > 0 || monsters.size() > 0) || ((time - endTime) < 5))
    {
        //cout << "time = " << time << " endTime = " << endTime << endl;
    	//cout.precision(3);
        //cout << "t : " << time << " s\tpos : " << pos / blockSize << " block / " << pos << " pix" << endl;
		if (loop() == 0) // No more players
			return (1);
        if (gameOver())
            return (2);

		// Loop time stabilization to REFRESH ms
		double targetTime = round(time * 1000 / REFRESH + 1) * REFRESH / 1000;
        sleep(static_cast<int>((targetTime - time) * 1000));
        last = time;
        time = (now() - begin);
        pos = time * BLOCKS_PER_SECOND * blockSize;

        // Detect end of level
        if (!(level->getSpawnList().size() > 0 || monsters.size() > 0) && endTime < 0)
        {
            endTime = time;
            string  t;
            t += CMD_NLVL;
            sendAll(t);
        }
    }
    return (0);
}
Пример #25
0
void placeKey() {
  for (int x = 0; x < 4; x++) {
    for (int y = 0; y < 4; y++) {
      if (key.t[x*4+y] == 1) {
        if (key.r+x <=4)
          gameOver();
        matrix[key.r+x][key.c+y] = 1;
        colorMatrix[key.r+x][key.c+y] = key.color;
      }
    }
  }
  checkForScore();
  key.t = next.t;
  key.color = next.color;
  key.r = 0;
  key.c = 3;
  int nextType = qran_range(0,7);
  int *n;
  n = tetriminos[nextType];
  next.t = n;
  next.color = colors[nextType];
  drawMatrix();
  setNextPiece(next);
  droppedYet = 0;
}
Пример #26
0
void Game::handleGameConditions()
{
	if(conditionTimer->Ticking())
	{
		conditionTimer->tick();
		if(conditionTimer->Condition())
		{
			switch(curCondition)
			{
			case CONDITION_RESTART:
				restartGame();
				break;
			case CONDITION_GAME_OVER:
				gameOver();
				break;
			case CONDITION_NO_CONDITION:
				throw 0; //someone made a mistake
				break;
			}

			/*Reset everything*/
			curCondition = CONDITION_NO_CONDITION;
			conditionTimer->stop();
			conditionTimer->reset();
		}
	}
}
Пример #27
0
void GameLogic::setupNewComputers()
{
    QRectF const scene = mView->sceneRect();
    mAgent = new WorkStation(mGenerator, stations::hacker);
    mView->setItemToScene(mAgent);
    mAgent->setPos(scene.right() - 110, scene.center().y());
    connect(this, SIGNAL(newWorkingDay()), mAgent, SLOT(dataTransfer()));

    mDevelopers = new WorkStation(mGenerator, stations::target);
    mView->setItemToScene(mDevelopers);
    mDevelopers->setPos(scene.left() + 10, scene.center().y() - scene.height() / 10);
    connect(mDevelopers, SIGNAL(secretDepartInfected()), this, SLOT(gameOver()));

    mUsersCount = (mGenerator->rand() % (maxUsers - minUsers + 1)) + minUsers;
    for (int i = 0; i < mUsersCount; i++)
    {
        WorkStation *newStation = new WorkStation(mGenerator);
        mView->setItemToScene(newStation);
        mUsers.append(newStation);
        connect(this, SIGNAL(newWorkingDay()), newStation, SLOT(dataTransfer()));

        // dbl click event filter doesnt work on graphicsview items
        connect(this, SIGNAL(energyChanged(bool)), newStation, SLOT(energyChange(bool)));
        connect(newStation, SIGNAL(updated()), this, SLOT(startReloadTime()));
    }

    trafficReloadTime = (mUsersCount < maxUsers / 2)? 2 : 1;
}
Пример #28
0
void
App::newGame()
{
    if (_game) delete _game;

    _game = new HexdameGame(this);
    _gameView = new HexdameView(_game);

    connect(_game, SIGNAL(gameOver()), this, SLOT(gameOver()));
    setBlackPlayer(_blackCombo->currentIndex());
    setWhitePlayer(_whiteCombo->currentIndex());

    _mainwindow->setCentralWidget(_gameView);

    _game->startNextTurn();
}
Пример #29
0
void SinglePlayerView::onDataError( int code, const QString& description )
{
	showMsg( description );
	emit gameOver();
	QTimer::singleShot( 10, this, SLOT( hideLoading() ) );
	qDebug() << "Loading error" << code << ":" << description;
}
Пример #30
0
/*
**	Handle events received (arrows, space, esc...).
*/
void	Gui::handleEvents()
{
  int	key = wgetch(m_win);

  if (key == -1)
    throw (NibError("ncurses_wgetch", "fail"));

  while (m_state == ENABLE)
    {
      while (key != ESCAPE && m_nibbler.isActive())
	{
	  if (key == KEY_LEFT)
	    m_nibbler.turn_left();
	  if (key == KEY_RIGHT)
	    m_nibbler.turn_right();
	  key = 0;
	  while ((key = wgetch(m_win)) != ESCAPE && key != ' ' && m_nibbler.isActive() &&
		 key != KEY_LEFT && key != KEY_RIGHT);
	  if (key == ' ')
	    m_nibbler.boost();
	}
      if (key == ESCAPE)
	m_nibbler.disable();
      if (gameOver(key) == true)
	m_state = DISABLE;
    }
}