Qt Reference Documentation

graphicsscene.cpp Example File

demos/sub-attaq/graphicsscene.cpp
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
 ** This file contains pre-release code and may not be distributed.
 ** You may use this file in accordance with the terms and conditions
 ** contained in the Technology Preview License Agreement accompanying
 ** this package.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 2.1 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.LGPL included in the
 ** packaging of this file.  Please review the following information to
 ** ensure the GNU Lesser General Public License version 2.1 requirements
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights.  These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at qt-info@nokia.com.
 **
 **
 **
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 //Own
 #include "graphicsscene.h"
 #include "states.h"
 #include "boat.h"
 #include "submarine.h"
 #include "torpedo.h"
 #include "bomb.h"
 #include "pixmapitem.h"
 #include "animationmanager.h"
 #include "qanimationstate.h"
 #include "progressitem.h"
 #include "textinformationitem.h"

 //Qt
 #include <QtCore/QPropertyAnimation>
 #include <QtCore/QSequentialAnimationGroup>
 #include <QtCore/QParallelAnimationGroup>
 #include <QtCore/QStateMachine>
 #include <QtCore/QFinalState>
 #include <QtCore/QPauseAnimation>
 #include <QtGui/QAction>
 #include <QtCore/QDir>
 #include <QtGui/QApplication>
 #include <QtGui/QMessageBox>
 #include <QtGui/QGraphicsView>
 #include <QtGui/QGraphicsSceneMouseEvent>
 #include <QtCore/QXmlStreamReader>

 GraphicsScene::GraphicsScene(int x, int y, int width, int height, Mode mode)
     : QGraphicsScene(x , y, width, height), mode(mode), boat(new Boat)
 {
     PixmapItem *backgroundItem = new PixmapItem(QString("background"),mode);
     backgroundItem->setZValue(1);
     backgroundItem->setPos(0,0);
     addItem(backgroundItem);

     PixmapItem *surfaceItem = new PixmapItem(QString("surface"),mode);
     surfaceItem->setZValue(3);
     surfaceItem->setPos(0,sealLevel() - surfaceItem->boundingRect().height()/2);
     addItem(surfaceItem);

     //The item that display score and level
     progressItem = new ProgressItem(backgroundItem);

     textInformationItem = new TextInformationItem(backgroundItem);
     textInformationItem->hide();
     //We create the boat
     addItem(boat);
     boat->setPos(this->width()/2, sealLevel() - boat->size().height());
     boat->hide();

     //parse the xml that contain all data of the game
     QXmlStreamReader reader;
     QFile file(":data.xml");
     file.open(QIODevice::ReadOnly);
     reader.setDevice(&file);
     LevelDescription currentLevel;
     while (!reader.atEnd()) {
          reader.readNext();
          if (reader.tokenType() == QXmlStreamReader::StartElement) {
              if (reader.name() == "submarine") {
                  SubmarineDescription desc;
                  desc.name = reader.attributes().value("name").toString();
                  desc.points = reader.attributes().value("points").toString().toInt();
                  desc.type = reader.attributes().value("type").toString().toInt();
                  submarinesData.append(desc);
              } else if (reader.name() == "level") {
                  currentLevel.id = reader.attributes().value("id").toString().toInt();
                  currentLevel.name = reader.attributes().value("name").toString();
              } else if (reader.name() == "subinstance") {
                  currentLevel.submarines.append(qMakePair(reader.attributes().value("type").toString().toInt(), reader.attributes().value("nb").toString().toInt()));
              }
          } else if (reader.tokenType() == QXmlStreamReader::EndElement) {
             if (reader.name() == "level") {
                 levelsData.insert(currentLevel.id, currentLevel);
                 currentLevel.submarines.clear();
             }
          }
    }
 }

 qreal GraphicsScene::sealLevel() const
 {
     return (mode == Big) ? 220 : 160;
 }

 void GraphicsScene::setupScene(QAction *newAction, QAction *quitAction)
 {
     static const int nLetters = 10;
     static struct {
         char const *pix;
         qreal initX, initY;
         qreal destX, destY;
     } logoData[nLetters] = {
         {"s",   -1000, -1000, 300, 150 },
         {"u",    -800, -1000, 350, 150 },
         {"b",    -600, -1000, 400, 120 },
         {"dash", -400, -1000, 460, 150 },
         {"a",    1000,  2000, 350, 250 },
         {"t",     800,  2000, 400, 250 },
         {"t2",    600,  2000, 430, 250 },
         {"a2",    400,  2000, 465, 250 },
         {"q",     200,  2000, 510, 250 },
         {"excl",    0,  2000, 570, 220 } };

     QSequentialAnimationGroup * lettersGroupMoving = new QSequentialAnimationGroup(this);
     QParallelAnimationGroup * lettersGroupFading = new QParallelAnimationGroup(this);

     for (int i = 0; i < nLetters; ++i) {
         PixmapItem *logo = new PixmapItem(QLatin1String(":/logo-") + logoData[i].pix, this);
         logo->setPos(logoData[i].initX, logoData[i].initY);
         logo->setZValue(i + 3);
         //creation of the animations for moving letters
         QPropertyAnimation *moveAnim = new QPropertyAnimation(logo, "pos", lettersGroupMoving);
         moveAnim->setEndValue(QPointF(logoData[i].destX, logoData[i].destY));
         moveAnim->setDuration(200);
         moveAnim->setEasingCurve(QEasingCurve::OutElastic);
         lettersGroupMoving->addPause(50);
         //creation of the animations for fading out the letters
         QPropertyAnimation *fadeAnim = new QPropertyAnimation(logo, "opacity", lettersGroupFading);
         fadeAnim->setDuration(800);
         fadeAnim->setEndValue(0);
         fadeAnim->setEasingCurve(QEasingCurve::OutQuad);
     }

     QStateMachine *machine = new QStateMachine(this);

     //This state is when the player is playing
     PlayState *gameState = new PlayState(this, machine);

     //Final state
     QFinalState *final = new QFinalState(machine);

     //Animation when the player enter in the game
     QAnimationState *lettersMovingState = new QAnimationState(machine);
     lettersMovingState->setAnimation(lettersGroupMoving);

     //Animation when the welcome screen disappear
     QAnimationState *lettersFadingState = new QAnimationState(machine);
     lettersFadingState->setAnimation(lettersGroupFading);

     //if new game then we fade out the welcome screen and start playing
     lettersMovingState->addTransition(newAction, SIGNAL(triggered()), lettersFadingState);
     lettersFadingState->addTransition(lettersFadingState, SIGNAL(animationFinished()), gameState);

     //New Game is triggered then player start playing
     gameState->addTransition(newAction, SIGNAL(triggered()), gameState);

     //Wanna quit, then connect to CTRL+Q
     gameState->addTransition(quitAction, SIGNAL(triggered()), final);
     lettersMovingState->addTransition(quitAction, SIGNAL(triggered()), final);

     //Welcome screen is the initial state
     machine->setInitialState(lettersMovingState);

     machine->start();

     //We reach the final state, then we quit
     connect(machine, SIGNAL(finished()), qApp, SLOT(quit()));
 }

 void GraphicsScene::addItem(Bomb *bomb)
 {
     bombs.insert(bomb);
     connect(bomb,SIGNAL(bombExecutionFinished()),this, SLOT(onBombExecutionFinished()));
     QGraphicsScene::addItem(bomb);
 }

 void GraphicsScene::addItem(Torpedo *torpedo)
 {
     torpedos.insert(torpedo);
     connect(torpedo,SIGNAL(torpedoExecutionFinished()),this, SLOT(onTorpedoExecutionFinished()));
     QGraphicsScene::addItem(torpedo);
 }

 void GraphicsScene::addItem(SubMarine *submarine)
 {
     submarines.insert(submarine);
     connect(submarine,SIGNAL(subMarineExecutionFinished()),this, SLOT(onSubMarineExecutionFinished()));
     QGraphicsScene::addItem(submarine);
 }

 void GraphicsScene::addItem(QGraphicsItem *item)
 {
     QGraphicsScene::addItem(item);
 }

 void GraphicsScene::onBombExecutionFinished()
 {
     Bomb *bomb = qobject_cast<Bomb *>(sender());
     bombs.remove(bomb);
     bomb->deleteLater();
     if (boat)
         boat->setBombsLaunched(boat->bombsLaunched() - 1);
 }

 void GraphicsScene::onTorpedoExecutionFinished()
 {
     Torpedo *torpedo = qobject_cast<Torpedo *>(sender());
     torpedos.remove(torpedo);
     torpedo->deleteLater();
 }

 void GraphicsScene::onSubMarineExecutionFinished()
 {
     SubMarine *submarine = qobject_cast<SubMarine *>(sender());
     submarines.remove(submarine);
     if (submarines.count() == 0)
         emit allSubMarineDestroyed(submarine->points());
     else
         emit subMarineDestroyed(submarine->points());
     submarine->deleteLater();
 }

 void GraphicsScene::clearScene()
 {
     foreach (SubMarine *sub, submarines) {
         sub->destroy();
         sub->deleteLater();
     }

     foreach (Torpedo *torpedo, torpedos) {
         torpedo->destroy();
         torpedo->deleteLater();
     }

     foreach (Bomb *bomb, bombs) {
         bomb->destroy();
         bomb->deleteLater();
     }

     submarines.clear();
     bombs.clear();
     torpedos.clear();

     AnimationManager::self()->unregisterAllAnimations();

     boat->stop();
     boat->hide();
     boat->setEnabled(true);
 }
X

Thank you for giving your feedback.

Make sure it is related to this specific page. For more general bugs and requests, please use the Qt Bug Tracker.

[0]; s.parentNode.insertBefore(ga, s); })();