- make a few optimizations to actor sprites

- make actor move via keyboard!

9 files changed, 203 insertions, 56 deletions

diff --git a/pacman-c++/actor.cpp b/pacman-c++/actor.cpp
index cde20cd..1796091 100644
--- a/pacman-c++/actor.cpp
+++ b/pacman-c++/actor.cpp
@@ -1,8 +1,6 @@
 #include "actor.h"
 #include "animationmanager.h"
 #include <QtCore/QPropertyAnimation>
-#include <QtCore/QSequentialAnimationGroup>
-#include <QtCore/QParallelAnimationGroup>
 #include <QtCore/QVariantAnimation>
 #include <QDebug>
 
@@ -11,8 +9,8 @@ static QVariant myBooleanInterpolator(const bool &start, const bool &end, qreal
   return (progress == 1.0) ? end : start;
 }
 
-Actor::Actor(Color::Color color, QGraphicsItem *parent)
-  : PixmapItem(parent), m_color(color), m_direction(Actor::None)
+Actor::Actor(Color::Color color, bool local, QGraphicsItem *parent)
+  : PixmapItem(parent), m_color(color), m_direction(Actor::None), m_local(local)
 {
   m_pix  = ":/" + QString("actor%1").arg((m_color >> 1) + 1);
   // DON'T set any pixmap here. we've a pixmap in the animation
@@ -24,23 +22,47 @@ Actor::Actor(Color::Color color, QGraphicsItem *parent)
   m_icon.setPixmap(m_pix);
   m_icon.setSprite(Constants::sprite_margin, Constants::sprite_margin, Constants::field_size.width, Constants::field_size.height);
 
-  m_direction = Actor::Left;
+  /* setup static images first
+   * they are visible if no animation is running
+   * and will be the first in m_images
+   */
+  for (int i = 0; i < 5; i++)
+  {
+    PixmapItem *img = new PixmapItem(m_pix, this);
+    m_images.append(img);
+    int x = i * Constants::sprite_offset + Constants::sprite_margin;
+    int y = Actor::None * Constants::sprite_offset + Constants::sprite_margin;
+    img->setSprite(x, y, Constants::field_size.width, Constants::field_size.height);
+    img->setZValue(zValue());
+    img->setVisible(false);
+  }
 
+  /* setup animation stuff */
   qRegisterAnimationInterpolator<bool>(myBooleanInterpolator);
+  m_moving = new QParallelAnimationGroup(this);
+  m_eating.append(NULL); // Actor::None
+  m_eating.append(setupEatingAnimation(Actor::Left));
+  m_eating.append(setupEatingAnimation(Actor::Right));
+  m_eating.append(setupEatingAnimation(Actor::Up));
+  m_eating.append(setupEatingAnimation(Actor::Down));
+
+  /* make the picture showing the current direction visible */
+  m_images[m_direction]->setVisible(true);
+}
 
+QSequentialAnimationGroup *Actor::setupEatingAnimation(Actor::Movement direction)
+{
   QSequentialAnimationGroup *eating = new QSequentialAnimationGroup(this);
-  QParallelAnimationGroup *moving = new QParallelAnimationGroup(this);
   eating->setLoopCount(-1);
-
   for (int i = 0; i < 4; i++)
   {
     PixmapItem *img = new PixmapItem(m_pix, this);
+    m_images.append(img);
     int x = i * Constants::sprite_offset + Constants::sprite_margin;
-    int y = m_direction * Constants::sprite_offset + Constants::sprite_margin;
+    int y = direction * Constants::sprite_offset + Constants::sprite_margin;
     img->setSprite(x, y, Constants::field_size.width, Constants::field_size.height);
     img->setZValue(zValue());
     img->setVisible(false);
-    img->setPos(QPointF(200, 0));
 
     QPropertyAnimation *fadein = new QPropertyAnimation(img, "visible", eating);
     fadein->setDuration(0);
@@ -52,17 +74,92 @@ Actor::Actor(Color::Color color, QGraphicsItem *parent)
     fadeout->setDuration(0);
     fadeout->setEndValue(false);
 
-    QPropertyAnimation *move = new QPropertyAnimation(img, "pos", moving);
-    move->setDuration(5000);
-    move->setEndValue(QPointF(0, 0));
+    QPropertyAnimation *move = new QPropertyAnimation(img, "pos", m_moving);
+    move->setDuration(Constants::tick);
   }
 
-  AnimationManager::self()->registerAnimation(eating);
-  eating->start();
-  moving->start();
+  return eating;
+}
+
+Color::Color Actor::getColor()
+{
+  return m_color;
 }
 
 PixmapItem &Actor::getIcon()
 {
   return m_icon;
 }
+
+bool Actor::isLocal()
+{
+  return m_local;
+}
+
+void Actor::move(Actor::Movement direction)
+{
+  //TODO: remove?
+  if (isMoving())
+    return;
+
+  /* stop current animation */
+  if (direction != m_direction)
+  {
+    /* hide all pictures */
+    for (int i = 0; i < m_images.size(); ++i)
+      m_images.at(i)->setVisible(false);
+
+    if (m_eating[m_direction] != NULL)
+    {
+      m_eating[m_direction]->stop();
+      //AnimationManager::self()->unregisterAnimation(m_eating[m_direction]);
+    }
+  }
+
+  QPointF endpos(0, 0);
+  switch(direction)
+  {
+  case Actor::None:
+    break;
+  case Actor::Left:
+    endpos.setX(static_cast<qreal>(Constants::field_size.width) * -1);
+    break;
+  case Actor::Right:
+    endpos.setX(Constants::field_size.width);
+    break;
+  case Actor::Up:
+    endpos.setY(static_cast<qreal>(Constants::field_size.height) * -1);
+    break;
+  case Actor::Down:
+    endpos.setY(Constants::field_size.height);
+    break;
+  default:
+    Q_ASSERT(false);
+    break;
+  }
+
+  qDebug() << __FILE__ << "Move from" << pos() - endpos << "to" << (pos()) << "(" << endpos << ")";
+  for(int i = 0; i < m_moving->animationCount(); ++i)
+  {
+    QPropertyAnimation *move = dynamic_cast<QPropertyAnimation *>(m_moving->animationAt(i));
+    move->setStartValue(QPoint(0, 0) - endpos);
+    move->setEndValue(QPoint(0, 0));
+  }
+  setPos(pos() + endpos);
+
+  /* start new animation */
+  if (direction != m_direction)
+  {
+    if (direction == Actor::None)
+      m_images[m_direction]->setVisible(true);
+    else
+      m_eating[direction]->start();
+    m_direction = direction;
+  }
+  m_moving->start();
+}
+
+bool Actor::isMoving()
+{
+  return (m_moving->state() ==  QAbstractAnimation::Running);
+}
diff --git a/pacman-c++/actor.h b/pacman-c++/actor.h
index 39ccb88..68bf06f 100644
--- a/pacman-c++/actor.h
+++ b/pacman-c++/actor.h
@@ -3,30 +3,42 @@
 
 #include "pixmapitem.h"
 #include "constants.h"
+#include <QtCore/QSequentialAnimationGroup>
+#include <QtCore/QParallelAnimationGroup>
+#include <QList>
 
 class Actor
   : public PixmapItem
 {
 public:
   enum Movement {
-    None = 0,
+    None    = 0,
     Left,
     Right,
     Up,
-    Down
+    Down,
   };
 
-  Actor(Color::Color color, QGraphicsItem *parent = 0);
+  Actor(Color::Color color, bool local = false, QGraphicsItem *parent = 0);
   virtual ~Actor() {};
 
+  QSequentialAnimationGroup *setupEatingAnimation(Actor::Movement direction);
+  Color::Color getColor();
   PixmapItem &getIcon();
-  Color::Color getColor() { return m_color; }
+  bool isLocal();
+  void move(Movement direction);
+  bool isMoving();
 
 private:
   QPixmap m_pix;
   Color::Color m_color;
   Movement m_direction;
   PixmapItem m_icon;
+  bool m_local;
+
+  QList<PixmapItem *> m_images;
+  QList<QSequentialAnimationGroup *> m_eating;
+  QParallelAnimationGroup *m_moving;
 };
 
 #endif // ACTOR_H
diff --git a/pacman-c++/constants.h b/pacman-c++/constants.h
index 019ac14..f0e7903 100644
--- a/pacman-c++/constants.h
+++ b/pacman-c++/constants.h
@@ -4,13 +4,16 @@
 namespace Constants {
   const struct
   {
-    const unsigned int width, height;
-  } field_size =  { 16, 16 },
-    map_size =    { 30, 30 },
-    map_size_pixel = { field_size.width * map_size.width,
-                       field_size.height * map_size.height};
+    const unsigned int width;
+    const unsigned int height;
+  }
+  field_size =  { 16, 16 },
+  map_size   =  { 30, 30 },
+  map_size_pixel = { field_size.width * map_size.width,
+                     field_size.height * map_size.height };
   const unsigned int sprite_margin = 2;
   const unsigned int sprite_offset = 20;
+  const unsigned int tick = 250; // ms
 }
 
 namespace Color
diff --git a/pacman-c++/mainwidget.cpp b/pacman-c++/mainwidget.cpp
index 343fe4c..399d13c 100644
--- a/pacman-c++/mainwidget.cpp
+++ b/pacman-c++/mainwidget.cpp
@@ -179,21 +179,21 @@ Transmission::map_t createDummyMap()
   
   map[15][15] |= Color::red;
   map[15][15] |= Transmission::pacman;
-  map[15][15] |= Transmission::direction_left;
+  map[15][15] |= Transmission::direction_right;
 
-  map[16][15] |= Color::blue;
+  /*map[16][15] |= Color::blue;
   map[16][15] |= Transmission::pacman;
-  map[16][15] |= Transmission::direction_left;
+  map[16][15] |= Transmission::direction_up;
 
   map[17][15] |= Color::green;
   map[17][15] |= Transmission::pacman;
-  map[17][15] |= Transmission::direction_left;
+  map[17][15] |= Transmission::direction_left;*/
 
   return map;
 }
 
 MainWidget::MainWidget()
-  : currentKey(0)
+  : m_currentKey(0)
 {
   visualMap.resize(Constants::map_size.width);
   for (int i=0; i<visualMap.size(); ++i) {
@@ -237,6 +237,7 @@ void MainWidget::createGui()
   //window->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
   //window->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
   window->setFixedSize(Constants::map_size_pixel.width, Constants::map_size_pixel.height);
+  window->setWindowFlags(window->windowFlags() & ~Qt::WindowMaximizeButtonHint);
 
   layout->addLayout(m_scoreLayout);
   layout->addWidget(window);
@@ -251,19 +252,19 @@ void MainWidget::updateScore()
   while (i.hasNext())
   {
     i.next();
-    int id = (i.key() >> 1);
-    if (id > (Color::max >> 1))
+    if (i.key() > Color::max)
     {
       /* player #4 isn't supported in score */
       Q_ASSERT(false);
       continue;
     }
+    int id = (i.key() >> 1);
     QLabel *turnPointsLbl =
       dynamic_cast<QLabel*>(m_playerScoreLayouts.at(id)->itemAtPosition(0,1)->widget());
     QLabel *allPointsLbl =
       dynamic_cast<QLabel*>(m_playerScoreLayouts.at(id)->itemAtPosition(1,1)->widget());
-    turnPointsLbl->setText(QString::number(id * 100 * qrand()));
-    allPointsLbl->setText(QString::number(id * 200 * qrand()));
+    turnPointsLbl->setText(QString::number(id));
+    allPointsLbl->setText(QString::number(id));
   }
 }
 
@@ -303,8 +304,9 @@ void MainWidget::updateMap(const Transmission::map_t& map)
         item = new BonusPoint();
       else if (cur & Transmission::pacman)
       {
-        Actor *actor = m_actors.value(color, 0);
-        if (actor == 0) { // 0 entspricht NULL ;)
+        Actor *actor = m_actors.value(color, NULL);
+        if (actor == NULL)
+        {
           //qDebug() << "new actor of col" << color;
           actor = new Actor(color);
           m_actors[color] = actor;
@@ -312,7 +314,7 @@ void MainWidget::updateMap(const Transmission::map_t& map)
           actor->setPos(mapPositionToCoord(x, y));
         }
 
-        Actor::Movement direction;
+        Actor::Movement direction = Actor::None;
         switch (cur & Transmission::direction_mask)
         {
         case Transmission::direction_none:
@@ -333,7 +335,7 @@ void MainWidget::updateMap(const Transmission::map_t& map)
         default:
           Q_ASSERT(false);
         }
-        //actor->move(direction, mapPositionToCoord(x, y);
+        //actor->move(direction, mapPositionToCoord(x, y));
       }
       else
         Q_ASSERT(false);
@@ -363,38 +365,71 @@ QPoint MainWidget::mapPositionToCoord(unsigned int x, unsigned int y)
 
 Transmission::field_t MainWidget::translateKey(int key)
 {
-  switch(key) {
-    case Qt::Key_Up:
-      return Transmission::direction_up;
-      break;
-    case Qt::Key_Down:
-      return Transmission::direction_down;
-      break;
-    case Qt::Key_Left:
-      return Transmission::direction_left;
-      break;
-    case Qt::Key_Right:
-      return Transmission::direction_right;
-      break;
-    default:
-      return 0;
+  switch(key)
+  {
+  case Qt::Key_W:
+  case Qt::Key_Up:
+    return Transmission::direction_up;
+    break;
+  case Qt::Key_S:
+  case Qt::Key_Down:
+    return Transmission::direction_down;
+    break;
+  case Qt::Key_A:
+  case Qt::Key_Left:
+    return Transmission::direction_left;
+    break;
+  case Qt::Key_D:
+  case Qt::Key_Right:
+    return Transmission::direction_right;
+    break;
+  default:
+    return 0;
   }
 }
 
 void MainWidget::keyPressEvent(QKeyEvent* event)
 {
   QWidget::keyPressEvent(event);
-  currentKey = translateKey( event->key() );
+  m_currentKey = translateKey(event->key());
+
+  // test stuff
+  Actor::Movement mov = Actor::None;
+  switch(m_currentKey)
+  {
+  case Transmission::direction_up:
+    mov = Actor::Up;
+    break;
+  case Transmission::direction_down:
+    mov = Actor::Down;
+    break;
+  case Transmission::direction_left:
+    mov = Actor::Left;
+    break;
+  case Transmission::direction_right:
+    mov = Actor::Right;
+    break;
+  default:
+    break;
+  }
+
+  QMapIterator<Color::Color, Actor*> i(m_actors);
+  while (i.hasNext())
+  {
+    i.next();
+    i.value()->move(mov);
+  }
 }
 
 void MainWidget::keyReleaseEvent(QKeyEvent* event)
 {
   QWidget::keyReleaseEvent(event);
   Transmission::field_t releasedKey = translateKey(event->key());
-  if (releasedKey == currentKey) {
+  if (releasedKey == m_currentKey)
+  {
     // current key got released
     // if this is false, a key got released which has already
     // been replaced by a different key, so this case is disregarded
-    currentKey = 0;
+    m_currentKey = Transmission::direction_none;
   }
 }
diff --git a/pacman-c++/mainwidget.h b/pacman-c++/mainwidget.h
index 951b6c6..b15427c 100644
--- a/pacman-c++/mainwidget.h
+++ b/pacman-c++/mainwidget.h
@@ -42,7 +42,7 @@ private:
   QMap<Color::Color, Actor*> m_actors;
 
   // key currently pressed by user
-  Transmission::field_t currentKey;
+  Transmission::field_t m_currentKey;
 
   // translate Qt::Key to our key format
   Transmission::field_t translateKey(int);
diff --git a/pacman-c++/pics/actor1.png b/pacman-c++/pics/actor1.png
index b1304cd..ae9f172 100644
--- a/pacman-c++/pics/actor1.png
+++ b/pacman-c++/pics/actor1.png
diff --git a/pacman-c++/pics/actor2.png b/pacman-c++/pics/actor2.png
index cac3786..07ecb3f 100644
--- a/pacman-c++/pics/actor2.png
+++ b/pacman-c++/pics/actor2.png
diff --git a/pacman-c++/pics/actor3.png b/pacman-c++/pics/actor3.png
index 99e025c..486fd37 100644
--- a/pacman-c++/pics/actor3.png
+++ b/pacman-c++/pics/actor3.png
diff --git a/pacman-c++/pics/actor4.png b/pacman-c++/pics/actor4.png
index 9947f9b..9684fc0 100644
--- a/pacman-c++/pics/actor4.png
+++ b/pacman-c++/pics/actor4.png