#include "camera_info.h"
#include "keyboard.h"
#include "clock.h"
#include "backlight.h"
#include "lang.h"
#include "gui.h"
#include "gui_draw.h"
#include "gui_lang.h"
#include "gui_batt.h"
#include "gui_mbox.h"
#include "modes.h"
#include "time.h"
#include "module_def.h"
#include "simple_game.c"

Include-Abhängigkeitsdiagramm für gui_tetris.c:

Datenstrukturen
struct	StcTetramino

struct	StcGame

Makrodefinitionen
#define	BOARD_WIDTH (10)

#define	BOARD_HEIGHT (22)

#define	INI_DELAY_FALL (540)

#define	SCORE_1_FILLED_ROW (40)

#define	SCORE_2_FILLED_ROW (100)

#define	SCORE_3_FILLED_ROW (300)

#define	SCORE_4_FILLED_ROW (1200)

#define	FILLED_ROWS_FOR_LEVEL_UP (10)

#define	DELAY_FACTOR_FOR_LEVEL_UP (0.9)

#define	GAME_ERROR_NONE (0) /* Everything is OK, oh wonders! */

#define	GAME_ERROR_USER_QUITS (1) /* The user quits (bored?), our fail */

#define	GAME_ERROR_NO_MEMORY (-1) /* Not enough memory */

#define	GAME_ERROR_NO_VIDEO (-2) /* Video system was not initialized */

#define	GAME_ERROR_NO_IMAGES (-3) /* Problem loading the image files */

#define	GAME_ERROR_ASSERT (-100) /* Something went very very wrong... */

#define	EVENT_NONE (0)

#define	EVENT_MOVE_DOWN (1 << 1)

#define	EVENT_MOVE_LEFT (1 << 2)

#define	EVENT_MOVE_RIGHT (1 << 3)

#define	EVENT_ROTATE_CW (1 << 4) /* rotate clockwise */

#define	EVENT_ROTATE_CCW (1 << 5) /* rotate counter-clockwise */

#define	EVENT_DROP (1 << 6)

#define	EVENT_PAUSE (1 << 7)

#define	EVENT_RESTART (1 << 8)

#define	EVENT_SHOW_NEXT (1 << 9) /* toggle show next tetromino */

#define	TETROMINO_I (0)

#define	TETROMINO_O (1)

#define	TETROMINO_T (2)

#define	TETROMINO_S (3)

#define	TETROMINO_Z (4)

#define	TETROMINO_J (5)

#define	TETROMINO_L (6)

#define	TETRIS_COLOR_CYAN COLOR_CYAN

#define	TETRIS_COLOR_RED COLOR_RED

#define	TETRIS_COLOR_BLUE COLOR_BLUE

#define	TETRIS_COLOR_ORANGE COLOR_WHITE

#define	TETRIS_COLOR_GREEN COLOR_GREEN

#define	TETRIS_COLOR_YELLOW COLOR_YELLOW

#define	TETRIS_COLOR_PURPLE COLOR_MAGENTA

#define	EMPTY_CELL (-1)

#define	TETRIS_COLOR_BG COLOR_GREY_DK

#define	TETRIS_COLOR_BOARD COLOR_GREY

#define	TETRIS_COLOR_TEXT COLOR_WHITE

#define	PREVIEW_X (tile_size*15)

#define	PREVIEW_Y (tile_size)

#define	BOARD_X (tile_size)

#define	BOARD_Y (tile_size)

#define	TILE_SIZE (tile_size)

Typdefinitionen
typedef struct StcTetramino	StcTetramino

typedef struct StcPlatform	StcPlatform

typedef struct StcGame	StcGame

Funktionen
void	gui_game_menu_kbd_process ()

int	gui_tetris_kbd_process ()

void	gui_tetris_draw ()

StcGame *	createGame ()

void	deleteGame (StcGame *pGame)

int	gameInit (StcGame *gameInstance)

void	gameEnd ()

void	gameUpdate (StcGame *gameInstance)

long	mkdir_if_not_exist (const char *dirname)

int	platformInit ()

void	platformEnd ()

void	platformReadInput ()

void	platformRenderGame ()

long	platformGetSystemTime ()

static void	setMatrixCells (int *matrix, int width, int height, int value)

static void	setTetramino (int indexTetramino, StcTetramino *tetramino)

static void	startGame (StcGame *game)

void	rotateTetramino (StcGame *game, int clockwise)

static int	checkCollision (StcGame *game, int dx, int dy)

static void	onFilledRows (StcGame *game, int filledRows)

static void	moveTetramino (StcGame *game, int x, int y)

static void	dropTetramino (StcGame *game)

void	gui_tetris_init ()

int	basic_module_init ()

Variablen
gui_handler	GUI_MODE_TETRIS

StcGame *	game = 0

int	tile_size

int	tmp [BOARD_WIDTH][BOARD_HEIGHT]

int	tmp2 [BOARD_WIDTH][BOARD_HEIGHT]

int	prevNextBlockType = -1

ModuleInfo	_module_info

Makro-Dokumentation

#define BOARD_HEIGHT (22)

Definiert in Zeile 24 der Datei gui_tetris.c.

#define BOARD_WIDTH (10)

Definiert in Zeile 23 der Datei gui_tetris.c.

#define BOARD_X (tile_size)

Definiert in Zeile 137 der Datei gui_tetris.c.

#define BOARD_Y (tile_size)

Definiert in Zeile 138 der Datei gui_tetris.c.

#define DELAY_FACTOR_FOR_LEVEL_UP (0.9)

Definiert in Zeile 35 der Datei gui_tetris.c.

#define EMPTY_CELL (-1)

Definiert in Zeile 70 der Datei gui_tetris.c.

#define EVENT_DROP (1 << 6)

Definiert in Zeile 50 der Datei gui_tetris.c.

#define EVENT_MOVE_DOWN (1 << 1)

Definiert in Zeile 45 der Datei gui_tetris.c.

#define EVENT_MOVE_LEFT (1 << 2)

Definiert in Zeile 46 der Datei gui_tetris.c.

#define EVENT_MOVE_RIGHT (1 << 3)

Definiert in Zeile 47 der Datei gui_tetris.c.

#define EVENT_NONE (0)

Definiert in Zeile 44 der Datei gui_tetris.c.

#define EVENT_PAUSE (1 << 7)

Definiert in Zeile 51 der Datei gui_tetris.c.

#define EVENT_RESTART (1 << 8)

Definiert in Zeile 52 der Datei gui_tetris.c.

#define EVENT_ROTATE_CCW (1 << 5) /* rotate counter-clockwise */

Definiert in Zeile 49 der Datei gui_tetris.c.

#define EVENT_ROTATE_CW (1 << 4) /* rotate clockwise */

Definiert in Zeile 48 der Datei gui_tetris.c.

#define EVENT_SHOW_NEXT (1 << 9) /* toggle show next tetromino */

Definiert in Zeile 53 der Datei gui_tetris.c.

#define FILLED_ROWS_FOR_LEVEL_UP (10)

Definiert in Zeile 33 der Datei gui_tetris.c.

#define GAME_ERROR_ASSERT (-100) /* Something went very very wrong... */

Definiert in Zeile 42 der Datei gui_tetris.c.

#define GAME_ERROR_NO_IMAGES (-3) /* Problem loading the image files */

Definiert in Zeile 41 der Datei gui_tetris.c.

#define GAME_ERROR_NO_MEMORY (-1) /* Not enough memory */

Definiert in Zeile 39 der Datei gui_tetris.c.

#define GAME_ERROR_NO_VIDEO (-2) /* Video system was not initialized */

Definiert in Zeile 40 der Datei gui_tetris.c.

#define GAME_ERROR_NONE (0) /* Everything is OK, oh wonders! */

Definiert in Zeile 37 der Datei gui_tetris.c.

#define GAME_ERROR_USER_QUITS (1) /* The user quits (bored?), our fail */

Definiert in Zeile 38 der Datei gui_tetris.c.

#define INI_DELAY_FALL (540)

Definiert in Zeile 26 der Datei gui_tetris.c.

#define PREVIEW_X (tile_size*15)

Definiert in Zeile 135 der Datei gui_tetris.c.

#define PREVIEW_Y (tile_size)

Definiert in Zeile 136 der Datei gui_tetris.c.

#define SCORE_1_FILLED_ROW (40)

Definiert in Zeile 28 der Datei gui_tetris.c.

#define SCORE_2_FILLED_ROW (100)

Definiert in Zeile 29 der Datei gui_tetris.c.

#define SCORE_3_FILLED_ROW (300)

Definiert in Zeile 30 der Datei gui_tetris.c.

#define SCORE_4_FILLED_ROW (1200)

Definiert in Zeile 31 der Datei gui_tetris.c.

#define TETRIS_COLOR_BG COLOR_GREY_DK

Definiert in Zeile 72 der Datei gui_tetris.c.

#define TETRIS_COLOR_BLUE COLOR_BLUE

Definiert in Zeile 65 der Datei gui_tetris.c.

#define TETRIS_COLOR_BOARD COLOR_GREY

Definiert in Zeile 73 der Datei gui_tetris.c.

#define TETRIS_COLOR_CYAN COLOR_CYAN

Definiert in Zeile 63 der Datei gui_tetris.c.

#define TETRIS_COLOR_GREEN COLOR_GREEN

Definiert in Zeile 67 der Datei gui_tetris.c.

#define TETRIS_COLOR_ORANGE COLOR_WHITE

Definiert in Zeile 66 der Datei gui_tetris.c.

#define TETRIS_COLOR_PURPLE COLOR_MAGENTA

Definiert in Zeile 69 der Datei gui_tetris.c.

#define TETRIS_COLOR_RED COLOR_RED

Definiert in Zeile 64 der Datei gui_tetris.c.

#define TETRIS_COLOR_TEXT COLOR_WHITE

Definiert in Zeile 74 der Datei gui_tetris.c.

#define TETRIS_COLOR_YELLOW COLOR_YELLOW

Definiert in Zeile 68 der Datei gui_tetris.c.

#define TETROMINO_I (0)

Definiert in Zeile 55 der Datei gui_tetris.c.

#define TETROMINO_J (5)

Definiert in Zeile 60 der Datei gui_tetris.c.

#define TETROMINO_L (6)

Definiert in Zeile 61 der Datei gui_tetris.c.

#define TETROMINO_O (1)

Definiert in Zeile 56 der Datei gui_tetris.c.

#define TETROMINO_S (3)

Definiert in Zeile 58 der Datei gui_tetris.c.

#define TETROMINO_T (2)

Definiert in Zeile 57 der Datei gui_tetris.c.

#define TETROMINO_Z (4)

Definiert in Zeile 59 der Datei gui_tetris.c.

#define TILE_SIZE (tile_size)

Definiert in Zeile 139 der Datei gui_tetris.c.

Dokumentation der benutzerdefinierten Typen

typedef struct StcGame StcGame

typedef struct StcPlatform StcPlatform

Definiert in Zeile 84 der Datei gui_tetris.c.

typedef struct StcTetramino StcTetramino

Dokumentation der Funktionen

int basic_module_init ( )

Definiert in Zeile 792 der Datei gui_tetris.c.

 {
     gui_set_mode(&GUI_MODE_TETRIS);
     gui_tetris_init();
     return 1;
 }

static int checkCollision	(	StcGame *	game,
		int	dx,
		int	dy
	)

static

Definiert in Zeile 484 der Datei gui_tetris.c.

 {
     int newx, newy, i, j;
 
     newx = game->fallingBlock.x + dx;
     newy = game->fallingBlock.y + dy;
 
     for (i = 0; i < game->fallingBlock.size; ++i)
     {
         for (j = 0; j < game->fallingBlock.size; ++j)
         {
             if (game->fallingBlock.cells[i][j] != EMPTY_CELL)
             {
                 /* Check the tetramino would be inside the left, right and bottom borders */
                 if ((newx + i < 0) || (newx + i >= BOARD_WIDTH) || (newy + j >= BOARD_HEIGHT))
                 {
                     return 1;
                 }
                 /* Check the tetromino won't collide with existing cells in the map */
                 if (game->map[newx + i][newy + j] != EMPTY_CELL)
                 {
                     return 1;
                 }
             }
         }
     }
     return 0;
 }

StcGame * createGame ( )

Definiert in Zeile 383 der Datei gui_tetris.c.

 {
     /* Allocate space for our game object */
     StcGame *game = (StcGame *) malloc(sizeof(StcGame));
     return game;
 }

void deleteGame ( StcGame * pGame)

Definiert in Zeile 412 der Datei gui_tetris.c.

 {
     free(game);
 }

static void dropTetramino ( StcGame * game)

static

Definiert in Zeile 649 der Datei gui_tetris.c.

 {
     int y;
     y = 1;
     /* Calculate number of cells to drop */
     while (!checkCollision(game, 0, y))
     {
         y++;
     }
     moveTetramino(game, 0, y - 1);
 }

void gameEnd ( )

Definiert in Zeile 406 der Datei gui_tetris.c.

 {
     /* Free platform resources */
     platformEnd();
 }

int gameInit ( StcGame * gameInstance)

Definiert in Zeile 393 der Datei gui_tetris.c.

 {
     int errorCode;
 
     errorCode = platformInit();
     if (errorCode == GAME_ERROR_NONE)
     {
         startGame(game);
         return GAME_ERROR_NONE;
     }
     return errorCode;
 };

void gameUpdate ( StcGame * gameInstance)

Definiert in Zeile 664 der Datei gui_tetris.c.

 {
     long sysTime;
 
     if (!game)
     {
         return;
     }
 
     /* Read user input */
     platformReadInput();
 
     /* Update game state */
     if (game->isOver)
     {
 
         if (game->stats.score > game->stats.high)
         {
             game->stats.high = game->stats.score;
             FILE * f;
             long buf;
             buf = game->stats.score;
 
             mkdir_if_not_exist("A/CHDK/GAMES");
             f = fopen("A/CHDK/GAMES/TETRIS.SCO", "wb");
             fwrite(&buf, 1, sizeof(buf), f);
             fclose(f);
         }
 
         //if (game->events & EVENT_RESTART) {
         if (game->events & EVENT_PAUSE)
         {
 
             //TurnOnBackLight();
 
             game->isOver = 0;
             startGame(game);
 
         }
     }
     else
     {
         sysTime = platformGetSystemTime();
 
         /* Always handle pause event */
         if (game->events & EVENT_PAUSE)
         {
             game->isPaused = !game->isPaused;
             game->events = EVENT_NONE;
         }
 
         /* Check if the game is paused */
         if (game->isPaused)
         {
             /* We achieve the effect of pausing the game
              * adding the last frame duration to lastFallTime */
             game->lastFallTime += (sysTime - game->systemTime);
         }
         else
         {
             if (game->events != EVENT_NONE)
             {
                 if (game->events & EVENT_SHOW_NEXT)
                 {
                     game->showPreview = !game->showPreview;
                 }
                 if (game->events & EVENT_DROP)
                 {
                     dropTetramino(game);
                 }
                 if (game->events & EVENT_ROTATE_CW)
                 {
                     rotateTetramino(game, 1);
                 }
                 if (game->events & EVENT_MOVE_RIGHT)
                 {
                     moveTetramino(game, 1, 0);
                 }
                 else if (game->events & EVENT_MOVE_LEFT)
                 {
                     moveTetramino(game, -1, 0);
                 }
                 if (game->events & EVENT_MOVE_DOWN)
                 {
                     moveTetramino(game, 0, 1);
                 }
                 game->events = EVENT_NONE;
             }
             /* Check if it's time to move downwards the falling tetromino */
             if (sysTime - game->lastFallTime >= game->delay)
             {
                 moveTetramino(game, 0, 1);
                 game->lastFallTime = sysTime;
             }
         }
         game->systemTime = sysTime;
     }
     /* Draw game state */
     platformRenderGame();
 }

void gui_game_menu_kbd_process ( )

Definiert in Zeile 7 der Datei simple_game.c.

 {
     running = 0;
     gui_default_kbd_process_menu_btn();
 }

void gui_tetris_draw ( )

Definiert in Zeile 799 der Datei gui_tetris.c.

 {
     gameUpdate(game);
 }

void gui_tetris_init ( )

Definiert in Zeile 765 der Datei gui_tetris.c.

 {
     tile_size = camera_screen.height / (BOARD_HEIGHT+2);
 
     draw_rectangle(camera_screen.disp_left, 0, camera_screen.disp_right, camera_screen.height - 1, MAKE_COLOR(TETRIS_COLOR_BG, TETRIS_COLOR_BG), RECT_BORDER0 | DRAW_FILLED);
     draw_rectangle(camera_screen.disp_left + BOARD_X - 1, BOARD_Y - 1, camera_screen.disp_left + BOARD_WIDTH * TILE_SIZE + TILE_SIZE, BOARD_HEIGHT * TILE_SIZE + TILE_SIZE, MAKE_COLOR(TETRIS_COLOR_TEXT, TETRIS_COLOR_TEXT), RECT_BORDER1);
     game = createGame();
     gameInit(game);
 
     long buf;
     FILE *f;
 
     f = fopen("A/CHDK/GAMES/TETRIS.SCO", "rb");
     if (!f)
     {
         game->stats.high = 0;
     }
     else
     {
         fread(&buf, 1, sizeof(buf), f);
         game->stats.high = buf;
     }
 
     fclose(f);
     startGame(game);
 }

int gui_tetris_kbd_process ( )

Definiert in Zeile 804 der Datei gui_tetris.c.

 {
     if (!game)
     {
         return 0;
     }
     switch (kbd_get_autoclicked_key())
     {
         case KEY_UP:
             if ((game->isPaused) || (game->isOver))
             {
                 TurnOnBackLight();
             }
             else
             {
                 TurnOffBackLight();
             }
             game->events |= EVENT_PAUSE;
             break;
         case KEY_LEFT:
             game->events |= EVENT_MOVE_LEFT;
             break;
         case KEY_RIGHT:
             game->events |= EVENT_MOVE_RIGHT;
             break;
         case KEY_DOWN:
             game->events |= EVENT_MOVE_DOWN;
             break;
             //case KEY_SET:
             //game->events |= EVENT_RESTART;
             //break;
         case KEY_DISPLAY:
         case KEY_ERASE:
         case KEY_SET:
             game->events |= EVENT_ROTATE_CW;
             break;
         default:
             break;
     }
     return 0;
 }

long mkdir_if_not_exist ( const char * dirname)

Definiert in Zeile 121 der Datei gui_tetris.c.

 {
     // Check if directory exists and create it if it does not.
     if (stat(dirname,0) != 0) return mkdir(dirname);
     return 0;   // Success
 }

static void moveTetramino	(	StcGame *	game,
		int	x,
		int	y
	)

static

Definiert in Zeile 552 der Datei gui_tetris.c.

 {
     int i, j, hasFullRow, numFilledRows;
 
     /* Check if the move would create a collision */
     if (checkCollision(game, x, y))
     {
         /* In case of collision check if move was downwards (y == 1) */
         if (y == 1)
         {
             /* Check if collision occur when the falling
              * tetromino is in the 1st or 2nd row */
             if (game->fallingBlock.y <= 1)
             {
                 game->isOver = 1; /* if this happens the game is over */
             }
             else
             {
                 /* The falling tetromino has reached the bottom,
                  * so we copy their cells to the board map */
                 for (i = 0; i < game->fallingBlock.size; ++i)
                 {
                     for (j = 0; j < game->fallingBlock.size; ++j)
                     {
                         if (game->fallingBlock.cells[i][j] != EMPTY_CELL)
                         {
                             game->map[game->fallingBlock.x + i][game->fallingBlock.y + j] = game->fallingBlock.cells[i][j];
                         }
                     }
                 }
 
                 /* Check if the landing tetromino has created full rows */
                 numFilledRows = 0;
                 for (j = 1; j < BOARD_HEIGHT; ++j)
                 {
                     hasFullRow = 1;
                     for (i = 0; i < BOARD_WIDTH; ++i)
                     {
                         if (game->map[i][j] == EMPTY_CELL)
                         {
                             hasFullRow = 0;
                             break;
                         }
                     }
                     /* If we found a full row we need to remove that row from the map
                      * we do that by just moving all the above rows one row below */
                     if (hasFullRow)
                     {
                         for (x = 0; x < BOARD_WIDTH; ++x)
                         {
                             for (y = j; y > 0; --y)
                             {
                                 game->map[x][y] = game->map[x][y - 1];
                             }
                         }
                         numFilledRows++; /* increase filled row counter */
                     }
                 }
 
                 /* Update game statistics */
                 if (numFilledRows)
                 {
                     onFilledRows(game, numFilledRows);
                 }
                 game->stats.totalPieces++;
                 game->stats.pieces[game->fallingBlock.type]++;
 
                 /* Use preview tetromino as falling tetromino.
                  * Copy preview tetramino for falling tetramino */
                 for (i = 0; i < 4; ++i)
                 {
                     for (j = 0; j < 4; ++j)
                     {
                         game->fallingBlock.cells[i][j] = game->nextBlock.cells[i][j];
                     }
                 }
                 game->fallingBlock.size = game->nextBlock.size;
                 game->fallingBlock.type = game->nextBlock.type;
 
                 /* Reset position */
                 game->fallingBlock.y = 0;
                 game->fallingBlock.x = (BOARD_WIDTH - game->fallingBlock.size) / 2;
 
                 /* Create next preview tetromino */
                 setTetramino(rand() % 7, &game->nextBlock);
             }
         }
     }
     else
     {
         /* There are no collisions, just move the tetramino */
         game->fallingBlock.x += x;
         game->fallingBlock.y += y;
     }
 }

static void onFilledRows	(	StcGame *	game,
		int	filledRows
	)

static

Definiert in Zeile 514 der Datei gui_tetris.c.

 {
     /* Update total number of filled rows */
     game->stats.lines += filledRows;
 
     /* Increase score accordingly to the number of filled rows */
     switch (filledRows)
     {
         case 1:
             game->stats.score += (SCORE_1_FILLED_ROW * (game->stats.level));
             break;
         case 2:
             game->stats.score += (SCORE_2_FILLED_ROW * (game->stats.level));
             break;
         case 3:
             game->stats.score += (SCORE_3_FILLED_ROW * (game->stats.level));
             break;
         case 4:
             game->stats.score += (SCORE_4_FILLED_ROW * (game->stats.level));
             break;
         default:
             game->errorCode = GAME_ERROR_ASSERT; /* This can't happen */
     }
     /* Check if we need to update level */
     if (game->stats.lines >= FILLED_ROWS_FOR_LEVEL_UP * (game->stats.level))
     {
         game->stats.level++;
 
         /* Increase speed for falling tetrominoes */
         game->delay *= DELAY_FACTOR_FOR_LEVEL_UP;
     }
 }

void platformEnd ( )

Definiert in Zeile 129 der Datei gui_tetris.c.

129 {}

long platformGetSystemTime ( )

Definiert in Zeile 267 der Datei gui_tetris.c.

267 { return get_tick_count(); }

int platformInit ( )

Definiert in Zeile 128 der Datei gui_tetris.c.

128 { return GAME_ERROR_NONE; }

void platformReadInput ( )

Definiert in Zeile 132 der Datei gui_tetris.c.

132 {}

void platformRenderGame ( )

Definiert in Zeile 145 der Datei gui_tetris.c.

 {
     int i, j;
 
     for (i = 0; i < BOARD_WIDTH; ++i)
     {
         for (j = 0; j < BOARD_HEIGHT; ++j)
         {
             tmp[i][j] = EMPTY_CELL;
             tmp2[i][j] = EMPTY_CELL;
         }
     }
 
     /* Draw preview block */
     if (game->nextBlock.type != prevNextBlockType)
     {
         prevNextBlockType = game->nextBlock.type;
         for (i = 0; i < 4; ++i)
         {
             for (j = 0; j < 4; ++j)
             {
                 if (game->nextBlock.cells[i][j] != EMPTY_CELL)
                 {
                     draw_rectangle(camera_screen.disp_left + PREVIEW_X + (TILE_SIZE * i),
                                    PREVIEW_Y + (TILE_SIZE * j),
                                    camera_screen.disp_left + PREVIEW_X + (TILE_SIZE * i) + TILE_SIZE - 1,
                                    PREVIEW_Y + (TILE_SIZE * j) + TILE_SIZE - 1,
                                    MAKE_COLOR(game->nextBlock.cells[i][j], game->nextBlock.cells[i][j]), RECT_BORDER0 | DRAW_FILLED);
                 }
                 else
                 {
                     draw_rectangle(camera_screen.disp_left + PREVIEW_X + (TILE_SIZE * i),
                                    PREVIEW_Y + (TILE_SIZE * j),
                                    camera_screen.disp_left + PREVIEW_X + (TILE_SIZE * i) + TILE_SIZE - 1,
                                    PREVIEW_Y + (TILE_SIZE * j) + TILE_SIZE - 1,
                                    MAKE_COLOR(TETRIS_COLOR_BG, TETRIS_COLOR_BG), RECT_BORDER0 | DRAW_FILLED);
                 }
             }
         }
     }
 
     /* Draw the cells in the board */
     for (i = 0; i < BOARD_WIDTH; ++i)
     {
         for (j = 0; j < BOARD_HEIGHT; ++j)
         {
             if (game->map[i][j] != EMPTY_CELL)
             {
                 tmp2[i][j] = game->map[i][j];
             }
         }
     }
     /* Draw falling tetromino */
     for (i = 0; i < 4; ++i)
     {
         for (j = 0; j < 4; ++j)
         {
             if (game->fallingBlock.cells[i][j] != EMPTY_CELL)
             {
                 tmp[i + game->fallingBlock.x][j + game->fallingBlock.y] = game->fallingBlock.cells[i][j];
             }
         }
     }
 
     for (i = 0; i < BOARD_WIDTH; ++i)
     {
         for (j = 0; j < BOARD_HEIGHT; ++j)
         {
             if (tmp[i][j] != EMPTY_CELL)
             {
                 draw_rectangle(camera_screen.disp_left + BOARD_X + (TILE_SIZE * i),
                                BOARD_Y + (TILE_SIZE * j),
                                camera_screen.disp_left + BOARD_X + (TILE_SIZE * i) + TILE_SIZE - 1,
                                BOARD_Y + (TILE_SIZE * j) + TILE_SIZE - 1,
                                MAKE_COLOR(tmp[i][j], tmp[i][j]), RECT_BORDER0 | DRAW_FILLED);
             }
             else if (tmp2[i][j] != EMPTY_CELL)
             {
                 draw_rectangle(camera_screen.disp_left + BOARD_X + (TILE_SIZE * i),
                                BOARD_Y + (TILE_SIZE * j),
                                camera_screen.disp_left + BOARD_X + (TILE_SIZE * i) + TILE_SIZE - 1,
                                BOARD_Y + (TILE_SIZE * j) + TILE_SIZE - 1,
                                MAKE_COLOR(tmp2[i][j], tmp2[i][j]), RECT_BORDER0 | DRAW_FILLED);
             }
             else
             {
                 draw_rectangle(camera_screen.disp_left + BOARD_X + (TILE_SIZE * i),
                                BOARD_Y + (TILE_SIZE * j),
                                camera_screen.disp_left + BOARD_X + (TILE_SIZE * i) + TILE_SIZE - 1,
                                BOARD_Y + (TILE_SIZE * j) + TILE_SIZE - 1,
                                MAKE_COLOR(TETRIS_COLOR_BOARD, TETRIS_COLOR_BOARD), RECT_BORDER0 | DRAW_FILLED);
             }
         }
     }
 
     /* output game info */
     int tx = camera_screen.disp_right - 22 * FONT_WIDTH;
     twoColors cl = MAKE_COLOR(TETRIS_COLOR_BG, TETRIS_COLOR_TEXT);
     int yo = FONT_HEIGHT;
     char str_buf[100];
     static struct tm *ttm;
     sprintf(str_buf, "High:    %5d", game->stats.high);
     draw_string(tx, camera_screen.height - yo * 11, str_buf, cl);
     sprintf(str_buf, "Points:  %5d", game->stats.score);
     draw_string(tx, camera_screen.height - yo * 10, str_buf, cl);
     sprintf(str_buf, "Lines:   %5d", game->stats.lines);
     draw_string(tx, camera_screen.height - yo * 9, str_buf, cl);
     sprintf(str_buf, "Level:   %5d", game->stats.level);
     draw_string(tx, camera_screen.height - yo * 8, str_buf, cl);
     sprintf(str_buf, "UP  -> Pause");
     draw_string(tx, camera_screen.height - yo * 6, str_buf, cl);
     sprintf(str_buf, "SET -> Rotate");
     draw_string(tx, camera_screen.height - yo * 5, str_buf, cl);
 
     ttm = get_localtime();
     sprintf(str_buf, "Time:    %2u:%02u", ttm->tm_hour, ttm->tm_min);
     draw_string(tx, camera_screen.height - yo * 3, str_buf, cl);
     sprintf(str_buf, "Batt:     %3d%%", get_batt_perc());
     draw_string(tx, camera_screen.height - yo * 2, str_buf, cl);
 }

void rotateTetramino	(	StcGame *	game,
		int	clockwise
	)

Definiert in Zeile 421 der Datei gui_tetris.c.

 {
     int i, j;
     int rotated[4][4]; /* temporary array to hold rotated cells */
 
     /* If TETRAMINO_O is falling return immediately */
     if (game->fallingBlock.type == TETROMINO_O)
     {
         return; /* rotation doesn't require any changes */
     }
 
     /* Initialize rotated cells to blank */
     setMatrixCells(&rotated[0][0], 4, 4, EMPTY_CELL);
 
     /* Copy rotated cells to the temporary array */
     for (i = 0; i < game->fallingBlock.size; ++i)
     {
         for (j = 0; j < game->fallingBlock.size; ++j)
         {
             if (clockwise)
             {
                 rotated[game->fallingBlock.size - j - 1][i] = game->fallingBlock.cells[i][j];
             }
             else
             {
                 rotated[j][game->fallingBlock.size - i - 1] = game->fallingBlock.cells[i][j];
             }
         }
     }
     /* Check collision of the temporary array */
     for (i = 0; i < game->fallingBlock.size; ++i)
     {
         for (j = 0; j < game->fallingBlock.size; ++j)
         {
             if (rotated[i][j] != EMPTY_CELL)
             {
                 /* Check collision with left, right or bottom borders of the map */
                 if ((game->fallingBlock.x + i < 0) || (game->fallingBlock.x + i >= BOARD_WIDTH) || (game->fallingBlock.y + j >= BOARD_HEIGHT))
                 {
                     return; /* there was collision therefore return */
                 }
                 /* Check collision with existing cells in the map */
                 if (game->map[i + game->fallingBlock.x][j + game->fallingBlock.y] != EMPTY_CELL)
                 {
                     return; /* there was collision therefore return */
                 }
             }
         }
     }
     /* There are no collisions, replace tetramino cells with rotated cells */
     for (i = 0; i < 4; ++i)
     {
         for (j = 0; j < 4; ++j)
         {
             game->fallingBlock.cells[i][j] = rotated[i][j];
         }
     }
 }

static void setMatrixCells	(	int *	matrix,
		int	width,
		int	height,
		int	value
	)

static

Definiert in Zeile 270 der Datei gui_tetris.c.

 {
     int i, j;
     for (i = 0; i < width; ++i)
     {
         for (j = 0; j < height; ++j)
         {
             *(matrix + i + (j * width)) = value;
         }
     }
 }

static void setTetramino	(	int	indexTetramino,
		StcTetramino *	tetramino
	)

static

Definiert in Zeile 283 der Datei gui_tetris.c.

 {
 
     /* Initialize tetromino cells to empty cells */
     setMatrixCells(&tetramino->cells[0][0], 4, 4, EMPTY_CELL);
 
     /* Almost all the blocks have size 3 */
     tetramino->size = 3;
 
     /* Initial configuration from: http://www.tetrisconcept.com/wiki/index.php/SRS */
     switch (indexTetramino)
     {
         case TETROMINO_I:
             tetramino->cells[0][1] = TETRIS_COLOR_CYAN;
             tetramino->cells[1][1] = TETRIS_COLOR_CYAN;
             tetramino->cells[2][1] = TETRIS_COLOR_CYAN;
             tetramino->cells[3][1] = TETRIS_COLOR_CYAN;
             tetramino->size = 4;
             break;
         case TETROMINO_O:
             tetramino->cells[0][0] = TETRIS_COLOR_YELLOW;
             tetramino->cells[0][1] = TETRIS_COLOR_YELLOW;
             tetramino->cells[1][0] = TETRIS_COLOR_YELLOW;
             tetramino->cells[1][1] = TETRIS_COLOR_YELLOW;
             tetramino->size = 2;
             break;
         case TETROMINO_T:
             tetramino->cells[0][1] = TETRIS_COLOR_PURPLE;
             tetramino->cells[1][0] = TETRIS_COLOR_PURPLE;
             tetramino->cells[1][1] = TETRIS_COLOR_PURPLE;
             tetramino->cells[2][1] = TETRIS_COLOR_PURPLE;
             break;
         case TETROMINO_S:
             tetramino->cells[0][1] = TETRIS_COLOR_GREEN;
             tetramino->cells[1][0] = TETRIS_COLOR_GREEN;
             tetramino->cells[1][1] = TETRIS_COLOR_GREEN;
             tetramino->cells[2][0] = TETRIS_COLOR_GREEN;
             break;
         case TETROMINO_Z:
             tetramino->cells[0][0] = TETRIS_COLOR_RED;
             tetramino->cells[1][0] = TETRIS_COLOR_RED;
             tetramino->cells[1][1] = TETRIS_COLOR_RED;
             tetramino->cells[2][1] = TETRIS_COLOR_RED;
             break;
         case TETROMINO_J:
             tetramino->cells[0][0] = TETRIS_COLOR_BLUE;
             tetramino->cells[0][1] = TETRIS_COLOR_BLUE;
             tetramino->cells[1][1] = TETRIS_COLOR_BLUE;
             tetramino->cells[2][1] = TETRIS_COLOR_BLUE;
             break;
         case TETROMINO_L:
             tetramino->cells[0][1] = TETRIS_COLOR_ORANGE;
             tetramino->cells[1][1] = TETRIS_COLOR_ORANGE;
             tetramino->cells[2][0] = TETRIS_COLOR_ORANGE;
             tetramino->cells[2][1] = TETRIS_COLOR_ORANGE;
             break;
     }
     tetramino->type = indexTetramino;
 }

static void startGame ( StcGame * game)

static

Definiert in Zeile 344 der Datei gui_tetris.c.

 {
     int i;
 
     /* Initialize game data */
     game->errorCode = GAME_ERROR_NONE;
     game->systemTime = platformGetSystemTime();
     game->lastFallTime = game->systemTime;
     game->isOver = 0;
     game->isPaused = 0;
     game->showPreview = 1;
     game->events = EVENT_NONE;
     game->delay = INI_DELAY_FALL;
     /* Initialize game statistics */
     game->stats.score = 0;
     game->stats.lines = 0;
     game->stats.totalPieces = 0;
     game->stats.level = 0;
     for (i = 0; i < 7; ++i)
     {
         game->stats.pieces[i] = 0;
     }
 
     /* Initialize rand generator */
     srand(game->systemTime);
 
     /* Initialize game tile map */
     setMatrixCells(&game->map[0][0], BOARD_WIDTH, BOARD_HEIGHT, EMPTY_CELL);
 
     /* Initialize falling tetromino */
     setTetramino(rand() % 7, &game->fallingBlock);
     game->fallingBlock.x = (BOARD_WIDTH - game->fallingBlock.size) / 2;
     game->fallingBlock.y = 0;
 
     /* Initialize preview tetromino */
     setTetramino(rand() % 7, &game->nextBlock);
 }

Variablen-Dokumentation

ModuleInfo _module_info

Initialisierung:

=
{
    MODULEINFO_V1_MAGICNUM,
    sizeof(ModuleInfo),
    SIMPLE_MODULE_VERSION,      
    ANY_CHDK_BRANCH, 0, OPT_ARCHITECTURE,           
    ANY_PLATFORM_ALLOWED,       
    -LANG_MENU_GAMES_TETRIS,    
    MTYPE_GAME,
    &_librun.base,
    ANY_VERSION,                
    CAM_SCREEN_VERSION,         
    ANY_VERSION,                
    ANY_VERSION,                
    0,
}

Definiert in Zeile 850 der Datei gui_tetris.c.

StcGame* game = 0

Definiert in Zeile 118 der Datei gui_tetris.c.

gui_handler GUI_MODE_TETRIS

Initialisierung:

=

{ GUI_MODE_MODULE, gui_tetris_draw, gui_tetris_kbd_process, gui_game_menu_kbd_process, 0, GUI_MODE_FLAG_NODRAWRESTORE }

Definiert in Zeile 20 der Datei gui_tetris.c.

int prevNextBlockType = -1

Definiert in Zeile 144 der Datei gui_tetris.c.

int tile_size

Definiert in Zeile 134 der Datei gui_tetris.c.

int tmp[BOARD_WIDTH][BOARD_HEIGHT]

Definiert in Zeile 141 der Datei gui_tetris.c.

int tmp2[BOARD_WIDTH][BOARD_HEIGHT]

Definiert in Zeile 142 der Datei gui_tetris.c.

Datenstrukturen

Makrodefinitionen

Typdefinitionen

Funktionen

Variablen

Makro-Dokumentation

Dokumentation der benutzerdefinierten Typen

Dokumentation der Funktionen

Variablen-Dokumentation