Subversion Repositories layer2

/******************************************************************************

 * Tennmino Version 0.1                                                       *

 ******************************************************************************

 * Copyright (C)2011  Mathias Hörtnagl <mathias.hoertnagl@gmail.com>          *

 *                                                                            *

 * This program is free software: you can redistribute it and/or modify       *

 * it under the terms of the GNU General Public License as published by       *

 * the Free Software Foundation, either version 3 of the License, or          *

 * (at your option) any later version.                                        *

 *                                                                            *

 * This program is distributed in the hope that it will be useful,            *

 * but WITHOUT ANY WARRANTY; without even the implied warranty of             *

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *

 * GNU General Public License for more details.                               *

 *                                                                            *

 * You should have received a copy of the GNU General Public License          *

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.      *

 ******************************************************************************/

#include "tiles.h"

/* The current tile. */

static Tile tile;

/* The state of the move. Can be either

      MOVE_CONTINUE when everything is okay to move or

      MOVE_BLOCKED  when the tile can not move down anymore. */

static uchar moveState = MOVE_CONTINUE;

/* The sequences of each tile

   A tile is represented by a 16bit unsigned number. Every 4bit represent a

   line of the 4x4 tile starting on the top. */

static ushort seq[7][4] = {

   {0x4444, 0x00f0, 0x4444, 0x00f0},   /* I */

   {0x0e20, 0x6440, 0x8e00, 0x44c0},   /* J */

   {0x02e0, 0x6220, 0xe800, 0x88c0},   /* L */

   {0x0660, 0x0660, 0x0660, 0x0660},   /* O */

   {0x0e40, 0x4c40, 0x4e00, 0x4640},   /* T */

   {0x06c0, 0x4620, 0x06c0, 0x4620},   /* S */

   {0x0c60, 0x2640, 0x0c60, 0x2640}    /* Z */

};

/******************************************************************************

 * Reading VGA RAM                                                            *

 ******************************************************************************/

/* Read contetnts of the VGA RAM at location (x,y). */

uchar getVGAContents(uchar x, uchar y) {

   return (VGA_MEMORY[ VGA_POS(x, y) ] & 0xff);

}

/* Read a 4x4 area of the VGA RAM starting at loaction (x,y). */

uint getVGAMask(uchar x, uchar y) {

   uint mask = 0;

   for(uchar i=0; i < 4; i++) {

      for(uchar j=0; j < 8; j+=2) {

         if( getVGAContents(x + j, y + i) == CHR_FULL )

            mask |= 1;

         mask <<= 1;

      }

   }

   return mask >> 1; // Shifting happens once too often.

}

/******************************************************************************

 * Tile Placement                                                             *

 ******************************************************************************/

/* Initialize a tile at te top of the board. */

void initTile(uchar type) {

   tile.type = type;

   tile.tile = seq[type][0];

   tile.ridx = 0;

   tile.pos.x = VGA_H/2 - 2;     // Center tile horizontally.

   tile.pos.y = 0;

   drawTile();

}

/* Print the current tile either visible or invisible to erase it from the

   screen. */

void printTile(uchar chr) {

   ushort pos;

   ushort mask = 0x8000;

   for(uchar i=0; i < 4; i++) {

      for(uchar j=0; j < 8; j+=2) {

         if(tile.tile & mask) {

            pos = VGA_POS(tile.pos.x + j, tile.pos.y + i);

            VGA_MEMORY[pos] = VGA_CHR(tile.type + 1, BLACK, chr);

            VGA_MEMORY[++pos] = VGA_CHR(tile.type + 1, BLACK, chr);

         }

         mask >>= 1;

      }

   }

}

/******************************************************************************

 * Tile Movement                                                              *

 ******************************************************************************/

/* Rotate the tile if its new rotation does not interfere with already present

   tiles or the game board. */

void rotate() {

   ushort mask;

   uchar ridx;

   ushort rtile;

   eraseTile();

   mask = (ushort) getVGAMask(tile.pos.x, tile.pos.y);

   ridx = ++tile.ridx & 3;              // Mod 4 counter.   

   rtile = seq[tile.type][ridx];

   // See if the rotated tile and the area share occupied blocks. 

   if(mask & rtile) {

      // If true we can not accept the rotation of the tile. Instead

      // draw the original tile once more.     

      moveState = MOVE_BLOCKED;

   }

   else {

      tile.ridx = ridx;

      tile.tile = rtile;

      moveState = MOVE_CONTINUE;

   }

   drawTile();

}

/* Move in any direction and check if the tile does not interfere with already

   present tiles or the borders of the game board. */

void move(char x, char y) {

   ushort mask;

   eraseTile();

   // Grab the area for the tiles next position. The old tile is erased and 

   // won't interfere with the match.

   mask = (ushort) getVGAMask(tile.pos.x + x, tile.pos.y + y);

   // See if the tile and the area share occupied blocks. 

   if(mask & tile.tile) {

      // If true we can not continue with the movement of the tile. Instead

      // draw the tile at the old position once more and change moveState.     

      moveState = MOVE_BLOCKED;

   }

   else {

      tile.pos.x += x;

      tile.pos.y += y;

      moveState = MOVE_CONTINUE;

   }

   drawTile();

}

/******************************************************************************

 * Game State                                                                 *

 ******************************************************************************/

/* Return the current game state. Can be either

      GAME_CONTINUE if the game can continue without further processing.

      GAME_NEW_TILE if the current tile is stuck and a new tile needs to be

                    initialized.

      GAME_OVER     if the current tile can not move down from the beginning.

 */

uchar getGameState() {

   switch(moveState) {

      case MOVE_BLOCKED:

         return (tile.pos.y == 0) ? GAME_OVER : GAME_NEW_TILE;

      default:

         return GAME_CONTINUE;

         break;

   }

}

/******************************************************************************

 * Deletion of Lines                                                          *

 ******************************************************************************/

/* Deletes one complete row and scrolls down the remaining board. */

uchar deleteCompletedRow(uchar x, uchar y, uchar w) {

   ushort pos = VGA_POS(x, y);

   for(uchar i=0; i<w; i++){

      if( (VGA_MEMORY[pos + i] & 0xff) != CHR_FULL )

         return 0;

   }

   for(uchar j = y; j>0; j--)

      for(uchar i=0; i<w; i++)

         VGA_MEMORY[VGA_POS( (x+i), j )] = VGA_MEMORY[VGA_POS( (x+i), (j-1) )];

   return 1;

}

/* Deletes up to four complete rows and scrolls down acordingly. Returns the

   number of deleted rows. For x deleted lines return

      1  ...   128 points

      2  ...   256 points

      3  ...   512 points

      4  ...  1024 points

 */

uint deleteCompletedRows(uchar x, uchar w) {

   uchar cnt = 0;

   for(uchar i=0; i<4; i++) {

      // Empty tile lines do not change anything. 

      if( tile.tile & (0xf000 >> (i*4)) )

         cnt += deleteCompletedRow(x, tile.pos.y + i, w);

   }

   return (cnt << 7);

}