Blinker

@@ -151,8 +151,8 @@ void Tetris::opConnRecvKey(OpConn *pConn, char key)

   }

   /** normal keys for controlling game,

-      deactivated if dropping stone */

-  if (m_dropping) {

+      deactivated if dropping stone or rows blinking */

+  if (m_dropping || m_blinking > 0) {

     return;

   }

@@ -252,11 +252,17 @@ void Tetris::reinitialize()

   color2data(m_fileStoneColor, m_stoneColor);

   // get values

   valueFromFile(m_fileDelay, c_delayDescr, m_delay);

+  valueFromFile(m_fileDropDelay, c_dropDelayDescr, m_dropDelay);

+  valueFromFile(m_fileBlinkDelay, c_blinkDelayDescr, m_blinkDelay);

   // initialize field: empty

   m_field.clear();

   m_field.resize(m_height * m_width, -1);

+  // initialize blinking rows: no row blinking

+  m_rowsBlink.clear();

+  m_rowsBlink.resize(m_height, false);

+

   // start with new stone

   newStone();

@@ -273,14 +279,16 @@ void Tetris::redraw()

   // draw background

   rectFill(0, m_height, 0, m_width, m_backgroundColor);

-  // draw fixed pixels

+  // draw fixed pixels, respect blinking rows

   for (int y = 0, i = 0; y < m_height; ++y) {

+    if (! (m_blinking & 1) || ! m_rowsBlink.at(y)) {

       for (int x = 0; x < m_width; ++x, ++i) {

         if (m_field.at(i) >= 0) {

           pixel(y, x, m_stoneColor);

         }

       }

     }

+  }

   // draw current stone

   drawStone(m_stone, m_rot, m_posY, m_posX);

@@ -292,6 +300,43 @@ void Tetris::redraw()

 /// process next time step of game

 void Tetris::timeStep()

 {

+  // blinking of completed rows

+  if (m_blinking > 0) {

+

+    // blink rows

+    ++m_blinking;

+

+    // end of blinking -> remove blinking rows, new stone

+    if (m_blinking >= 8) {

+      // remove blinking rows

+      for (int b = 0; b < m_height; ++b) {

+        if (m_rowsBlink.at(b)) {

+          // move rows 0..b-1 one row down, i.e., to rows 1..b

+          for (int y = b, i = b * m_width + m_width - 1; y > 0; --y) {

+            for (int x = m_width - 1; x >= 0; --x, --i) {

+              m_field.at(i) = m_field.at(i - m_width);

+            }

+          }

+          // clear first row

+          for (int x = 0; x < m_width; ++x) {

+            m_field.at(x) = -1;

+          }

+          // row not blinking any more

+          m_rowsBlink.at(b) = false;

+        }

+      }

+      // blinking done

+      m_blinking = 0;

+      // new stone

+      newStone();

+    }

+

+    // redraw image and send frame

+    redraw();

+

+  // falling stone

+  } else {

+

     // stone can move down by one pixel

     if (checkStoneFit(m_stone, m_rot, m_posY + 1, m_posX)) {

       // move stone down by one pixel

@@ -305,17 +350,50 @@ void Tetris::timeStep()

       // add stone permanently to field at current position

       freezeStone(m_stone, m_rot, m_posY, m_posX);

       drawStone(m_stone, m_rot, m_posY, m_posX); // TODO: frozen color

-    // prepare new stone

-    newStone();

+      // no current stone any more

+      m_stone = -1;

+      // check for completed rows, (afterwards: new stone)

+      checkComplete();

     }

     // send updated image buffer as frame

     sendFrame();

+  } // falling stone

+

   // request next time step

   planTimeStep();

 }

+/// check for completed rows to disappear (new stone afterwards)

+void Tetris::checkComplete()

+{

+  // collect y coordinated of completed rows -> m_rowsBlink

+  bool blink = false;

+  for (int y = 0, i = 0; y < m_height; ++y) {

+    bool complete = true;

+    for (int x = 0; x < m_width; ++x, ++i) {

+      if (m_field.at(i) < 0) {

+        complete = false;

+      }

+    }

+    m_rowsBlink.at(y) = complete;

+    if (complete) {

+      blink = true;

+    }

+  }

+

+  // no completed rows -> new stone

+  if (! blink) {

+    newStone();

+  }

+

+  // start blinking (start with rows visible, last bit == 0)

+  else {

+    m_blinking = 2;

+  }

+}

+

 /// set up a new stone

 void Tetris::newStone()

 {

@@ -121,6 +121,9 @@ protected:

   /// process next time step of game

   virtual void timeStep();

+  /// check for completed rows to disappear (new stone afterwards)

+  void checkComplete();

+

   /// set up a new stone

   void newStone();

@@ -181,12 +184,12 @@ protected:

   int   m_posX;     ///< x position of current stone

   int   m_posY;     ///< y position of current stone

   bool  m_dropping; ///< whether currently dropping a stone

-  int   m_blinking; ///< step of blinking: 0 not blinking

+  int   m_blinking; ///< step of blinking: 0 not blinking, lsb == 0 -> visible

   /// tetris field (y * m_width + x), -1 for free, >= 0 for pixel from stone

   std::vector<int> m_field;

-  /// sorted y indices of rows that are currently blinking

-  std::vector<int> m_rowsBlink;

+  /// rows that are currently blinking (bool for each row, true when blinking)

+  std::vector<bool> m_rowsBlink;

 }; // class Tetris

 } // namespace Blinker