git.maemo.org Git - ghostsoverboard/blob - seascene.cpp

   1 /**************************************************************************
   2         Ghosts Overboard - a game for Maemo 5
   3
   4         Copyright (C) 2011  Heli Hyvättinen
   5
   6         This file is part of Ghosts Overboard
   7
   8         Ghosts Overboard is free software: you can redistribute it and/or modify
   9         it under the terms of the GNU General Public License as published by
  10         the Free Software Foundation, either version 2 of the License, or
  11         (at your option) any later version.
  12
  13         This program is distributed in the hope that it will be useful,
  14         but WITHOUT ANY WARRANTY; without even the implied warranty of
  15         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16         GNU General Public License for more details.
  17
  18         You should have received a copy of the GNU General Public License
  19         along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 **************************************************************************/
  22
  23 #include "seascene.h"
  24 #include "octopus.h"
  25 #include "ship.h"
  26 #include <QGraphicsPixmapItem>
  27 #include <QDebug>
  28 #include <QMessageBox>
  29 #include <QTime>
  30 #include <QApplication>
  31 #include <QAction>
  32 #include <QPushButton>
  33 #include <QLabel>
  34 #include <QVBoxLayout>
  35
  36 const QString ghostImageFilename_ = ":/pix/aave.png";
  37 const QString rockImageFilename_ =":/pix/kari.png";
  38 const QString octopusImageFilename_= ":/pix/tursas.png";
  39
  40
  41 SeaScene::SeaScene(QObject *parent) :
  42     QGraphicsScene(parent)
  43 {
  44     paused_ = false;
  45     screenLitKeeper_.keepScreenLit(true);
  46
  47     //set background
  48
  49     QPixmap waves (":/pix/meri.png");
  50     waves.scaled(20,20);
  51     setBackgroundBrush(QBrush(waves));
  52
  53     //set random seed
  54
  55     qsrand(QTime::currentTime().msec()+2);  //+2 to avoid setting it to 1
  56
  57 //Setup the level list
  58
  59     Level level1(5,10);
  60     levelList_.append(level1);
  61     Level level2(5,10,2,50);
  62     levelList_.append(level2);
  63     Level level3(5,15,2,50);
  64     levelList_.append(level3);
  65     Level level4(5,15,4,50);
  66     levelList_.append(level4);
  67     Level level5(5,15,5,100);
  68     levelList_.append(level5);
  69
  70     currentLevel_ = 0;
  71
  72     connect(this,SIGNAL(allGhostsPicked()),this,SLOT(nextLevel()));
  73
  74
  75     pVibrateAction_ = new QAction(tr("Vibration effects"),this);
  76     pVibrateAction_->setCheckable(true);
  77     connect(pVibrateAction_,SIGNAL(toggled(bool)),this,SLOT(vibrationActivate(bool)));
  78
  79
  80     pPauseAction_ = new QAction(tr("Pause"),this);
  81     pPauseAction_->setCheckable(true);
  82     connect(pPauseAction_,SIGNAL(toggled(bool)),this,SLOT(pause(bool)));
  83
  84
  85 }
  86
  87 void SeaScene::setupMap(int ghosts, int rocks, int octopuses, int octopusSpeed)
  88 {
  89     //empty the map
  90
  91     clear();
  92
  93     createMenuItems();
  94
  95     //empty the list of moving items
  96
  97     movingItems_.clear();
  98
  99     //empty the list of free slots
 100     freeTiles_.clear();
 101
 102     //fill the list of free slots
 103
 104     int numberOfXTiles  = width() / 40;
 105     int numberOfYTiles = height() /40;
 106
 107 //    qDebug() << numberOfXTiles << " slots in x direction";
 108 //    qDebug() << numberOfYTiles << " slots in y rirection";
 109
 110     for (int i = 0; i < numberOfXTiles; i++ )
 111     {
 112         for (int j = 0; j < numberOfYTiles; j++)
 113         {
 114             freeTiles_.append(QPointF(i*40,j*40));
 115         }
 116     }
 117
 118
 119     //spread the rocks
 120
 121     for (int i = 0; i < rocks; i++)
 122     {
 123         QPointF * pPosition = findRandomFreeSlot();
 124
 125         //If there was no room no point to continue
 126         if (pPosition == NULL)
 127             break;
 128
 129         QPixmap rockPixmap (":/pix/kari.png");
 130         QGraphicsPixmapItem * pRock = addPixmap(rockPixmap);
 131         pRock->setData(0,"rock");
 132         pRock->setPos(*pPosition);
 133         delete pPosition;
 134
 135     }
 136
 137     //spread the ghosts
 138
 139     ghostsLeft_ = ghosts;
 140     spreadGhosts(ghosts);
 141
 142
 143
 144     //spread the octopuses
 145
 146     QList <Octopus*> octopusList;
 147
 148     for (int i=0; i < octopuses; i++)
 149     {
 150         QPointF * pPosition = findRandomFreeSlot();
 151
 152         //If there was no room no point to continue
 153         if (pPosition == NULL)
 154             break;
 155
 156     QPixmap octopusPixmap (":/pix/tursas.png");
 157     Octopus * pOctopus = new Octopus(octopusPixmap,octopusSpeed);
 158     pOctopus->setData(0,"octopus");
 159     pOctopus->setPos(*pPosition);
 160     addItem(pOctopus);
 161     pOctopus->startMoving();
 162     movingItems_.append(pOctopus);
 163     connect(this,SIGNAL(pauseOn()),pOctopus,SLOT(stopMoving()));
 164     connect(this,SIGNAL(pauseOff()),pOctopus,SLOT(startMoving()));
 165     octopusList.append(pOctopus);
 166     delete pPosition;
 167
 168     }
 169
 170
 171     //place the ship
 172
 173     QPointF * pPosition = findRandomFreeSlot();
 174     if (pPosition == NULL)
 175     {
 176         // Game cannot begin without a free position for ship, so give an error message and return
 177
 178         QMessageBox::critical(NULL,"Error! Too many objects on screen","No free space to place the ship. The game cannot start. Please choose another level.");
 179         return;
 180     }
 181
 182     QList<QPixmap> shipImages;
 183     shipImages.append(QPixmap(":/pix/laiva.png"));
 184     shipImages.append(QPixmap(":/pix/laiva_1aave.png"));
 185     shipImages.append(QPixmap(":/pix/laiva_2aave.png"));
 186     shipImages.append(QPixmap(":/pix/laiva_3aave.png"));
 187     shipImages.append(QPixmap(":/pix/laiva_4aave.png"));
 188     shipImages.append(QPixmap(":/pix/laiva_5aave.png"));
 189     shipImages.append(QPixmap(":/pix/laiva_6aave.png"));
 190     shipImages.append(QPixmap(":/pix/laiva_7aave.png"));
 191     shipImages.append(QPixmap(":/pix/laiva_8aave.png"));
 192     shipImages.append(QPixmap(":/pix/laiva_9aave.png"));
 193     shipImages.append(QPixmap(":/pix/laiva_10aave.png"));
 194
 195     Ship * pShip = new Ship (shipImages);
 196     pShip->setData(0,"ship");
 197     pShip->setPos(*pPosition);
 198     addItem(pShip);
 199     connect(pShip,SIGNAL(pickingGhost(QGraphicsItem*)),this, SLOT(removeGhost(QGraphicsItem*)) );
 200     connect(pShip,SIGNAL(droppingGhosts(int)),this,SLOT(ghostsDropped(int)));
 201     connect(this,SIGNAL(vibrationActivated(bool)),pShip,SLOT(setVibrationActivate(bool)));
 202     pShip->startMoving();
 203     movingItems_.append(pShip);
 204     connect(this,SIGNAL(pauseOn()),pShip,SLOT(stopMoving()));
 205     connect(this,SIGNAL(pauseOff()),pShip,SLOT(startMoving()));
 206     foreach (Octopus* pOctopus, octopusList)
 207     {
 208         connect(pOctopus,SIGNAL(droppingGhosts()),pShip,SLOT(dropAllGhosts()));
 209     }
 210     delete pPosition;
 211 }
 212
 213 void SeaScene::setupMap(Level level)
 214 {
 215     setupMap(level.getNumberOfGhosts(),level.getNumberOfRocks(),level.getNumberOfOctopuses(),level.getOctopusSpeed());
 216 }
 217
 218 void SeaScene::spreadGhosts(int ghosts)
 219 {
 220
 221
 222     //the octopuses and the ship may have moved from their original positions,
 223     //so the list of free slots must be adjusted to exclude their current positions
 224
 225     QList<QPointF> temporarilyReservedSlots;
 226
 227     foreach (QGraphicsItem* pItem, movingItems_)
 228     {
 229         if (pItem == NULL)
 230         {
 231  //           qDebug() << "NULL item in movingItems_";
 232             continue;
 233         }
 234
 235         //round x and y down to fit the slot size
 236         int x = pItem->x();
 237         x = x/40;
 238         x = x*40;
 239
 240         int y = pItem->y();
 241         y = y/40;
 242         y=y*40;
 243
 244
 245         QPointF position (x,y);
 246
 247         //remove the tiles (potentially) occupied by the item from free slots and place in temp list if was in the list before
 248
 249         if (freeTiles_.removeOne(position))
 250             temporarilyReservedSlots.append(position);
 251
 252
 253         position.setX(x+40);
 254
 255         if (freeTiles_.removeOne(position))
 256             temporarilyReservedSlots.append(position);
 257
 258         position.setY(y+40);
 259
 260         if (freeTiles_.removeOne(position))
 261             temporarilyReservedSlots.append(position);
 262
 263         position.setX(x);
 264
 265         if (freeTiles_.removeOne(position))
 266             temporarilyReservedSlots.append(position);
 267
 268     }
 269
 270
 271     //spread ghosts in random free slots
 272
 273     for (int i=0; i < ghosts; i++)
 274     {
 275         QPointF * pPosition = findRandomFreeSlot();
 276
 277         //If there was no room no point to continue
 278         if (pPosition == NULL)
 279             return;
 280
 281         QPixmap ghostPixmap(":/pix/aave.png");
 282         QGraphicsPixmapItem * pGhost = addPixmap(ghostPixmap);
 283         pGhost->setData(0,"ghost");
 284         pGhost->setPos(*pPosition);
 285         delete pPosition;
 286     }
 287
 288     //return the slots occupied by moving items to free slots
 289     freeTiles_.append(temporarilyReservedSlots);
 290
 291     //clear temp for the next round
 292     temporarilyReservedSlots.clear();
 293 }
 294
 295 QPointF* SeaScene::findRandomFreeSlot()
 296 {
 297     if (freeTiles_.isEmpty())
 298         return NULL;
 299
 300     int index = qrand()%freeTiles_.size();
 301
 302 //    qDebug()  << index << " index";
 303     return new QPointF (freeTiles_.takeAt(index));
 304
 305 }
 306
 307 void SeaScene::removeGhost(QGraphicsItem *pGhost)
 308 {
 309     removeItem(pGhost);  //remove the item from scene
 310     freeTiles_.append(pGhost->scenePos()); //add the item's position to free slots
 311     delete pGhost;
 312     ghostsLeft_--;
 313     if (ghostsLeft_ == 0)
 314     {
 315         emit allGhostsPicked();
 316  //       qDebug() << "All ghosts picked!";
 317     }
 318 }
 319
 320 void SeaScene::ghostsDropped(int ghosts)
 321 {
 322     ghostsLeft_ += ghosts;
 323
 324     spreadGhosts(ghosts);
 325 }
 326
 327 void SeaScene::pause(bool paused)
 328 {
 329     //    qDebug() << "pause pressed " << paused;
 330         if (paused_ == paused)
 331                 return;
 332
 333         paused_ = paused;
 334
 335         if (paused == false)
 336         {
 337      //       qDebug() << "starting to move again";
 338             emit fullscreenRequested();
 339             emit pauseOff();
 340             screenLitKeeper_.keepScreenLit(true);
 341             if (pPausetextItem_)
 342                 pPausetextItem_->hide();
 343         }
 344
 345         else
 346         {
 347          qDebug("about to stop movement");
 348             emit pauseOn();
 349             screenLitKeeper_.keepScreenLit(false);
 350             if (pPausetextItem_ != NULL)
 351             {
 352                 qDebug() << "about to show the pause text";
 353                 pPausetextItem_->show();
 354                 qDebug() << "showing pause text";
 355             }
 356                 else qDebug() << "No pause text available";
 357         }
 358 }
 359
 360 void SeaScene::vibrationActivate(bool on)
 361 {
 362     emit vibrationActivated(on);
 363 }
 364
 365 void SeaScene::handleScreenTapped()
 366 {
 367
 368     //If the game is going just pause it
 369     if (!paused_)
 370     {
 371         pPauseAction_->setChecked(true);
 372         return;
 373     }
 374
 375     //If the game is paused, chacl if menu item was selected
 376
 377     QList<QGraphicsItem *> items = selectedItems();
 378
 379     //if nothing selected resume play
 380
 381     if (items.isEmpty())
 382     {
 383         pPauseAction_->setChecked(false);
 384         return;
 385
 386     }
 387
 388     //If something was selected check if it was one of the menu items and act on it
 389     //(Nothing else should be made selectable anyway)
 390
 391     //Menu functions
 392
 393     QGraphicsItem* pItem = items.at(0); //Selecting an item brings here, thus only selecting one item should be possible
 394                                        //... so we can just take the first one
 395
 396
 397     if (pItem == pRestartGameItem_)
 398     {
 399         qDebug() << "game restart requested";
 400         restartGame();
 401     }
 402
 403     else if (pItem == pRestartLevelItem_)
 404     {
 405         qDebug() << "Level restart requested";
 406         restartLevel();
 407
 408     }
 409
 410     else if (pItem == pSettingsItem_)
 411     {
 412     //Temporary code for settings, likely to be turned into a QML dialog
 413
 414           QMessageBox::StandardButton buttonpressed = QMessageBox::question(NULL,"Settings","Do you wish to have vibration effects enabled?", QMessageBox::Yes | QMessageBox::No);
 415
 416           if (buttonpressed == QMessageBox::Yes)
 417               pVibrateAction_->setChecked(true);
 418           if (buttonpressed == QMessageBox::No)
 419               pVibrateAction_->setChecked(false);
 420     }
 421
 422     else if (pItem == pAboutItem_)
 423     {
 424         about();
 425     }
 426
 427     else if(pItem == pMinimizeItem_)
 428     {
 429         emit minimizeRequested();
 430     }
 431
 432     else if (pItem == pQuitItem_)
 433     {
 434         qApp->quit();
 435     }
 436
 437
 438
 439     //Selection is just used to get notice of a menu item being clicked, removed after use
 440
 441     clearSelection();
 442
 443     //The user propably went to paused state just to access menu, so unpause
 444     //unless status bar was requested
 445     if (pItem != pMinimizeItem_)
 446     {
 447         pPauseAction_->setChecked(false);
 448     }
 449 }
 450
 451
 452
 453 void SeaScene::createMenuItems()
 454 {
 455
 456     QFont font;
 457     font.setPixelSize(35);
 458
 459
 460
 461     pPausetextItem_ = new QGraphicsTextItem;
 462     pPausetextItem_->setHtml("<font size = \"5\" color = darkorange> Game paused. Tap to continue.");
 463     pPausetextItem_->setZValue(1000);
 464     pPausetextItem_->setPos(165,50);
 465     addItem(pPausetextItem_);
 466     pPausetextItem_->hide();
 467
 468     menuItemCount_ = 0;
 469
 470     QString menufonthtml = "<font size = \"4\" color = darkorange>";
 471
 472     pRestartGameItem_ = new QGraphicsTextItem;
 473     pRestartGameItem_->setHtml(tr("Restart <br> game").prepend(menufonthtml));
 474     prepareForMenu(pRestartGameItem_);
 475
 476     pRestartLevelItem_ = new QGraphicsTextItem;
 477     pRestartLevelItem_->setHtml(tr("Restart <br> level").prepend(menufonthtml));
 478     prepareForMenu(pRestartLevelItem_);
 479
 480     pSettingsItem_ = new QGraphicsTextItem;
 481     pSettingsItem_->setHtml(tr("Vibration <br> effects").prepend(menufonthtml));
 482     prepareForMenu(pSettingsItem_);
 483
 484     pAboutItem_ = new QGraphicsTextItem;
 485     pAboutItem_->setHtml(tr("About <br> game").prepend(menufonthtml));
 486     prepareForMenu(pAboutItem_);
 487
 488     pMinimizeItem_ = new QGraphicsTextItem;
 489     pMinimizeItem_->setHtml(tr("Show <br> status bar").prepend(menufonthtml));
 490     prepareForMenu(pMinimizeItem_);
 491
 492     pQuitItem_ = new QGraphicsTextItem;
 493     pQuitItem_->setHtml(tr("Quit <br> game").prepend(menufonthtml));
 494     prepareForMenu(pQuitItem_);
 495
 496 }
 497
 498 void SeaScene::prepareForMenu(QGraphicsItem * pItem)
 499 {
 500
 501     //Menu items have pause text item as their parent and are thus added to scene automatically
 502     //They are also shown and hidden with it, resulting in the menu being visble when the game is paused
 503     //Their coordinates are given relative to the parent.
 504
 505
 506
 507
 508     int itemsPerRow = 3;
 509
 510     pItem->setParentItem(pPausetextItem_);
 511     pItem->setZValue(1000);
 512     pItem->setFlag(QGraphicsItem::ItemIsSelectable);
 513
 514     int row = menuItemCount_/(itemsPerRow);
 515     pItem->setY(150+row*120);
 516     pItem->setX(((menuItemCount_%(itemsPerRow))*180+5));
 517
 518     menuItemCount_++;
 519  }
 520
 521
 522 void SeaScene::about()
 523 {
 524     QMessageBox::about(NULL, tr("About %1").arg(QApplication::applicationName()),
 525                        tr("Version %1"
 526                           "<p>Copyright 2011 Heli Hyv&auml;ttinen"
 527                           "<p>License: General Public License v2"
 528                           "<p>Bug Reports: https://bugs.maemo.org/ "
 529                           "enter_bug.cgi?product=Ghosts%20Overboard"
 530                           ).arg(QApplication::applicationVersion()));
 531
 532
 533
 534 }
 535
 536
 537 void SeaScene::restartLevel()
 538 {
 539     setupMap(levelList_.value(currentLevel_));  //value() returns default constructor Level if index is invalid, so no risk of crash
 540     vibrationActivate(pVibrateAction_->isChecked());  //Vibration effects are lost without this
 541    // qDebug() << pVibrateAction_->isChecked();
 542 }
 543
 544
 545
 546 void SeaScene::nextLevel()
 547 {
 548
 549     currentLevel_++;
 550
 551     if (levelList_.empty())
 552         setupMap(Level());
 553
 554
 555     if ( currentLevel_ < levelList_.size() )
 556     {
 557        restartLevel();
 558     }
 559
 560     else //Victory!
 561     {
 562
 563        QDialog* pVictoryDialog = new QDialog();
 564        pVictoryDialog->setWindowTitle(tr("You won!"));
 565
 566
 567        QPushButton* pPlayAgainButton = new QPushButton(tr("Play again"));
 568 //       QPushButton* pQuitButton = new QPushButton(tr("Quit game"));
 569
 570        QPixmap victoryIcon (":/pix/aavesaari.png");
 571        QLabel* pVictoryLabel = new QLabel();
 572        pVictoryLabel->setPixmap(victoryIcon);
 573
 574        QLabel* pTextLabel = new QLabel(tr("Congratulations! <p>You have saved all the ghosts."));
 575
 576
 577        QVBoxLayout* pMainLayout = new QVBoxLayout;
 578
 579        QHBoxLayout* pTopLayout = new QHBoxLayout;
 580        pMainLayout->addLayout(pTopLayout);
 581
 582        pTopLayout->addWidget(pVictoryLabel);
 583        pTopLayout->addWidget(pTextLabel);
 584
 585
 586
 587        QHBoxLayout* pButtonLayout = new QHBoxLayout();
 588        pMainLayout->addLayout(pButtonLayout);
 589
 590  //      pButtonLayout->addWidget(pQuitButton);
 591        pButtonLayout->addWidget(pPlayAgainButton);
 592
 593
 594
 595        pVictoryDialog->setLayout(pMainLayout);
 596
 597        connect(pPlayAgainButton, SIGNAL(clicked()),pVictoryDialog,SLOT(accept()));
 598
 599        pVictoryDialog->exec();
 600
 601         //Never mind if the user cancels the dialog: restart the game anyway
 602
 603        restartGame();
 604     }
 605 }
 606
 607
 608 void SeaScene::restartGame()
 609 {
 610     currentLevel_ = 0;
 611     restartLevel();
 612 }
 613
 614
 615 void SeaScene::forcePause()
 616 {
 617     //Pause without setting the pause action state
 618     pause(true);
 619 }
 620
 621 void::SeaScene::softContinue()
 622 {
 623     //Continue if not being paused by the user
 624     // Reverts forcePause()
 625
 626     pause(pPauseAction_->isChecked());
 627 }