Blinker

@@ -138,7 +138,59 @@ void Tetris::opConnRecvKey(OpConn *pConn, char key)

   // normal keys for controlling game

+  // move left

+  if (key == '4') {

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

+      wipeStone(m_stone, m_rot, m_posY, m_posX);

+      m_posX -= 1;

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

+    }

+    return;

+  }

+

+  // move right

+  if (key == '6') {

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

+      wipeStone(m_stone, m_rot, m_posY, m_posX);

+      m_posX += 1;

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

+    }

+    return;

+  }

+

+  // rotate left

+  if (key == '1') {

+    int new_rot = m_rot - 1;

+    if (new_rot < 0) {

+      new_rot = c_rotCnt - 1;

+    }

+    if (checkStoneFit(m_stone, new_rot, m_posY, m_posX)) {

+      wipeStone(m_stone, m_rot, m_posY, m_posX);

+      m_rot = new_rot;

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

+    }

+    return;

+  }

+

+  // rotate right

+  if (key == '2' || key == '3') {

+    int new_rot = m_rot + 1;

+    if (new_rot >= c_rotCnt) {

+      new_rot = 0;

+    }

+    if (checkStoneFit(m_stone, new_rot, m_posY, m_posX)) {

+      wipeStone(m_stone, m_rot, m_posY, m_posX);

+      m_rot = new_rot;

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

+    }

+    return;

+  }

+

+  // drop stone

+  if (key == '8') {

     // TODO

+    return;

+  }

 }

 /**

@@ -217,13 +269,22 @@ void Tetris::redraw()

 /// process next time step of game

 void Tetris::timeStep()

 {

-  // FIXME

-  if (m_posY >= m_height + 2) {

-    newStone();

-  }

+  // stone can move down by one pixel

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

+    // move stone down by one pixel

     wipeStone(m_stone, m_rot, m_posY, m_posX);

     m_posY += 1;

-  drawStone(m_stone, m_rot, m_posY, m_posX);

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

+  }

+

+  // stone cannot move down by one pixel

+  else {

+    // 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();

+  }

   // send updated image buffer as frame

   sendFrame();

@@ -262,33 +323,65 @@ void Tetris::planTimeStep()

   setTimeStep(Time::now() + stepTime);

 }

+/// get rotatation of stone from stone/rotation index (or NULL in invalid)

+Tetris::RotStone const * Tetris::getRotStone(int stone, int rot)

+{

+  if (! checkLimitInt(stone, 0, c_stoneCnt -1) ||

+      ! checkLimitInt(rot, 0, c_rotCnt - 1)) {

+    return NULL; // invalid stone or rotation

+  }

+  return &c_stones[stone].rot[rot];

+}

+

 /// check if stone fits at position

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

 {

   // get rotation of stone

-  if (! checkLimitInt(stone, 0, c_stoneCnt -1) ||

-      ! checkLimitInt(rot, 0, c_rotCnt - 1)) {

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

+  if (! rotStone) {

     return false; // invalid stone or rotation -> does not fit

   }

-  RotStone const &rotStone = c_stones[stone].rot[rot];

   // check pixels

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

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

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

-    if (py >= m_height - 1 || ! checkLimitInt(px, 0, m_width - 1)) {

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

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

+    if (py > m_height - 1 || ! checkLimitInt(px, 0, m_width - 1)) {

       return false; // outside field (except at top) -> does not fit

     }

+    if (py >= 0) { // do not check above top

       int pi = py * m_width + px;

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

         return false; // occupixed pixel -> does not fit

       }

     }

+  }

   // all checks passed -> stone fits

   return true;

 }

+/// freeze stone to field at position

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

+{

+  // get rotation of stone

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

+  if (! rotStone) {

+    return; // invalid stone or rotation -> nothing to do

+  }

+

+  // add pixels to field

+  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)) {

+      int pi = py * m_width + px;

+      m_field.at(pi) = stone; // mark pixel in field with stone index

+    }

+  }

+}

+

 /// draw a stone to image buffer

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

 {

@@ -306,15 +399,14 @@ void Tetris::colorStone(int stone, int rot, int y, int x,

                         ColorData const &color)

 {

   // get rotation of stone

-  if (! checkLimitInt(stone, 0, c_stoneCnt -1) ||

-      ! checkLimitInt(rot, 0, c_rotCnt - 1)) {

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

+  if (! rotStone) {

     return; // invalid stone or rotation -> nothing to do

   }

-  RotStone const &rotStone = c_stones[stone].rot[rot];

   // color pixels

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

-    pixel(y + rotStone.pixels[p].y, x + rotStone.pixels[p].x, color);

+    pixel(y + rotStone->pixels[p].y, x + rotStone->pixels[p].x, color);

   }

 }

@@ -382,7 +474,7 @@ int const Tetris::c_pixelCnt = sizeof(Tetris::RotStone::pixels) /

                                sizeof(Tetris::RotStone::pixels[0]);

 /// descriptor for delay value

-Tetris::ValueDescr const Tetris::c_delayDescr = { 200, 100, 500 };

+Tetris::ValueDescr const Tetris::c_delayDescr = { 400, 200, 1000 };

 } // namespace Blinker

@@ -127,9 +127,15 @@ protected:

   /// set time for next time step of game - or unset if not needed

   void planTimeStep();

+  /// get rotatation of stone from stone/rotation index (or NULL in invalid)

+  static RotStone const * getRotStone(int stone, int rot);

+

   /// check if stone fits at position

   bool checkStoneFit(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);

+

   /// draw a stone to image buffer

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