Qt 4.6: graphicsscene.cpp Example File (demos/sub-attaq/graphicsscene.cpp)

|  | Home · All Classes · Overviews |

# graphicsscene.cpp Example File
demos/sub-attaq/graphicsscene.cpp

     /****************************************************************************
     **
     ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
     ** 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 "custompropertyanimation.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>

     //helper function that creates an animation for position and inserts it into group
     static CustomPropertyAnimation *addGraphicsItemPosAnimation(QSequentialAnimationGroup *group,
                                                                   QGraphicsItem *item, const QPointF &endPos)
     {
         CustomPropertyAnimation *ret = new CustomPropertyAnimation(group);
         ret->setMemberFunctions(item, &QGraphicsItem::pos, &QGraphicsItem::setPos);
         ret->setEndValue(endPos);
         ret->setDuration(200);
         ret->setEasingCurve(QEasingCurve::OutElastic);
         group->addPause(50);
         return ret;
     }

     //helper function that creates an animation for opacity and inserts it into group
     static void addGraphicsItemFadeoutAnimation(QAnimationGroup *group, QGraphicsItem *item)
     {
     #if QT_VERSION >=0x040500
         CustomPropertyAnimation *anim = new CustomPropertyAnimation(group);
         anim->setMemberFunctions(item, &QGraphicsItem::opacity, &QGraphicsItem::setOpacity);
         anim->setDuration(800);
         anim->setEndValue(0);
         anim->setEasingCurve(QEasingCurve::OutQuad);
     #else
         // work around for a bug where we don't transition if the duration is zero.
         QtPauseAnimation *anim = new QtPauseAnimation(group);
         anim->setDuration(1);
     #endif
     }

     GraphicsScene::GraphicsScene(int x, int y, int width, int height, Mode mode)
         : QGraphicsScene(x,y,width,height), mode(mode), newAction(0), quitAction(0), boat(0)
     {
         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
         boat = new 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);
                  }
                  if (reader.name() == "level")
                  {
                      currentLevel.id = reader.attributes().value("id").toString().toInt();
                      currentLevel.name = reader.attributes().value("name").toString();
                  }
                  if (reader.name() == "subinstance")
                  {
                      currentLevel.submarines.append(qMakePair(reader.attributes().value("type").toString().toInt(),reader.attributes().value("nb").toString().toInt()));
                  }
              }
              if (reader.tokenType() == QXmlStreamReader::EndElement) {
                 if (reader.name() == "level")
                 {
                     levelsData.insert(currentLevel.id,currentLevel);
                     currentLevel.submarines.clear();
                 }
              }
        }
     }

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

     void GraphicsScene::setupScene(const QList<QAction *> &actions)
     {
         newAction = actions.at(0);
         quitAction = actions.at(1);

         QGraphicsItem *logo_s = addWelcomeItem(QPixmap(":/logo-s"));
         QGraphicsItem *logo_u = addWelcomeItem(QPixmap(":/logo-u"));
         QGraphicsItem *logo_b = addWelcomeItem(QPixmap(":/logo-b"));
         QGraphicsItem *logo_dash = addWelcomeItem(QPixmap(":/logo-dash"));
         QGraphicsItem *logo_a = addWelcomeItem(QPixmap(":/logo-a"));
         QGraphicsItem *logo_t = addWelcomeItem(QPixmap(":/logo-t"));
         QGraphicsItem *logo_t2 = addWelcomeItem(QPixmap(":/logo-t2"));
         QGraphicsItem *logo_a2 = addWelcomeItem(QPixmap(":/logo-a2"));
         QGraphicsItem *logo_q = addWelcomeItem(QPixmap(":/logo-q"));
         QGraphicsItem *logo_excl = addWelcomeItem(QPixmap(":/logo-excl"));
         logo_s->setZValue(3);
         logo_u->setZValue(4);
         logo_b->setZValue(5);
         logo_dash->setZValue(6);
         logo_a->setZValue(7);
         logo_t->setZValue(8);
         logo_t2->setZValue(9);
         logo_a2->setZValue(10);
         logo_q->setZValue(11);
         logo_excl->setZValue(12);
         logo_s->setPos(QPointF(-1000, -1000));
         logo_u->setPos(QPointF(-800, -1000));
         logo_b->setPos(QPointF(-600, -1000));
         logo_dash->setPos(QPointF(-400, -1000));
         logo_a->setPos(QPointF(1000, 2000));
         logo_t->setPos(QPointF(800, 2000));
         logo_t2->setPos(QPointF(600, 2000));
         logo_a2->setPos(QPointF(400, 2000));
         logo_q->setPos(QPointF(200, 2000));
         logo_excl->setPos(QPointF(0, 2000));

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

         //creation of the animations for moving letters
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_s, QPointF(300, 150));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_u, QPointF(350, 150));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_b, QPointF(400, 120));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_dash, QPointF(460, 150));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_a, QPointF(350, 250));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_t, QPointF(400, 250));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_t2, QPointF(430, 250));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_a2, QPointF(465, 250));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_q, QPointF(510, 250));
         addGraphicsItemPosAnimation(lettersGroupMoving, logo_excl, QPointF(570, 220));

         //creation of the animations for fading out the letters
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_s);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_u);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_b);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_dash);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_a);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_t);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_t2);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_a2);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_q);
         addGraphicsItemFadeoutAnimation(lettersGroupFading, logo_excl);
         connect(lettersGroupFading, SIGNAL(finished()), this, SLOT(onIntroAnimationFinished()));

         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()),this, SLOT(onQuitGameTriggered()));
     }

     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::mousePressEvent (QGraphicsSceneMouseEvent * event)
     {
         event->ignore();
     }

     void GraphicsScene::onQuitGameTriggered()
     {
         qApp->closeAllWindows();
     }

     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();
     }

     int GraphicsScene::remainingSubMarines() const
     {
         return submarines.count();
     }

     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();
     }

     QGraphicsPixmapItem *GraphicsScene::addWelcomeItem(const QPixmap &pm)
     {
         QGraphicsPixmapItem *item = addPixmap(pm);
         welcomeItems << item;
         return item;
     }

     void GraphicsScene::onIntroAnimationFinished()
     {
         qDeleteAll(welcomeItems);
         welcomeItems.clear();
     }