Exemplo n.º 1
0
void testApp::mouseReleased(int x, int y, int button){

	ofVec2f target = ofVec2f(x,y);

	if(state==START_SCREEN){

		ofRectangle startb = ofRectangle(START_BUTTON_POS);
		if( startb.inside(x, y)){
			currentLevel = 0;
			nextLevel();
			return;
		}else{

			lines[currentLine].push_back( ofVec2f(x ,y ));
		}
	}

	if(state==PLAYING){
		Silo * silo = bestSiloForTarget( target );

		if (silo != NULL){
			Missile *m = silo->launchMissile();
			if(m != NULL){
				launch.play();
				m->startGood( target );
				playerMissiles.push_back(m);
			}else{
				empty.play();
			}
		}else{
			empty.play();
		}
	}
}
Exemplo n.º 2
0
/// Check whether or not the game is over or the level was completed.
void GameModel::checkLevel() {
	if (enemiesNearBase() or lives == 0) {
		gameOver = true;
	}

	if (enemiesShot == 55) {
		nextLevel();
	}
}
Exemplo n.º 3
0
 void connect(TreeLinkNode *root) {
     vector<TreeLinkNode *> roots;
     if(root){
         roots.push_back(root);
         while(roots.size()!=0){
             roots = nextLevel(roots);
         }
     }
 }
Exemplo n.º 4
0
void KJezzball::newPercent( int percent )
{
    m_percentLCD->display( percent );
    if ( percent>=75 )
    {
        m_level.score = m_level.lifes*15 + (percent-75)*2*(m_game.level+5);
        nextLevel();
    }
}
Exemplo n.º 5
0
void GravityJamRoot::endLevel(float dt)
{
    // we will need all of the end of level graphics here
    // for now, just unload the level and load the next one
    closeLevel();
    if(!nextLevel())
    {
        printf("Error opening level %i", gj_level);
        faulted = true;
    }
}
Exemplo n.º 6
0
/**
 * Handles the Middle Button Presses
 */
static void select_click_handler(ClickRecognizerRef recognizer, void *context) {
	// If the Game didn't finish yet, handle the Logic, otherwise restart the game
	if (!status.end) nextLevel();
	else {
		status.end = true;
		//free(status.timer);
		status.timer = NULL;
		
		layer_set_hidden(text_layer_get_layer(ui.messageLayer), true);
		window_stack_pop(true);
		scores_name_init(status.points);
		status.cleanScores	= true;
	}
}
Exemplo n.º 7
0
OptimizationInfos::OptimizationInfos()
{
    infos_[Optimization_Normal - 1].initNormalOptimizationInfo();
    infos_[Optimization_AsmJS - 1].initAsmjsOptimizationInfo();

#ifdef DEBUG
    OptimizationLevel level = firstLevel();
    while (!isLastLevel(level)) {
        OptimizationLevel next = nextLevel(level);
        JS_ASSERT(level < next);
        level = next;
    }
#endif
}
Exemplo n.º 8
0
// adding 1 to counter of lines, builded by user
void TetrisEngine:: addLine()
{
    _linesCounter++;
    // if current lines tens are higher than _curLevel, emit nextLevel
    // max level is 10
    if ( _linesCounter / 10 > _curLevel && _curLevel < 11)
    {
        _curLevel = _linesCounter / 10;
        _interval -= INTERVAL_STEP;
        timer.setInterval(_interval);
        emit nextLevel();
    }
    emit linesCounterChanged();
}
Exemplo n.º 9
0
void HeartGame::init()
{
    m_win.create(sf::VideoMode(800u, 600u), "Heart", sf::Style::Titlebar | sf::Style::Close);
    m_win.setFramerateLimit(60u);
    m_font.loadFromFile("read/DejaVuSans.ttf");
    m_hearttex.loadFromFile("read/heart.png");
    m_brokenhearttex.loadFromFile("read/broken-heart.png");
    m_heartcolor = kPrimaryColors[m_randomizer.getRandomUintBelow(3u)];
    m_beatclock.restart();
    m_points = 0;
    m_currentlevelpoints = 0;
    m_gameover = false;
    m_level = 0u;
    nextLevel();
    setText("A and D to rotate\nSpace to shoot\nEscape to quit", sf::seconds(4.f));
}
Exemplo n.º 10
0
OptimizationLevel
OptimizationInfos::levelForScript(JSScript *script, jsbytecode *pc) const
{
    OptimizationLevel prev = Optimization_DontCompile;

    while (!isLastLevel(prev)) {
        OptimizationLevel level = nextLevel(prev);
        const OptimizationInfo *info = get(level);
        if (script->getWarmUpCount() < info->compilerWarmUpThreshold(script, pc))
            return prev;

        prev = level;
    }

    return prev;
}
Exemplo n.º 11
0
void Map::updateFO() {
	for (int i = 0; i < foVector.size(); i++) {
		//if falling object off screen
		if (foVector[i]->foSprite.getPosition().y - foVector[i]->foSprite.getGlobalBounds().height / 2 > window->getSize().y) {
			resetPosition(foVector[i]);
			curNumFO--;
			//check if all falling objects have been destroyed
			if (curNumFO == 0) {
				nextLevel();
			}
		}
		else {
			foVector[i]->foSprite.setRotation(foVector[i]->foSprite.getRotation() + foVector[i]->randomNum);
			foVector[i]->foSprite.move(0, 15*foVector[i]->velY);
			foVector[i]->foCircle.move(0, 15*foVector[i]->velY);
		}
	}
}
Exemplo n.º 12
0
void Map::detectCollisionFG() {
	for (int i = 0; i < gbVector.size(); i++) {
		for (int j = 0; j < foVector.size(); j++) {
			if (!foVector[j]->intersected && intersects(foVector[j], gbVector[i]->gbSprite.getGlobalBounds(), 1)) { //collision detected
				sound.setBuffer(iBuffer);
				sound.play();
				gbVector.erase(gbVector.begin() + i);
				curNumFO--;
				foVector[j]->intersected = true;
				resetPosition(foVector[j]);
				if (curNumFO == 0) {
					nextLevel();
				}
				break;
			}
		}
	}
}
Exemplo n.º 13
0
void Map::detectCollisionFB(std::vector<Weapon::Bullet*> bullets) {
	for (int i = 0; i < bullets.size(); i++) {
		for (int j = 0; j < foVector.size(); j++) {
			if (!foVector[j]->intersected && intersects(foVector[j], bullets[i]->bulletSprite.getGlobalBounds(), 0)) { //collision detected
				sound.setBuffer(iBuffer);
				sound.play();
				bullets.erase(bullets.begin() + i);
				score += 10;
				curNumFO--;
				foVector[j]->intersected = true;
				resetPosition(foVector[j]);
				if (curNumFO == 0) {
					nextLevel();
				}
				break;
			}
		}
	}
}
Exemplo n.º 14
0
void
GameState::detectCollisions() {

  // walls
  if (m_ball.position.x < 0 || m_ball.position.x > 1) {
    m_ball.velocity.x = -m_ball.velocity.x;
    g_sound_engine.playSound(PLINK);
    return;
  }

  // ceiling
  if (m_ball.position.y < 0) {
    m_ball.velocity.y = -m_ball.velocity.y;
    g_sound_engine.playSound(PLINK);
    return;
  }

  // paddle
  Rectangle paddle(m_paddle - 0.1, 0.95, m_paddle + 0.1, 0.98);
  if (detectCollision(paddle, true)) {
    g_sound_engine.playSound(PLUNK);
    return;
  }

  Block::List::iterator i = m_blocks.begin();
  for (; i != m_blocks.end(); ++i) {
    if (detectCollision(i->location, false)) {

      g_sound_engine.playSound(PLONK);

      m_blocks.erase(i);
      ++m_blocks_destroyed;

      // have we completed the level?
      if (m_blocks.empty()) {
	nextLevel();
      }
      
      return;
    }
  }
}
Exemplo n.º 15
0
Level::Level()
{
    srand(time(NULL));

    numbers_ = al_load_bitmap("pics/numbers.bmp");
    al_convert_mask_to_alpha(numbers_, al_map_rgb(0, 0, 0));
    hearts_ = al_load_bitmap("pics/hearts.bmp");
    bunny_ = new Bunny();
    spaceItem_ = new SpaceItem(NULL, 0);
    efactory_ = new EnemyFactory(bunny_);
    ifactory_ = new ItemFactory();
    pfactory_ = new PickupFactory();

    for (int i = 0; i < LVL_CNT; i++)
    {
        usedLevels_[i] = false;
    }
    levelsPlayed_ = 0;
    playing_ = true;
    nextLevel();
}
Exemplo n.º 16
0
void HeartGame::updateHeartAndLevel()
{
    if(m_currentlevelpoints < 0)
    {
        m_gameover = true;
        return;
    }

    if(m_rings.isEmpty())
        nextLevel();

    if(m_beatclock.getElapsedTime() >= sf::seconds(1.f))
    {
        unsigned nextcolor = kPrimaryColors[m_randomizer.getRandomUintBelow(3u)];
        while(m_heartcolor == nextcolor)
            nextcolor = kPrimaryColors[m_randomizer.getRandomUintBelow(3u)];

        m_heartcolor = nextcolor;
        m_beatclock.restart();
    }
}
Exemplo n.º 17
0
// Restarting board, tiles, and bricks
void TetrisEngine::restart()
{
    _linesCounter = 0;
    emit linesCounterChanged();
    _endofgame = false;
    _rotatePos = 0;
    _curLevel = 0;
    emit nextLevel();

    // initialize random table with 1 (same chance for every brick)
    for (int i = 0; i < 7; i++)
    {
        _randomTable[i] = 1;
    }

    for(int i = 0; i < _tiles.count(); i++)
        _tiles[i]->restart();

    if (_nextBrick != NULL)
    {
        delete(_nextBrick);
        _nextBrick = NULL;
    }

    if (_curBrick != NULL)
        delete(_curBrick);

    _nextBrick = createNewBrick();
    _curBrick = createNewBrick();

    for (int i= 0; i < BRICKCOUNT; i++)
    {
        _tiles[_curBrick->brickPosition[i]]->setActive(resolveBrickColor(_curBrick->color));
    }

    _interval = START_INTERVAL;
    timer.setInterval(_interval);
    timer.start();
    qDebug() << "Undergone restart";
}
Exemplo n.º 18
0
void MainWgt::luzg()
{
  int c = ui->lcdSluzgano->intValue() + 1;
  if ( c >= nextLevelCount ){
    nextLevelCount += nextLevelIncrement;
    semkoInterval -= 3;
    if (semkoInterval <= semkoIntervalMin){
      semkoInterval = semkoIntervalMin;
    }
    int livesAdd = ui->lcdUnluzged->intValue() + 3;
    ui->lcdUnluzged->display ( livesAdd );
    placeTimerInterval = placeTimerInterval - placeTimerIntervalDecrement;
    if (placeTimerInterval <= placeTimerIntervalMin){
      placeTimerInterval = placeTimerIntervalMin;
    }
    placeSemkoTimer->stop();
    placeSemkoTimer->setInterval(placeTimerInterval);
    placeSemkoTimer->start();
    emit nextLevel();
  }
  ui->lcdSluzgano->display ( c );
}
Exemplo n.º 19
0
void Map::detectCollisionFC(sf::RectangleShape charShape) {
	for (int i = 0; i < foVector.size(); i++) {
		if (!foVector[i]->intersected && intersects(foVector[i], charShape.getGlobalBounds(), 0)) { 			
			foVector[i]->intersected = true;
			lives--;
			if (lives <= 0) {
				sound.setBuffer(dBuffer);
				sound.play();
				gameOverB = true;
			}
			else {
				sound.setBuffer(oBuffer);
				sound.play();
			}
			resetPosition(foVector[i]);
			curNumFO--;
			if (curNumFO == 0) {
				nextLevel();
			}
		}
	}
}
Exemplo n.º 20
0
bool Game2D::event(QEvent *event){
     //qDebug () << event->type();

     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *ke = static_cast<QKeyEvent *>(event);

         if (!state_) state_=1;
         else{
             if (state_==2) start ();
         }

         switch (ke->key()){
             case Qt::Key_Up:
             case Qt::Key_W: direction_=UP; break;

             case Qt::Key_Right:
             case Qt::Key_D: direction_=RIGHT; break;

             case Qt::Key_Down:
             case Qt::Key_S: direction_=DOWN; break;

             case Qt::Key_Left:
             case Qt::Key_A: direction_=LEFT; break;

             case Qt::Key_Shift: ship_.setFire(1); break;

             case Qt::Key_Tab: nextLevel (); break;

             case Qt::Key_Backspace: prevLevel (); break;

             case Qt::Key_Pause: setPause (); break;
         }

         return true;
     }

     return QWidget::event(event);
}
Exemplo n.º 21
0
void GameScreen::gameIsWon()
{
    ball->object->stop();
    paddle->object->stop();
    time->stop();

    gameWonLbl = new QLabel(this);
    gameWonLbl->setPixmap(*gameWonIcon);
    gameWonLbl->setGeometry(50, 60, 401, 351);
    gameWonLbl->show();

    mainMenuBtn = new QPushButton(this);
    mainMenuBtn->setGeometry(75, 370, 75, 23);
    mainMenuBtn->setText("Main Menu");
    mainMenuBtn->show();
    connect(mainMenuBtn, SIGNAL(clicked()), this, SLOT(quitToMenu()));

    saveAndQuitBtn = new QPushButton(this);
    saveAndQuitBtn->setGeometry(165, 370, 81, 23);
    saveAndQuitBtn->setText("Save and Quit");
    saveAndQuitBtn->show();
    connect(saveAndQuitBtn, SIGNAL(clicked()), this, SLOT(saveAndQuit()));

    restartBtn = new QPushButton(this);
    restartBtn->setGeometry(261, 370, 75, 23);
    restartBtn->setText("Replay");
    restartBtn->show();
    connect(restartBtn, SIGNAL(clicked()), this, SLOT(restartLevel()));

    nextLvlBtn = new QPushButton(this);
    nextLvlBtn->setGeometry(355, 370, 75, 23);
    nextLvlBtn->setText("Next Level >");
    nextLvlBtn->show();
    connect(nextLvlBtn, SIGNAL(clicked()), this, SLOT(nextLevel()));

}
Exemplo n.º 22
0
void GameManager::tick()
{
	capTimer.start();

	// Calcuclate delta time
	auto lastFrame = currentFrame;
	currentFrame = hr_clock::now();
	auto timeSpan = currentFrame - lastFrame;
	deltaTime = static_cast<float>(timeSpan.count()) / 1000000000.0f;

	//Calculate and correct fps
	auto avgFPS = countedFrames / (fpsTimer.getTicks() / 1000.f);

	if (avgFPS > 2000000) {

		avgFPS = 0;
	}

	/***************
	* Movement
	****************/

	paddle.move(deltaTime);
	ball.move(paddle, deltaTime);

	SDL_Rect ballRect;
	ballRect.x = ball.getPosX();
	ballRect.y = ball.getPosY();
	ballRect.w = ball.mCollider.w;
	ballRect.h = ball.mCollider.h;

	// Check collision with the pieces
	for (auto & piece : pieces)
	{
		if (piece.isVisible)
		{
			auto hit = piece.hitByBall(&ball, ballRect);
			// We do not want to have more than 1 collision per frame
			if (hit) {
				totalBlocksDestroyed++;
				score.addScore();
				break;
			}
		}
	}

	// Advance to the next level
	if (totalBlocksDestroyed == PIECES)
	{
		level++;
		nextLevel(level);
	}

	// Game over
	if (ball.getLivesLeft() == 0)
	{
		restart();
	}

	int frameTicks = capTimer.getTicks();
	if (frameTicks < SCREEN_TICKS_PER_FRAME)
	{
		// wait the remaining time
		SDL_Delay(SCREEN_TICKS_PER_FRAME - frameTicks);
	}

	// Update game HUD every 10 ticks
	if(frameTicks < 10)
	{
		updateHUD();
	}

}
Exemplo n.º 23
0
void GameState::update( float dtFixed )
{	

	// If the car is out of route points, generate a route
	updateRoute();	

	// check for win
	int currPosX, currPosY;
	currPosX = (int)m_carPos.x;
	currPosY = (int)m_carPos.y;
	if ((currPosX >= 0) && (currPosY>=0) &&
		(currPosX < m_boardSizeX) &&
		(currPosY < m_boardSizeY) &&
		(m_tile[currPosX][currPosY].target))
	{
		// win!
		nextLevel();
	}

	// Move the car along the route
	vec2f targPos, targDir;
	if (m_carRoute.size()== 0 ) updateRoute();
	
	targPos = m_carRoute.front();
	targDir = targPos - m_carPos;
	if (LengthSquared(targDir) < 0.01)
	{	
		// we've reached this route point, discard it
		m_carRoute.pop_front();
		
		// update route to make sure there is data available
		updateRoute();

		targPos = m_carRoute.front();
		targDir = targPos - m_carPos;		
	}
	targDir.Normalize();

	// Adjust car dir 
	float turnrate = 0.4f; // not entirely true, but close enough
	m_carDir = Lerp( m_carDir, targDir, turnrate );
	m_carDir.Normalize();

	// Update car pos
	float speed = 2.0;
	m_carPos += m_carDir * dtFixed * speed;

	// Now update player's tiles
	if (m_pickTiles.size() < m_maxTiles)
	{
		m_newTileTimeout -= dtFixed;
		if (m_newTileTimeout <= 0.0f)
		{
			// pick a tile at random (scrabble probabilities)
			const char *tiles = "AAAAAAAAABBCCDDDDEEEEEEEEEEEEFFGGHHIIIIIIIIIJKLLLLMMNNNNNNOOOOOOOOPPQRRRRRRSSSSTTTTTTUUUUVVWWXYYZ";
			char letter = tiles[ (int)( ((float)rand() / (float)RAND_MAX) * strlen(tiles) ) ];
			PickTile newtile;
			newtile.letter = letter;
			newtile.xpos = m_maxTiles;
			newtile.pending = false;
			m_pickTiles.push_back( newtile );			
			m_newTileTimeout = NEW_TILE_TIMEOUT;
		}
	}

	// fade error
	foreach_tile
	{
		if (m_tile[i][j].error > 0.0)
		{
			m_tile[i][j].error -= 0.01;
		}
		else
		{
			m_tile[i][j].error = 0.0;
		}
	}
}
Exemplo n.º 24
0
OptimizationLevel
OptimizationInfos::firstLevel() const
{
    return nextLevel(Optimization_DontCompile);
}
Exemplo n.º 25
0
void Game2D::timer(){
    if (pause()) return;

    if (!evec_.size() && state_==1){
        //if (level () >=2) state_=2;
        //else
        nextLevel ();
    }

    if (state_==1){
        bool destroy=0;

        ship_.onFire();
        ship_.timer(direction_, width (), height ());

        for (int i=0; i<evec_.size(); i++){
            int x1=evec_[i].x ();
            int y1=evec_[i].y ();
            int x2=evec_[i].x () + evec_[i].width();
            int y2=evec_[i].y () + evec_[i].height();

            //ship hit in vertical line
            if (direction_==1 || direction_==3){
                if (isInInterval (ship_.y (), y1, y2) ||
                    isInInterval (ship_.y () + ship_.height()/2, y1, y2) ||
                    isInInterval (ship_.y () + ship_.height(), y1, y2)){

                    if (ship_.x() > x1) destroy=ship_.hitMinX(x2); //right
                    else{
                        if (ship_.x() +  ship_.width () > x1) destroy=ship_.hitMaxX(x1-ship_.width ()); //left
                    }
                }
            }

            //ship hit in horizontal line
            if (direction_==0 || direction_==2){
                if (isInInterval (ship_.x (), x1, x2) ||
                    isInInterval (ship_.x () + ship_.width()/2, x1, x2) ||
                    isInInterval (ship_.x () + ship_.width(), x1, x2)){
                    if (ship_.y() > y1) destroy=ship_.hitMinY(y2); //down
                    else{
                        if (ship_.y() +  ship_.height () > y1) destroy=ship_.hitMaxY(y1-ship_.height ()); //up
                    }
                }
            }

            if (ship_.fire()){

                bool damaged=0;
                QRect rc;
                ship_.getFireRect (rc, direction());
                //in fire axis y
                if (direction_==1 || direction_==3){
                    if (isInInterval (rc.y(), y1, y2) || isInInterval (rc.y()+rc.height(), y1, y2)){
                        //cross fire line & left enemy || //cross fire line & right enemy
                        if ((x1 > rc.x() && x1 < rc.x()+rc.width()) || (x2 < rc.x() && x2 > rc.x()+rc.width())){
                            damaged=1;
                        }
                    }
                }

                if (direction_==0 || direction_==2){
                    if (isInInterval (rc.x(), x1, x2) || isInInterval (rc.x()+rc.width(), x1, x2)){
                        //cross fire line & up enemy || //cross fire line & down enemy
                        if ((y1 > rc.y() && y1 < rc.y()+rc.height()) || (y2 < rc.y() && y2 > rc.y()+rc.height())){
                            damaged=1;
                        }
                    }
                }

                if (damaged){
                    ++score_;
                    evec_[i].addHealth (-(ship_.damage ()));
                    if (evec_[i].health () == 0) evec_.erase (evec_.begin () + i);
                }

            }

            if (destroy){
                state_=2;

                /*ship_.addHealth (-1);
                switch(direction_){
                    case 0: direction_=2; break;
                    case 1: direction_=3; break;
                    case 2: direction_=0; break;
                    case 3: direction_=1; break;
                }

                if (ship_.health () == 0) state_=2;
                */
                /*QMessageBox box;
                box.warning(0,"Game over", "Ship destroyed!", 0, 1);
                box.show();
                */
            }
        }

        incTime ();
        if (movable()) moveEnemy ();
    }
}
Exemplo n.º 26
0
MainWindow::MainWindow() : QMainWindow(){
	// Initialize variables
	pvx = 0; pvy = 0;
	attack = 1;
	pattack = false;
	paused = false;
	maxhp = 10;
	level = 1;
	pauseMe = 0;
	human = NULL;
	anim = 0;

	// Master Timer
	timer = new QTimer;
	gameSpeed = 14;
	timer->setInterval(gameSpeed);
	srand(time(0));

	// Secondary Timer
	timer2 = new QTimer;
	timer2->setInterval(100);

	// Load ALL THE PICTURES
	ab1 = new QPixmap("images/actualblue-1.png");
	ab2 = new QPixmap("images/actualblue-2.png");
	ag1 = new QPixmap("images/actualgreen-1.png");
	ag2 = new QPixmap("images/actualgreen-2.png");
	apl = new QPixmap("images/actualplayer.png");
	ap = new QPixmap("images/actualpurple.png");
	ar1 = new QPixmap("images/actualred-1.png");
	ar2 = new QPixmap("images/actualred-2.png");
	ar3 = new QPixmap("images/actualred-3.png");
	ay = new QPixmap("images/actualyellow.png");
	app = new QPixmap("images/actualpink.png");

	pbullet = new QPixmap("images/bullet.png");
	bbullet = new QPixmap("images/bluebullet.png");
	gbullet = new QPixmap("images/greenbullet.png");
	ppbullet = new QPixmap("images/pinkbullet.png");
	ybullet = new QPixmap("images/yellowbullet.png");
	widebulletpic = new QPixmap("images/redbullet.png");
	heartpic = new QPixmap("images/heart.png");
	rainbow = new QPixmap("images/rainbow.png");

	bg1 = new QPixmap("images/background.png");
	bg2 = new QPixmap("images/background2.png");
	bg3 = new QPixmap("images/background3.png");

	// This is for the hearts
	h1 = new QGraphicsPixmapItem(*heartpic);
	h1->setPos(400, 575);
	h1->setVisible(false);
	h2 = new QGraphicsPixmapItem(*heartpic);
	h2->setPos(375, 575);
	h2->setVisible(false);
	h3 = new QGraphicsPixmapItem(*heartpic);
	h3->setPos(350, 575);
	h3->setVisible(false);
	h4 = new QGraphicsPixmapItem(*heartpic);
	h4->setPos(325, 575);
	h4->setVisible(false);
	h5 = new QGraphicsPixmapItem(*heartpic);
	h5->setPos(300, 575);
	h5->setVisible(false);

	// Initialize the Scenes and Views
	gameScene = new GScene(this);
	gameView = new QGraphicsView(gameScene);
	mainScene = new QGraphicsScene;
	mainView = new QGraphicsView(mainScene);

	mainView->setWindowTitle("Starships (were meant to fly...)");

	// Now add the hearts 
	gameScene->addItem(h1);
	gameScene->addItem(h2);
	gameScene->addItem(h3);
	gameScene->addItem(h4);
	gameScene->addItem(h5);

	// Make the layouts
	holder = new QWidget;
	holder2 = new QWidget;
	holder3 = new QWidget;
	layout = new QVBoxLayout(holder);
	layout2 = new QHBoxLayout(holder2);
	layout3 = new QHBoxLayout(holder3);

	//Set the attributes to the game scene
	QBrush bg(*bg1);
	gameScene->setBackgroundBrush(bg);
	gameScene->setSceneRect(0,0,425,600);
	gameView->setFixedSize(430,605);
	gameView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	gameView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

	// Make buttons
	// Players love buttons
	startB = new QPushButton("Start");
	startB->setGeometry(160, 475, 100, 60);
	startB->setStyleSheet("background-color:rgba(0,0,0,0); color:#ffffff; font-size:36px;");
	gameScene->addWidget(startB);

	restartB = new QPushButton("Start");
	restartB->setFixedHeight(28);
	pauseB = new QPushButton("Pause");
	pauseB->setFixedHeight(28);
	endB = new QPushButton("Quit");
	endB->setFixedHeight(28);

	nameB = new QTextEdit;
	nameB->setFixedHeight(28);
	nameB->setStyleSheet("background-color:rgb(0,0,0); color:#ffffff;");

	// Connecting the timers and buttons 
	connect(timer, SIGNAL(timeout()), this, SLOT(handleTimer()));
	connect(timer2, SIGNAL(timeout()), this, SLOT(nextLevel()));
	connect(startB, SIGNAL(clicked()), this, SLOT(startGame()));
	connect(pauseB, SIGNAL(clicked()), this, SLOT(pauseGame()));
	connect(endB, SIGNAL(clicked()), this , SLOT(quitGame()));
	connect(restartB, SIGNAL(clicked()), this , SLOT(restartGame()));

	// Make the labels  
	nameL = new QTextEdit;
	nameL->setStyleSheet("background-color:rgb(0,0,0); color:#ffffff;");
	nameL->setFixedHeight(28);
	nameL->setFixedWidth(200);
	nameL->setReadOnly(true);
	layout3->addWidget(nameL);

	scoreL = new QTextEdit;
	scoreL->setStyleSheet("background-color:rgb(0,0,0); color:#ffffff;");
	scoreL->setFixedHeight(28);
	scoreL->setFixedWidth(130);
	scoreL->setReadOnly(true);
	layout3->addWidget(scoreL);

	hpL = new QTextEdit;
	hpL->setStyleSheet("background-color:rgb(0,0,0); color:#ffffff;");
	hpL->setFixedHeight(28);
	hpL->setFixedWidth(80);
	hpL->setReadOnly(true);
	layout3->addWidget(hpL);

	errorL = new QLabel;
	errorL->setStyleSheet("background-color:rgba(0,0,0,1); color:#ffffff; font-size:24px;");
	errorL->setGeometry(QRect(60,520,380,80));
	gameScene->addWidget(errorL);

	nextWave = new QLabel("Get ready for the next wave!");
	nextWave->setStyleSheet("background-color:rgba(0,0,0,1); color:#ffffff; font-size:24px;");
	nextWave->setGeometry(QRect(55,220,380,80));
	nextWave->hide();
	gameScene->addWidget(nextWave);

	endScore = new QLabel;
	endScore->setStyleSheet("background-color:rgba(0,0,0,1); color:#ffffff; font-size:26px;");
	endScore->setGeometry(QRect(0,40,425,80));
	endScore->setAlignment(Qt::AlignCenter);
	endScore->hide();
	gameScene->addWidget(endScore);

	scoreList = new QLabel;
	scoreList->setStyleSheet("background-color:rgba(0,0,0,1); color:#ffffff; font-size:26px;");
	scoreList->setGeometry(QRect(0,55,425,500));
	scoreList->setAlignment(Qt::AlignCenter);
	scoreList->hide();
	gameScene->addWidget(scoreList);

	// Set the layouts
	layout2->addWidget(restartB);
	layout2->addWidget(pauseB);
	layout2->addWidget(endB);
	layout->addWidget(holder2);
	layout->addWidget(gameView);
	layout->addWidget(nameB);
	holder3->setVisible(false);
	layout->addWidget(holder3);
	layout->setContentsMargins(0, 0, 0, 0);
	layout->setMargin(0);
	layout2->setContentsMargins(0, 0, 0, 0);
	layout2->setMargin(0);
	layout3->setContentsMargins(0, 0, 0, 0);
	layout3->setMargin(0);

	mainScene->addWidget(holder);
	mainView->setFixedSize(460,710);
	mainView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	mainView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

	// Setting these for faster rendering
	gameView->setAttribute(Qt::WA_OpaquePaintEvent);
	gameView->setAttribute(Qt::WA_NoSystemBackground);
	mainView->setAttribute(Qt::WA_OpaquePaintEvent);
	mainView->setAttribute(Qt::WA_NoSystemBackground);
	mainView->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
	gameView->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
}
Exemplo n.º 27
0
void
PlayField::keyPressEvent(QKeyEvent * e) {
  int x=levelMap_->xpos();
  int y=levelMap_->ypos();

  switch (e->key()) {
  case Qt::Key_Up:
    if (e->state() & Qt::ControlModifier) step(x, 0);
    else if (e->state() & Qt::ShiftModifier) push(x, 0);
    else push(x, y-1);
    break;
  case Qt::Key_Down:
    if (e->state() & Qt::ControlModifier) step(x, MAX_Y);
    else if (e->state() & Qt::ShiftModifier) push(x, MAX_Y);
    else push(x, y+1);
    break;
  case Qt::Key_Left:
    if (e->state() & Qt::ControlModifier) step(0, y);
    else if (e->state() & Qt::ShiftModifier) push(0, y);
    else push(x-1, y);
    break;
  case Qt::Key_Right:
    if (e->state() & Qt::ControlModifier) step(MAX_X, y);
    else if (e->state() & Qt::ShiftModifier) push(MAX_X, y);
    else push(x+1, y);
    break;

  case Qt::Key_Q:
    KApplication::kApplication()->closeAllWindows();
    break;

  case Qt::Key_Backspace:
  case Qt::Key_Delete:
    if (e->state() & Qt::ControlModifier) redo();
    else undo();
    break;

#if 0
  case Qt::Key_X:
    levelMap_->random();
    levelChange();
    repaint(false);
    break;

  case Qt::Key_R:
    level(levelMap_->level());
    return;
    break;
  case Qt::Key_N:
    nextLevel();
    return;
    break;
  case Qt::Key_P:
    previousLevel();
    return;
    break;
  case Qt::Key_U:
    undo();
    return;
    break;
  case Qt::Key_I:
    history_->redo(levelMap_);
    repaint(false);
    return;
    break;

  case Qt::Key_S:
    {
      QString buf;
      history_->save(buf);
      printf("%s\n", (char *) buf);
    }
    return;
    break;

  case Qt::Key_L:
    stopMoving();
    history_->clear();
    level(levelMap_->level());
    {
      char buf[4096]="r1*D1*D1*r1*@r1*D1*";
      //scanf("%s", buf);
      history_->load(levelMap_, buf);
    }
    updateStepsXpm();
    updatePushesXpm();
    repaint(false);
    return;
    break;
#endif


  case Qt::Key_Print:
    HtmlPrinter::printHtml(levelMap_);
    break;

  default:
    e->ignore();
    return;
    break;
  }
}
Exemplo n.º 28
0
void GameState::restartLevel()
{
	m_level--;
	nextLevel();
}
Exemplo n.º 29
0
bool gameLoop()
{
    initLevelManager();
    loadLevel(g_LevelManager, 0);
    initHUD();
    bool done = false;
    int moveStartTime = SDL_GetTicks();

    while(!done)
    {
        int startTime = SDL_GetTicks();
        // handle game lose situation (timer has run out, eaten by monster)
        // now handled in cLevelManager::update()


        SDL_Event event;

        while(SDL_PollEvent(&event))
        {
            //check for messages
            switch(event.type)
            {
                case SDL_QUIT:
                    done = true;
                    break;
                //check for keypresses
                case SDL_KEYDOWN:
                {
                    //handle keypresses
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_ESCAPE:
                            g_LevelManager.stop();
                            done = true;
                            return true;
                            break;
                        case SDLK_m:
                            g_LevelManager.stop();
                            done = true;
                            return false;
                            break;
                        case SDLK_r:
                            g_LevelManager.endLevel();
                            moveStartTime = SDL_GetTicks();
                            loadLevel(g_LevelManager, g_LevelManager.getCurrentLevel());
                            break;
                        case SDLK_n:
                            nextLevel();
                            moveStartTime = SDL_GetTicks();
                            break;
                        case SDLK_p:
                            prevLevel();
                            moveStartTime = SDL_GetTicks();
                            break;
                        default:
                            g_InputManager.updateKey(event.key.keysym.sym);
                            break;
                    }
                }
            } //end switch
        } //end of message processing


        //autoplay routine (if level autoplay enabled)
        if(g_LevelManager.activeLevel()->autoPlay())
        {
            if(g_LevelManager.activePlayer()->moveNumber() < g_LevelManager.activePlayer()->movesSize())
            {
                int moveCheckTime = SDL_GetTicks();
                if(moveCheckTime - moveStartTime >= 300)
                {
                    g_InputManager.update();
                    moveStartTime = moveCheckTime;
                }
            }
        }

        g_InputManager.autoUpdate();
        //do game update

        /*****update graphics*****/

        //clear screen
        SDL_FillRect(screen,0,SDL_MapRGB(screen->format,0,0,0));
        //SDL_FillRect(display,0,SDL_MapRGB(display->format,0,0,0));

        //draw image
        g_RenderManager.update();

        int endTime = SDL_GetTicks();
        if(endTime - startTime < 1000/fps) SDL_Delay(1000/fps - (endTime - startTime));

        //end frame

        SDL_Flip(screen);

        //level win now handled in cLevelManager::update()

        if(g_LevelManager.checkWin())
        {
            done = true;
            return false;
        }

        /*
        if(levelWon())
        {
            nextLevel();
        }
        */
    }
    return done;
    //do exit
}
Exemplo n.º 30
0
SeaScene::SeaScene(QObject *parent) :
    QGraphicsScene(parent)
{

    setItemPointersNull();

    paused_ = false;
    screenLitKeeper_.keepScreenLit(true);

    QSettings settings;

    //set background

    QPixmap waves (":/pix/meri.png");
    waves.scaled(20,20);
    setBackgroundBrush(QBrush(waves));

    //set random seed

    qsrand(QTime::currentTime().msec()+2);  //+2 to avoid setting it to 1



//Setup level sets

    QList<Level> levelList;
    Level level1(5,10);
    levelList.append(level1);
    Level level2(5,10,2,50);
    levelList.append(level2);
    Level level3(5,15,2,50);
    levelList.append(level3);
    Level level4(5,15,4,50);
    levelList.append(level4);
    Level level5(5,15,5,100);
    levelList.append(level5);

    Levelset set ("Original",levelList);
    availableLevelsets_.append(set);


    //Create another set of levels and place it in the available levelsets list
    levelList.clear();
    Level set2level1(8,15,4,50);
    levelList.append(set2level1);
    Level set2level2(8,20,4,50);
    levelList.append(set2level2);
    Level set2level3(8,20,5,80);
    levelList.append(set2level3);
    Level set2level4(8,20,6,120);
    levelList.append(set2level4);
    Level set2level5(8,25,8,150);
    levelList.append(set2level5);

    Levelset set2("Difficult",levelList);
    availableLevelsets_.append(set2);


    //Setup starting levelset

    QString levelname = settings.value("levelset","Original").toString();
    bool found = false;
    foreach (Levelset levelset, availableLevelsets_)
    {
        if (levelset.getName() == levelname)
        {
            levelset_ = levelset;
            found = true;
            break;
        }
    }

    if (!found)  //The last used level is not available
    {
        levelset_ = availableLevelsets_.value(0);
    }

    currentLevel_ = 0;

    totalScore_ = 0;



    connect(this,SIGNAL(allGhostsPicked()),this,SLOT(nextLevel()));

    pVibrateAction_ = new QAction(tr("Vibration effects"),this);
    pVibrateAction_->setCheckable(true);
    connect(pVibrateAction_,SIGNAL(toggled(bool)),this,SLOT(vibrationActivate(bool)));

    pVibrateAction_->setChecked(settings.value("vibration",false).toBool());


    pPauseAction_ = new QAction(tr("Pause"),this);
    pPauseAction_->setCheckable(true);
    connect(pPauseAction_,SIGNAL(toggled(bool)),this,SLOT(pause(bool)));


    deviceLockPollTimer_.setInterval(20*60);
    connect(&deviceLockPollTimer_,SIGNAL(timeout()),this,SLOT(pollDeviceLocked()));
    deviceLockPollTimer_.start();


    autopauseTimer.setSingleShot(true);
    autopauseTimer.setInterval(15*60*1000);
    connect(&autopauseTimer,SIGNAL(timeout()),this,SLOT(turnPauseOn()));


}