Blinker

@@ -0,0 +1 @@

+2000

@@ -0,0 +1 @@

+gameover

@@ -0,0 +1 @@

+yeah

@@ -40,14 +40,18 @@ Tetris::Tetris(const std::string &name, Mgrs &mgrs, const Directory &dirBase):

   m_fileDelay(dirBase.getFile("delay")),

   m_fileDropDelay(dirBase.getFile("dropDelay")),

   m_fileBlinkDelay(dirBase.getFile("blinkDelay")),

+  m_fileGameOverDelay(dirBase.getFile("gameOverDelay")),

   m_fileStartSound(dirBase.getFile("startSound")),

+  m_fileRowCompleteSound(dirBase.getFile("rowCompleteSound")),

+  m_fileGameOverSound(dirBase.getFile("gameOverSound")),

   m_stoneColor(),

   m_delay(c_delayDescr.default_),

   m_dropDelay(c_dropDelayDescr.default_),

   m_blinkDelay(c_blinkDelayDescr.default_),

+  m_gameOverDelay(c_gameOverDelayDescr.default_),

   m_pConn(NULL),

   m_stone(-1), m_rot(-1), m_posX(-1), m_posY(-1),

-  m_dropping(false), m_blinking(0),

+  m_dropping(false), m_blinking(0), m_completed(0), m_gameOver(0),

   m_field(), m_rowsBlink()

 {

   // open operator connection interfaces for player

@@ -86,9 +90,15 @@ bool Tetris::updateConfigGame()

   if (valueUpdate(m_fileBlinkDelay, c_blinkDelayDescr, m_blinkDelay)) {

     ret = true;

   }

+  if (valueUpdate(m_fileGameOverDelay, c_gameOverDelayDescr,

+                  m_gameOverDelay)) {

+    ret = true;

+  }

   // sound name file was modified -> re-read sound name, no other update needed

   soundUpdate(m_fileStartSound);

+  soundUpdate(m_fileRowCompleteSound);

+  soundUpdate(m_fileGameOverSound);

   return ret;

 }

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

   }

   /** normal keys for controlling game,

-      deactivated if dropping stone or rows blinking */

-  if (m_dropping || m_blinking > 0) {

+      deactivated if dropping stone, rows blinking or end of game */

+  if (m_dropping || m_blinking > 0 || m_gameOver > 0) {

     return;

   }

@@ -254,6 +264,7 @@ void Tetris::reinitialize()

   valueFromFile(m_fileDelay, c_delayDescr, m_delay);

   valueFromFile(m_fileDropDelay, c_dropDelayDescr, m_dropDelay);

   valueFromFile(m_fileBlinkDelay, c_blinkDelayDescr, m_blinkDelay);

+  valueFromFile(m_fileGameOverDelay, c_gameOverDelayDescr, m_gameOverDelay);

   // initialize field: empty

   m_field.clear();

@@ -263,6 +274,11 @@ void Tetris::reinitialize()

   m_rowsBlink.clear();

   m_rowsBlink.resize(m_height, false);

+  // no rows blinking or completed, game not over yet

+  m_blinking = 0;

+  m_completed = 0;

+  m_gameOver = 0;

+

   // start with new stone

   newStone();

@@ -300,9 +316,43 @@ void Tetris::redraw()

 /// process next time step of game

 void Tetris::timeStep()

 {

+  // count time at end of game

+  if (m_gameOver > 0) {

+    timeGameOver();

   // blinking of completed rows

-  if (m_blinking > 0) {

+  } else if (m_blinking > 0) {

+    timeBlinkRows();

+  // falling stone

+  } else {

+    timeStone();

+  }

+

+  // request next time step

+  planTimeStep();

+}

+

+/// count time at end of game

+void Tetris::timeGameOver()

+{

+  // count time

+  ++m_gameOver;

+  // terminate game after some time

+  if (m_gameOver >= 8) {

+    // close operator connection

+    if (m_pConn) {

+      forgetOpConn(m_pConn); // remove from requests (if it was in)

+      m_pConn->close();

+      m_pConn = NULL;

+    }

+    // deactivate game

+    deactivate();

+  }

+}

+

+/// blink completed rows

+void Tetris::timeBlinkRows()

+{

   // blink rows

   ++m_blinking;

@@ -333,10 +383,11 @@ void Tetris::timeStep()

   // redraw image and send frame

   redraw();

+}

-  // falling stone

-  } else {

-

+/// falling stone

+void Tetris::timeStone()

+{

   // stone can move down by one pixel

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

     // move stone down by one pixel

@@ -350,19 +401,27 @@ 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

+

+    // overflow of game field -> game over

+    if (checkStoneOverflow(m_stone, m_rot, m_posY, m_posX)) {

+      // unset stone

+      m_stone = -1;

+      // game over

+      m_gameOver = 1;

+      playOpConnSound(m_pConn, m_fileGameOverSound);

+    }

+

+    // no overflow

+    else {

       // 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)

@@ -391,6 +450,7 @@ void Tetris::checkComplete()

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

   else {

     m_blinking = 2;

+    playOpConnSound(m_pConn, m_fileRowCompleteSound);

   }

 }

@@ -420,12 +480,17 @@ void Tetris::planTimeStep()

   // compute interval based on game state

   int interval_ms = m_delay;

-  if (m_dropping) {

-    interval_ms = m_dropDelay;

+  int speedup = m_completed;

+  if (m_gameOver > 0) {

+    interval_ms = m_gameOverDelay;

+    speedup = 0;

   } else if (m_blinking > 0) {

     interval_ms = m_blinkDelay;

+  } else if (m_dropping) {

+    interval_ms = m_dropDelay;

   }

-  float interval = 1e-3f * interval_ms;

+  float scale = 0.3f + 0.7f * expf(-0.3f * speedup);

+  float interval = 1e-3f * interval_ms * scale;

   // request next time call

   Time stepTime;

@@ -471,6 +536,29 @@ bool Tetris::checkStoneFit(int stone, int rot, int y, int x) const

   return true;

 }

+/// check if stone overflow game field

+bool Tetris::checkStoneOverflow(int stone, int rot, int y, int x) const

+{

+  // get rotation of stone

+  RotStone const *rotStone = getRotStone(stone, rot);

+  if (! rotStone) {

+    return true; // invalid stone or rotation -> overflow

+  }

+

+  // check pixels for overflow

+  for (int p = 0; p < c_pixelCnt; ++p) {

+    int py = y + rotStone->pixels[p].y;

+    int px = x + rotStone->pixels[p].x;

+    if (! checkLimitInt(py, 0, m_height -1) ||

+        ! checkLimitInt(px, 0, m_width - 1)) {

+      return true; // outside field (including top) -> overflow

+    }

+  }

+

+  // all checks passed -> no overflow

+  return false;

+}

+

 /// freeze stone to field at position

 void Tetris::freezeStone(int stone, int rot, int y, int x)

 {

@@ -592,5 +680,8 @@ Tetris::ValueDescr const Tetris::c_dropDelayDescr = { 100, 50, 250 };

 /// descriptor for delay value during blinking of disappearing rows

 Tetris::ValueDescr const Tetris::c_blinkDelayDescr = { 50, 50, 250 };

+/// descriptor for delay value at end of game

+Tetris::ValueDescr const Tetris::c_gameOverDelayDescr = { 2000, 100, 5000 };

+

 } // namespace Blinker

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

   /// process next time step of game

   virtual void timeStep();

+  /// count time at end of game

+  void timeGameOver();

+

+  /// blink completed rows

+  void timeBlinkRows();

+

+  /// falling stone

+  void timeStone();

+

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

   void checkComplete();

@@ -136,6 +145,9 @@ protected:

   /// check if stone fits at position

   bool checkStoneFit(int stone, int rot, int y, int x) const;

+  /// check if stone overflow game field

+  bool checkStoneOverflow(int stone, int rot, int y, int x) const;

+

   /// freeze stone to field at position

   void freezeStone(int stone, int rot, int y, int x);

@@ -165,17 +177,24 @@ protected:

   /// descriptor for delay value during blinking of disappearing rows

   static ValueDescr const c_blinkDelayDescr;

+  /// descriptor for delay value at end of game

+  static ValueDescr const c_gameOverDelayDescr;

+

   ColorFile m_fileStoneColor;    ///< color file for stone color

   UIntFile  m_fileDelay;         ///< file for initial delay in ms per frame

   UIntFile  m_fileDropDelay;     ///< file for delay while dropping (ms/frame)

   UIntFile  m_fileBlinkDelay;    ///< file for delay while blinking (ms/frame)

+  UIntFile  m_fileGameOverDelay; ///< file for delay at end (ms/frame)

   NameFile m_fileStartSound;       ///< "start game" sound name file

+  NameFile m_fileRowCompleteSound; ///< "row complete" sound name file

+  NameFile m_fileGameOverSound;    ///< "game over" sound name file

   ColorData    m_stoneColor;    ///< stone color

   unsigned int m_delay;         ///< initial delay in ms per frame

   unsigned int m_dropDelay;     ///< delay while dropping in ms per frame

-  unsigned int m_blinkDelay; ///< delay while rwos blinking in ms per frame

+  unsigned int m_blinkDelay;    ///< delay while rows blinking in ms per frame

+  unsigned int m_gameOverDelay; ///< delay at end of game in ms per frame

   OpConn *m_pConn; ///< operator connection of player (or NULL)

@@ -185,6 +204,8 @@ protected:

   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, lsb == 0 -> visible

+  int   m_completed; ///< number of overall completed rows

+  int   m_gameOver;  ///< counter at end of game: 0 means game is running

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

   std::vector<int> m_field;