1093 lines
30 KiB
C
1093 lines
30 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2014 Franklin Wei
|
|
*
|
|
* Clone of 2048 by Gabriele Cirulli
|
|
*
|
|
* Thanks to [Saint], saratoga, and gevaerts for answering all my n00b
|
|
* questions :)
|
|
*
|
|
* 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 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
***************************************************************************/
|
|
|
|
/* TODO
|
|
* Sounds!
|
|
* Better animations!
|
|
*/
|
|
|
|
/* includes */
|
|
|
|
#include <plugin.h>
|
|
|
|
#include "lib/display_text.h"
|
|
|
|
#include "lib/helper.h"
|
|
#include "lib/highscore.h"
|
|
#include "lib/playback_control.h"
|
|
#include "lib/pluginlib_actions.h"
|
|
#include "lib/pluginlib_exit.h"
|
|
|
|
#include "pluginbitmaps/_2048_background.h"
|
|
#include "pluginbitmaps/_2048_tiles.h"
|
|
|
|
/* some constants */
|
|
|
|
static const int ANIM_SLEEPTIME = (HZ/20);
|
|
static const int NUM_STARTING_TILES = 2;
|
|
static const int VERT_SPACING = 4;
|
|
static const int WHAT_FONT = FONT_UI;
|
|
static const unsigned int WINNING_TILE = 2048;
|
|
|
|
/* must use macros for these */
|
|
#define GRID_SIZE 4
|
|
#define HISCORES_FILE PLUGIN_GAMES_DATA_DIR "/2048.score"
|
|
#define MIN_SPACE (BMPHEIGHT__2048_tiles * 0.134)
|
|
#define NUM_SCORES 5
|
|
#define RESUME_FILE PLUGIN_GAMES_DATA_DIR "/2048.save"
|
|
#define SPACES (GRID_SIZE * GRID_SIZE)
|
|
|
|
/* screen-specific configuration */
|
|
|
|
#if (LCD_WIDTH < LCD_HEIGHT) /* tall screens */
|
|
# define TITLE_X 0
|
|
# define TITLE_Y 0
|
|
# define BASE_Y (BMPHEIGHT__2048_tiles*1.5)
|
|
# define BASE_X (BMPHEIGHT__2048_tiles*.5-MIN_SPACE)
|
|
# define SCORE_X 0
|
|
# define SCORE_Y (max_numeral_height)
|
|
# define BEST_SCORE_X 0
|
|
# define BEST_SCORE_Y (2*max_numeral_height)
|
|
#else /* wide or square screens */
|
|
# define TITLE_X 0
|
|
# define TITLE_Y 0
|
|
# define BASE_X (LCD_WIDTH-(GRID_SIZE*BMPHEIGHT__2048_tiles)-(((GRID_SIZE+1)*MIN_SPACE)))
|
|
# define BASE_Y (BMPHEIGHT__2048_tiles*.5-MIN_SPACE)
|
|
# define SCORE_X 0
|
|
# define SCORE_Y (max_numeral_height)
|
|
# define BEST_SCORE_X 0
|
|
# define BEST_SCORE_Y (2*max_numeral_height)
|
|
#endif /* LCD_WIDTH < LCD_HEIGHT */
|
|
|
|
/* where to draw the background bitmap */
|
|
static const int BACKGROUND_X = (BASE_X-MIN_SPACE);
|
|
static const int BACKGROUND_Y = (BASE_Y-MIN_SPACE);
|
|
|
|
/* key mappings */
|
|
#define KEY_UP PLA_UP
|
|
#define KEY_DOWN PLA_DOWN
|
|
#define KEY_LEFT PLA_LEFT
|
|
#define KEY_RIGHT PLA_RIGHT
|
|
#define KEY_EXIT PLA_CANCEL
|
|
#define KEY_UNDO PLA_SELECT
|
|
|
|
/* notice how "color" is spelled :P */
|
|
#ifdef HAVE_LCD_COLOR
|
|
|
|
/* colors */
|
|
|
|
static const unsigned BACKGROUND = LCD_RGBPACK(0xfa, 0xf8, 0xef);
|
|
static const unsigned BOARD_BACKGROUND = LCD_RGBPACK(0xbb, 0xad, 0xa0);
|
|
static const unsigned TEXT_COLOR = LCD_RGBPACK(0x77, 0x6e, 0x65);
|
|
|
|
#endif
|
|
|
|
/* PLA data */
|
|
static const struct button_mapping *plugin_contexts[] = { pla_main_ctx };
|
|
|
|
/*** game data structures ***/
|
|
|
|
struct game_ctx_t {
|
|
unsigned int grid[GRID_SIZE][GRID_SIZE]; /* 0 = empty */
|
|
unsigned int score;
|
|
unsigned int cksum; /* sum of grid, XORed by score */
|
|
bool already_won; /* has the player gotten 2048 yet? */
|
|
} game_ctx;
|
|
|
|
static struct game_ctx_t *ctx = &game_ctx;
|
|
|
|
/*** temporary data ***/
|
|
|
|
static bool merged_grid[GRID_SIZE][GRID_SIZE];
|
|
static int old_grid[GRID_SIZE][GRID_SIZE];
|
|
|
|
static int max_numeral_height = -1;
|
|
|
|
#if LCD_DEPTH <= 1
|
|
static int max_numeral_width;
|
|
#endif
|
|
|
|
static bool loaded = false; /* has a save been loaded? */
|
|
|
|
/* the high score */
|
|
static unsigned int best_score;
|
|
|
|
static bool abnormal_exit = true;
|
|
static struct highscore highscores[NUM_SCORES];
|
|
|
|
/***************************** UTILITY FUNCTIONS *****************************/
|
|
|
|
static inline int rand_range(int min, int max)
|
|
{
|
|
return rb->rand() % (max-min + 1) + min;
|
|
}
|
|
|
|
/* prepares for exit */
|
|
static void cleanup(void)
|
|
{
|
|
backlight_use_settings();
|
|
}
|
|
|
|
/* returns 2 or 4 */
|
|
static inline int rand_2_or_4(void)
|
|
{
|
|
/* 1 in 10 chance of a four */
|
|
if(rb->rand() % 10 == 0)
|
|
return 4;
|
|
else
|
|
return 2;
|
|
}
|
|
|
|
/* displays the help text */
|
|
static bool do_help(void)
|
|
{
|
|
|
|
#ifdef HAVE_LCD_COLOR
|
|
rb->lcd_set_foreground(LCD_WHITE);
|
|
rb->lcd_set_background(LCD_BLACK);
|
|
#endif
|
|
|
|
rb->lcd_setfont(FONT_UI);
|
|
|
|
static char* help_text[]= {"2048", "", "Aim",
|
|
"", "Join", "the", "numbers", "to", "get", "to", "the", "2048", "tile!", "", "",
|
|
"How", "to", "Play", "",
|
|
"", "Use", "the", "directional", "keys", "to", "move", "the", "tiles.", "When",
|
|
"two", "tiles", "with", "the", "same", "number", "touch,", "they", "merge", "into", "one!"};
|
|
|
|
struct style_text style[] = {
|
|
{0, TEXT_CENTER | TEXT_UNDERLINE},
|
|
{2, C_RED},
|
|
{15, C_RED},
|
|
{16, C_RED},
|
|
{17, C_RED},
|
|
LAST_STYLE_ITEM
|
|
};
|
|
|
|
return display_text(ARRAYLEN(help_text), help_text, style, NULL, true);
|
|
}
|
|
|
|
/*** tile movement logic ***/
|
|
|
|
/* this function performs the tile movement */
|
|
static inline void slide_internal(int startx, int starty,
|
|
int stopx, int stopy,
|
|
int dx, int dy,
|
|
int lookx, int looky,
|
|
bool update_best)
|
|
{
|
|
unsigned int best_score_old = best_score;
|
|
|
|
/* loop over the rows or columns, moving the tiles in the specified direction */
|
|
for(int y = starty; y != stopy; y += dy)
|
|
{
|
|
for(int x = startx; x != stopx; x += dx)
|
|
{
|
|
if(ctx->grid[x + lookx][y + looky] == ctx->grid[x][y] &&
|
|
ctx->grid[x][y] &&
|
|
!merged_grid[x + lookx][y + looky] &&
|
|
!merged_grid[x][y]) /* merge these two tiles */
|
|
{
|
|
/* Each merged tile cannot be merged again */
|
|
merged_grid[x + lookx][y + looky] = true;
|
|
ctx->grid[x + lookx][y + looky] = 2 * ctx->grid[x][y];
|
|
ctx->score += ctx->grid[x + lookx][y + looky];
|
|
ctx->grid[x][y] = 0;
|
|
}
|
|
else if(ctx->grid[x + lookx][y + looky] == 0) /* Empty! */
|
|
{
|
|
ctx->grid[x + lookx][y + looky] = ctx->grid[x][y];
|
|
ctx->grid[x][y] = 0;
|
|
}
|
|
}
|
|
}
|
|
if(ctx->score > best_score_old && update_best)
|
|
best_score = ctx->score;
|
|
}
|
|
|
|
/* these functions move each tile 1 space in the direction specified via calls to slide_internal */
|
|
|
|
/* Up
|
|
0
|
|
1 ^ ^ ^ ^
|
|
2 ^ ^ ^ ^
|
|
3 ^ ^ ^ ^
|
|
0 1 2 3
|
|
*/
|
|
static void up(bool update_best)
|
|
{
|
|
slide_internal(0, 1, /* start values */
|
|
GRID_SIZE, GRID_SIZE, /* stop values */
|
|
1, 1, /* delta values */
|
|
0, -1, /* lookahead values */
|
|
update_best);
|
|
}
|
|
|
|
/* Down
|
|
0 v v v v
|
|
1 v v v v
|
|
2 v v v v
|
|
3
|
|
0 1 2 3
|
|
*/
|
|
static void down(bool update_best)
|
|
{
|
|
slide_internal(0, GRID_SIZE-2,
|
|
GRID_SIZE, -1,
|
|
1, -1,
|
|
0, 1,
|
|
update_best);
|
|
}
|
|
|
|
/* Left
|
|
0 < < <
|
|
1 < < <
|
|
2 < < <
|
|
3 < < <
|
|
0 1 2 3
|
|
*/
|
|
static void left(bool update_best)
|
|
{
|
|
slide_internal(1, 0,
|
|
GRID_SIZE, GRID_SIZE,
|
|
1, 1,
|
|
-1, 0,
|
|
update_best);
|
|
}
|
|
|
|
/* Right
|
|
0 > > >
|
|
1 > > >
|
|
2 > > >
|
|
3 > > >
|
|
0 1 2 3
|
|
*/
|
|
static void right(bool update_best)
|
|
{
|
|
slide_internal(GRID_SIZE-2, 0, /* start */
|
|
-1, GRID_SIZE, /* stop */
|
|
-1, 1, /* delta */
|
|
1, 0, /* lookahead */
|
|
update_best);
|
|
}
|
|
|
|
/* copies old_grid to ctx->grid */
|
|
static inline void RESTORE_GRID(void)
|
|
{
|
|
memcpy(&ctx->grid, &old_grid, sizeof(ctx->grid));
|
|
}
|
|
|
|
/* slightly modified base 2 logarithm, returns 1 when given zero, and log2(n) + 1 for anything else */
|
|
static inline int ilog2(int n)
|
|
{
|
|
if(n == 0)
|
|
return 1;
|
|
int log = 0;
|
|
while(n > 1)
|
|
{
|
|
n >>= 1;
|
|
++log;
|
|
}
|
|
return log + 1;
|
|
}
|
|
|
|
/* low-depth displays resort to text drawing, see the #else case below */
|
|
|
|
#if LCD_DEPTH > 1
|
|
|
|
/* draws game screen + updates LCD */
|
|
static void draw(void)
|
|
{
|
|
#ifdef HAVE_LCD_COLOR
|
|
rb->lcd_set_background(BACKGROUND);
|
|
#endif
|
|
|
|
rb->lcd_clear_display();
|
|
|
|
/* draw the background */
|
|
|
|
rb->lcd_bitmap(_2048_background,
|
|
BACKGROUND_X, BACKGROUND_Y,
|
|
BMPWIDTH__2048_background, BMPWIDTH__2048_background);
|
|
|
|
/*
|
|
grey_gray_bitmap(_2048_background, BACKGROUND_X, BACKGROUND_Y, BMPWIDTH__2048_background, BMPHEIGHT__2048_background);
|
|
*/
|
|
|
|
/* draw the grid */
|
|
|
|
for(int y = 0; y < GRID_SIZE; ++y)
|
|
{
|
|
for(int x = 0; x < GRID_SIZE; ++x)
|
|
{
|
|
rb->lcd_bitmap_part(_2048_tiles, /* source */
|
|
BMPWIDTH__2048_tiles - BMPHEIGHT__2048_tiles * ilog2(ctx->grid[x][y]), 0, /* source upper left corner */
|
|
STRIDE(SCREEN_MAIN, BMPWIDTH__2048_tiles, BMPHEIGHT__2048_tiles), /* stride */
|
|
(BMPHEIGHT__2048_tiles + MIN_SPACE) * x + BASE_X, (BMPHEIGHT__2048_tiles + MIN_SPACE) * y + BASE_Y, /* dest upper-left corner */
|
|
BMPHEIGHT__2048_tiles, BMPHEIGHT__2048_tiles); /* size of the cut section */
|
|
}
|
|
}
|
|
|
|
/* draw the title */
|
|
char buf[32];
|
|
|
|
#ifdef HAVE_LCD_COLOR
|
|
rb->lcd_set_foreground(TEXT_COLOR);
|
|
#endif
|
|
|
|
rb->snprintf(buf, sizeof(buf), "%d", WINNING_TILE);
|
|
|
|
/* check if the title will overlap the grid */
|
|
int w, h;
|
|
rb->lcd_setfont(FONT_UI);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_UI);
|
|
bool draw_title = true;
|
|
if(w + TITLE_X >= BACKGROUND_X && h + TITLE_Y >= BACKGROUND_Y)
|
|
{
|
|
/* if it goes into the grid, use the system font, which should be smaller */
|
|
rb->lcd_setfont(FONT_SYSFIXED);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_SYSFIXED);
|
|
if(w + TITLE_X >= BACKGROUND_X && h + TITLE_Y >= BACKGROUND_Y)
|
|
{
|
|
/* title can't fit, don't draw it */
|
|
draw_title = false;
|
|
h = 0;
|
|
}
|
|
}
|
|
|
|
if(draw_title)
|
|
rb->lcd_putsxy(TITLE_X, TITLE_Y, buf);
|
|
|
|
int score_y = TITLE_Y + h + VERT_SPACING;
|
|
|
|
/* draw the score */
|
|
rb->snprintf(buf, sizeof(buf), "Score: %d", ctx->score);
|
|
|
|
#ifdef HAVE_LCD_COLOR
|
|
rb->lcd_set_foreground(LCD_WHITE);
|
|
rb->lcd_set_background(BOARD_BACKGROUND);
|
|
#endif
|
|
|
|
rb->lcd_setfont(FONT_UI);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_UI);
|
|
|
|
/* try making the score fit */
|
|
if(w + SCORE_X >= BACKGROUND_X && h + SCORE_Y >= BACKGROUND_Y)
|
|
{
|
|
/* score overflows */
|
|
/* first see if it fits with Score: and FONT_SYSFIXED */
|
|
rb->lcd_setfont(FONT_SYSFIXED);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_SYSFIXED);
|
|
if(w + SCORE_X < BACKGROUND_X)
|
|
/* it fits, go and draw it */
|
|
goto draw_lbl;
|
|
|
|
/* now try with S: and FONT_UI */
|
|
rb->snprintf(buf, sizeof(buf), "S: %d", ctx->score);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_UI);
|
|
rb->lcd_setfont(FONT_UI);
|
|
if(w + SCORE_X < BACKGROUND_X)
|
|
goto draw_lbl;
|
|
|
|
/* now try with S: and FONT_SYSFIXED */
|
|
rb->snprintf(buf, sizeof(buf), "S: %d", ctx->score);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_SYSFIXED);
|
|
rb->lcd_setfont(FONT_SYSFIXED);
|
|
if(w + SCORE_X < BACKGROUND_X)
|
|
goto draw_lbl;
|
|
|
|
/* then try without Score: and FONT_UI */
|
|
rb->snprintf(buf, sizeof(buf), "%d", ctx->score);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_UI);
|
|
rb->lcd_setfont(FONT_UI);
|
|
if(w + SCORE_X < BACKGROUND_X)
|
|
goto draw_lbl;
|
|
|
|
/* as a last resort, don't use Score: and use the system font */
|
|
rb->snprintf(buf, sizeof(buf), "%d", ctx->score);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_SYSFIXED);
|
|
rb->lcd_setfont(FONT_SYSFIXED);
|
|
if(w + SCORE_X < BACKGROUND_X)
|
|
goto draw_lbl;
|
|
else
|
|
goto skip_draw_score;
|
|
}
|
|
|
|
draw_lbl:
|
|
rb->lcd_putsxy(SCORE_X, score_y, buf);
|
|
score_y += h + VERT_SPACING;
|
|
|
|
/* draw the best score */
|
|
skip_draw_score:
|
|
rb->snprintf(buf, sizeof(buf), "Best: %d", best_score);
|
|
|
|
#ifdef HAVE_LCD_COLOR
|
|
rb->lcd_set_foreground(LCD_WHITE);
|
|
rb->lcd_set_background(BOARD_BACKGROUND);
|
|
#endif
|
|
|
|
rb->lcd_setfont(FONT_UI);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_UI);
|
|
if(w + BEST_SCORE_X >= BACKGROUND_X && h + BEST_SCORE_Y >= BACKGROUND_Y)
|
|
{
|
|
/* score overflows */
|
|
/* first see if it fits with Score: and FONT_SYSFIXED */
|
|
rb->lcd_setfont(FONT_SYSFIXED);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_SYSFIXED);
|
|
if(w + BEST_SCORE_X < BACKGROUND_X)
|
|
/* it fits, go and draw it */
|
|
goto draw_best;
|
|
|
|
/* now try with S: and FONT_UI */
|
|
rb->snprintf(buf, sizeof(buf), "B: %d", best_score);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_UI);
|
|
rb->lcd_setfont(FONT_UI);
|
|
if(w + BEST_SCORE_X < BACKGROUND_X)
|
|
goto draw_best;
|
|
|
|
/* now try with S: and FONT_SYSFIXED */
|
|
rb->snprintf(buf, sizeof(buf), "B: %d", best_score);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_SYSFIXED);
|
|
rb->lcd_setfont(FONT_SYSFIXED);
|
|
if(w + BEST_SCORE_X < BACKGROUND_X)
|
|
goto draw_best;
|
|
|
|
/* then try without Score: and FONT_UI */
|
|
rb->snprintf(buf, sizeof(buf), "%d", best_score);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_UI);
|
|
rb->lcd_setfont(FONT_UI);
|
|
if(w + BEST_SCORE_X < BACKGROUND_X)
|
|
goto draw_best;
|
|
|
|
/* as a last resort, don't use Score: and use the system font */
|
|
rb->snprintf(buf, sizeof(buf), "%d", best_score);
|
|
rb->font_getstringsize(buf, &w, &h, FONT_SYSFIXED);
|
|
rb->lcd_setfont(FONT_SYSFIXED);
|
|
if(w + BEST_SCORE_X < BACKGROUND_X)
|
|
goto draw_best;
|
|
else
|
|
goto skip_draw_best;
|
|
}
|
|
draw_best:
|
|
rb->lcd_putsxy(BEST_SCORE_X, score_y, buf);
|
|
|
|
skip_draw_best:
|
|
rb->lcd_update();
|
|
|
|
/* revert the font */
|
|
rb->lcd_setfont(WHAT_FONT);
|
|
}
|
|
|
|
#else /* LCD_DEPTH > 1 */
|
|
|
|
/* 1-bit display :( */
|
|
/* bitmaps are unreadable on these screens, so just resort to text-based drawing */
|
|
static void draw(void)
|
|
{
|
|
rb->lcd_clear_display();
|
|
|
|
/* Draw the grid */
|
|
/* find the biggest tile */
|
|
unsigned int biggest_tile = 0;
|
|
for(int x = 0; x < GRID_SIZE; ++x)
|
|
{
|
|
for(int y = 0; y < GRID_SIZE; ++y)
|
|
if(ctx->grid[x][y] > biggest_tile)
|
|
biggest_tile = ctx->grid[x][y];
|
|
}
|
|
|
|
char buf[32];
|
|
|
|
rb->snprintf(buf, 32, "%d", biggest_tile);
|
|
|
|
int biggest_tile_width = rb->strlen(buf) * rb->font_get_width(rb->font_get(WHAT_FONT), '0') + MIN_SPACE;
|
|
|
|
for(int y = 0; y < GRID_SIZE; ++y)
|
|
{
|
|
for(int x = 0; x < GRID_SIZE; ++x)
|
|
{
|
|
if(ctx->grid[x][y])
|
|
{
|
|
if(ctx->grid[x][y] > biggest_tile)
|
|
biggest_tile = ctx->grid[x][y];
|
|
rb->snprintf(buf, 32, "%d", ctx->grid[x][y]);
|
|
rb->lcd_putsxy(biggest_tile_width * x, y * max_numeral_height + max_numeral_height, buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Now draw the score, and the game title */
|
|
rb->snprintf(buf, 32, "Score: %d", ctx->score);
|
|
int buf_width, buf_height;
|
|
rb->font_getstringsize(buf, &buf_width, &buf_height, WHAT_FONT);
|
|
|
|
int score_leftmost = LCD_WIDTH - buf_width - 1;
|
|
/* Check if there is enough space to display "Score: ", otherwise, only display the score */
|
|
if(score_leftmost >= 0)
|
|
rb->lcd_putsxy(score_leftmost, 0, buf);
|
|
else
|
|
rb->lcd_putsxy(score_leftmost, 0, buf + rb->strlen("Score: "));
|
|
|
|
rb->snprintf(buf, 32, "%d", WINNING_TILE);
|
|
rb->font_getstringsize(buf, &buf_width, &buf_height, WHAT_FONT);
|
|
if(buf_width < score_leftmost)
|
|
rb->lcd_putsxy(0, 0, buf);
|
|
|
|
rb->lcd_update();
|
|
}
|
|
|
|
#endif /* LCD_DEPTH > 1 */
|
|
|
|
/* place a 2 or 4 in a random empty space */
|
|
static void place_random(void)
|
|
{
|
|
int xpos[SPACES], ypos[SPACES];
|
|
int back = 0;
|
|
/* get the indexes of empty spaces */
|
|
for(int y = 0; y < GRID_SIZE; ++y)
|
|
for(int x = 0; x < GRID_SIZE; ++x)
|
|
{
|
|
if(!ctx->grid[x][y])
|
|
{
|
|
xpos[back] = x;
|
|
ypos[back++] = y;
|
|
}
|
|
}
|
|
|
|
if(!back)
|
|
/* no empty spaces */
|
|
return;
|
|
|
|
int idx = rand_range(0, back - 1);
|
|
ctx->grid[ xpos[idx] ][ ypos[idx] ] = rand_2_or_4();
|
|
}
|
|
|
|
/* checks for a win or loss */
|
|
static bool check_gameover(void)
|
|
{
|
|
/* first, check for a loss */
|
|
int oldscore = ctx->score;
|
|
bool have_legal_move = false;
|
|
|
|
memset(&merged_grid, 0, SPACES * sizeof(bool));
|
|
up(false);
|
|
if(memcmp(&old_grid, &ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
RESTORE_GRID();
|
|
ctx->score = oldscore;
|
|
have_legal_move = true;
|
|
}
|
|
RESTORE_GRID();
|
|
|
|
memset(&merged_grid, 0, SPACES * sizeof(bool));
|
|
down(false);
|
|
if(memcmp(&old_grid, &ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
RESTORE_GRID();
|
|
ctx->score = oldscore;
|
|
have_legal_move = true;
|
|
}
|
|
RESTORE_GRID();
|
|
|
|
memset(&merged_grid, 0, SPACES * sizeof(bool));
|
|
left(false);
|
|
if(memcmp(&old_grid, &ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
RESTORE_GRID();
|
|
ctx->score = oldscore;
|
|
have_legal_move = true;
|
|
}
|
|
RESTORE_GRID();
|
|
|
|
memset(&merged_grid, 0, SPACES * sizeof(bool));
|
|
right(false);
|
|
if(memcmp(&old_grid, &ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
RESTORE_GRID();
|
|
ctx->score = oldscore;
|
|
have_legal_move = true;
|
|
}
|
|
ctx->score = oldscore;
|
|
if(!have_legal_move)
|
|
{
|
|
/* no more legal moves */
|
|
draw(); /* Shame the player */
|
|
rb->splash(HZ*2, "Game Over!");
|
|
return true;
|
|
}
|
|
|
|
for(int y = 0;y < GRID_SIZE; ++y)
|
|
{
|
|
for(int x = 0; x < GRID_SIZE; ++x)
|
|
{
|
|
if(ctx->grid[x][y] == WINNING_TILE && !ctx->already_won)
|
|
{
|
|
/* Let the user see the tile in its full glory... */
|
|
draw();
|
|
ctx->already_won = true;
|
|
rb->splash(HZ*2,"You win!");
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* loads highscores from disk */
|
|
/* creates an empty structure if the file does not exist */
|
|
static void load_hs(void)
|
|
{
|
|
if(rb->file_exists(HISCORES_FILE))
|
|
highscore_load(HISCORES_FILE, highscores, NUM_SCORES);
|
|
else
|
|
memset(highscores, 0, sizeof(struct highscore) * NUM_SCORES);
|
|
}
|
|
|
|
/* initialize the data structures */
|
|
static void init_game(bool newgame)
|
|
{
|
|
best_score = highscores[0].score;
|
|
if(loaded && ctx->score > best_score)
|
|
best_score = ctx->score;
|
|
|
|
if(newgame)
|
|
{
|
|
/* initialize the game context */
|
|
memset(ctx->grid, 0, sizeof(ctx->grid));
|
|
for(int i = 0; i < NUM_STARTING_TILES; ++i)
|
|
{
|
|
place_random();
|
|
}
|
|
ctx->score = 0;
|
|
ctx->already_won = false;
|
|
}
|
|
|
|
/* using the menu resets the font */
|
|
/* set it again here */
|
|
|
|
rb->lcd_setfont(WHAT_FONT);
|
|
|
|
/* Now calculate font sizes */
|
|
/* Now get the height of the font */
|
|
rb->font_getstringsize("0123456789", NULL, &max_numeral_height, WHAT_FONT);
|
|
max_numeral_height += VERT_SPACING;
|
|
|
|
#if LCD_DEPTH <= 1
|
|
max_numeral_width = rb->font_get_width(rb->font_get(WHAT_FONT), '0');
|
|
#endif
|
|
|
|
backlight_ignore_timeout();
|
|
draw();
|
|
}
|
|
|
|
/* save the current game state */
|
|
static void save_game(void)
|
|
{
|
|
rb->splash(0, "Saving...");
|
|
int fd = rb->open(RESUME_FILE, O_WRONLY|O_CREAT, 0666);
|
|
if(fd < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* calculate checksum */
|
|
ctx->cksum = 0;
|
|
|
|
for(int x = 0; x < GRID_SIZE; ++x)
|
|
for(int y = 0; y < GRID_SIZE; ++y)
|
|
ctx->cksum += ctx->grid[x][y];
|
|
|
|
ctx->cksum ^= ctx->score;
|
|
|
|
rb->write(fd, ctx, sizeof(struct game_ctx_t));
|
|
rb->close(fd);
|
|
rb->lcd_update();
|
|
}
|
|
|
|
/* loads a saved game, returns true on success */
|
|
static bool load_game(void)
|
|
{
|
|
int success = 0;
|
|
int fd = rb->open(RESUME_FILE, O_RDONLY);
|
|
if(fd < 0)
|
|
{
|
|
rb->remove(RESUME_FILE);
|
|
return false;
|
|
}
|
|
|
|
int numread = rb->read(fd, ctx, sizeof(struct game_ctx_t));
|
|
|
|
/* verify checksum */
|
|
unsigned int calc = 0;
|
|
for(int x = 0; x < GRID_SIZE; ++x)
|
|
for(int y = 0; y < GRID_SIZE; ++y)
|
|
calc += ctx->grid[x][y];
|
|
|
|
calc ^= ctx->score;
|
|
|
|
if(numread == sizeof(struct game_ctx_t) && calc == ctx->cksum)
|
|
++success;
|
|
|
|
rb->close(fd);
|
|
rb->remove(RESUME_FILE);
|
|
|
|
return (success > 0);
|
|
}
|
|
|
|
/* update the highscores with ctx->score */
|
|
static void hs_check_update(bool noshow)
|
|
{
|
|
/* first, find the biggest tile to show as the level */
|
|
unsigned int biggest = 0;
|
|
for(int x = 0; x < GRID_SIZE; ++x)
|
|
{
|
|
for(int y = 0; y < GRID_SIZE; ++y)
|
|
{
|
|
if(ctx->grid[x][y] > biggest)
|
|
biggest = ctx->grid[x][y];
|
|
}
|
|
}
|
|
|
|
int hs_idx = highscore_update(ctx->score,biggest, "", highscores,NUM_SCORES);
|
|
if(!noshow)
|
|
{
|
|
/* show the scores if there is a new high score */
|
|
if(hs_idx >= 0)
|
|
{
|
|
rb->splashf(HZ*2, "New High Score: %d", ctx->score);
|
|
rb->lcd_clear_display();
|
|
highscore_show(hs_idx, highscores, NUM_SCORES, true);
|
|
}
|
|
}
|
|
highscore_save(HISCORES_FILE, highscores, NUM_SCORES);
|
|
}
|
|
|
|
/* asks the user if they wish to quit */
|
|
static bool confirm_quit(void)
|
|
{
|
|
const struct text_message prompt = { (const char*[]) {"Are you sure?", "This will clear your current game."}, 2};
|
|
enum yesno_res response = rb->gui_syncyesno_run(&prompt, NULL, NULL);
|
|
if(response == YESNO_NO)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
/* show the pause menu */
|
|
static int do_2048_pause_menu(void)
|
|
{
|
|
int sel = 0;
|
|
MENUITEM_STRINGLIST(menu,"2048 Menu", NULL,
|
|
"Resume Game",
|
|
"Start New Game",
|
|
"High Scores",
|
|
"Playback Control",
|
|
"Help",
|
|
"Quit without Saving",
|
|
"Quit");
|
|
bool quit = false;
|
|
while(!quit)
|
|
{
|
|
switch(rb->do_menu(&menu, &sel, NULL, false))
|
|
{
|
|
case 0:
|
|
draw();
|
|
return 0;
|
|
case 1:
|
|
{
|
|
if(!confirm_quit())
|
|
break;
|
|
else
|
|
{
|
|
hs_check_update(false);
|
|
return 1;
|
|
}
|
|
}
|
|
case 2:
|
|
highscore_show(-1, highscores, NUM_SCORES, true);
|
|
break;
|
|
case 3:
|
|
playback_control(NULL);
|
|
break;
|
|
case 4:
|
|
do_help();
|
|
break;
|
|
case 5: /* quit w/o saving */
|
|
{
|
|
if(!confirm_quit())
|
|
break;
|
|
else
|
|
{
|
|
return 2;
|
|
}
|
|
}
|
|
case 6:
|
|
return 3;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void exit_handler(void)
|
|
{
|
|
cleanup();
|
|
if(abnormal_exit)
|
|
save_game();
|
|
#ifdef HAVE_ADJUSTABLE_CPU_FREQ
|
|
rb->cpu_boost(false); /* back to idle */
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
static bool check_hs;
|
|
|
|
/* main game loop */
|
|
static enum plugin_status do_game(bool newgame)
|
|
{
|
|
init_game(newgame);
|
|
rb_atexit(exit_handler);
|
|
int made_move = 0;
|
|
while(1)
|
|
{
|
|
#ifdef HAVE_ADJUSTABLE_CPU_FREQ
|
|
rb->cpu_boost(false); /* Save battery when idling */
|
|
#endif
|
|
/* Wait for a button press */
|
|
int button = pluginlib_getaction(-1, plugin_contexts, ARRAYLEN(plugin_contexts));
|
|
made_move = 0;
|
|
|
|
memset(&merged_grid, 0, SPACES*sizeof(bool));
|
|
memcpy(&old_grid, &ctx->grid, sizeof(int)*SPACES);
|
|
|
|
unsigned int grid_before_anim_step[GRID_SIZE][GRID_SIZE];
|
|
|
|
#ifdef HAVE_ADJUSTABLE_CPU_FREQ
|
|
rb->cpu_boost(true); /* doing work now... */
|
|
#endif
|
|
switch(button)
|
|
{
|
|
case KEY_UP:
|
|
for(int i = 0; i < GRID_SIZE - 1; ++i)
|
|
{
|
|
memcpy(grid_before_anim_step, ctx->grid, sizeof(ctx->grid));
|
|
up(true);
|
|
if(memcmp(grid_before_anim_step, ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
rb->sleep(ANIM_SLEEPTIME);
|
|
draw();
|
|
}
|
|
}
|
|
made_move = 1;
|
|
break;
|
|
case KEY_DOWN:
|
|
for(int i = 0; i < GRID_SIZE - 1; ++i)
|
|
{
|
|
memcpy(grid_before_anim_step, ctx->grid, sizeof(ctx->grid));
|
|
down(true);
|
|
if(memcmp(grid_before_anim_step, ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
rb->sleep(ANIM_SLEEPTIME);
|
|
draw();
|
|
}
|
|
}
|
|
made_move = 1;
|
|
break;
|
|
case KEY_LEFT:
|
|
for(int i = 0; i < GRID_SIZE - 1; ++i)
|
|
{
|
|
memcpy(grid_before_anim_step, ctx->grid, sizeof(ctx->grid));
|
|
left(true);
|
|
if(memcmp(grid_before_anim_step, ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
rb->sleep(ANIM_SLEEPTIME);
|
|
draw();
|
|
}
|
|
}
|
|
made_move = 1;
|
|
break;
|
|
case KEY_RIGHT:
|
|
for(int i = 0; i < GRID_SIZE - 1; ++i)
|
|
{
|
|
memcpy(grid_before_anim_step, ctx->grid, sizeof(ctx->grid));
|
|
right(true);
|
|
if(memcmp(grid_before_anim_step, ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
rb->sleep(ANIM_SLEEPTIME);
|
|
draw();
|
|
}
|
|
}
|
|
made_move = 1;
|
|
break;
|
|
case KEY_EXIT:
|
|
switch(do_2048_pause_menu())
|
|
{
|
|
case 0: /* resume */
|
|
break;
|
|
case 1: /* new game */
|
|
init_game(true);
|
|
made_move = 1;
|
|
continue;
|
|
case 2: /* quit without saving */
|
|
check_hs = true;
|
|
rb->remove(RESUME_FILE);
|
|
return PLUGIN_ERROR;
|
|
case 3: /* save and quit */
|
|
check_hs = false;
|
|
save_game();
|
|
return PLUGIN_ERROR;
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
exit_on_usb(button); /* handle poweroff and USB events */
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(made_move)
|
|
{
|
|
/* Check if any tiles moved, then add random */
|
|
if(memcmp(&old_grid, ctx->grid, sizeof(ctx->grid)))
|
|
{
|
|
place_random();
|
|
}
|
|
memcpy(&old_grid, ctx->grid, sizeof(ctx->grid));
|
|
if(check_gameover())
|
|
return PLUGIN_OK;
|
|
draw();
|
|
}
|
|
#ifdef HAVE_ADJUSTABLE_CPU_FREQ
|
|
rb->cpu_boost(false); /* back to idle */
|
|
#endif
|
|
rb->yield();
|
|
}
|
|
}
|
|
|
|
/* decide if this_item should be shown in the main menu */
|
|
/* used to hide resume option when there is no save */
|
|
static int mainmenu_cb(int action,
|
|
const struct menu_item_ex *this_item,
|
|
struct gui_synclist *this_list)
|
|
{
|
|
(void)this_list;
|
|
int idx = ((intptr_t)this_item);
|
|
if(action == ACTION_REQUEST_MENUITEM && !loaded && (idx == 0 || idx == 5))
|
|
return ACTION_EXIT_MENUITEM;
|
|
return action;
|
|
}
|
|
|
|
/* show the main menu */
|
|
static enum plugin_status do_2048_menu(void)
|
|
{
|
|
int sel = 0;
|
|
loaded = load_game();
|
|
MENUITEM_STRINGLIST(menu,
|
|
"2048 Menu",
|
|
mainmenu_cb,
|
|
"Resume Game",
|
|
"Start New Game",
|
|
"High Scores",
|
|
"Playback Control",
|
|
"Help",
|
|
"Quit without Saving",
|
|
"Quit");
|
|
bool quit = false;
|
|
while(!quit)
|
|
{
|
|
switch(rb->do_menu(&menu, &sel, NULL, false))
|
|
{
|
|
case 0: /* Start new game or resume a game */
|
|
case 1:
|
|
{
|
|
if(sel == 1 && loaded)
|
|
{
|
|
if(!confirm_quit())
|
|
break;
|
|
}
|
|
enum plugin_status ret = do_game(sel == 1);
|
|
switch(ret)
|
|
{
|
|
case PLUGIN_OK:
|
|
{
|
|
loaded = false;
|
|
rb->remove(RESUME_FILE);
|
|
hs_check_update(false);
|
|
break;
|
|
}
|
|
case PLUGIN_USB_CONNECTED:
|
|
save_game();
|
|
/* Don't bother showing the high scores... */
|
|
return ret;
|
|
case PLUGIN_ERROR: /* exit without menu */
|
|
if(check_hs)
|
|
hs_check_update(false);
|
|
return PLUGIN_OK;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
highscore_show(-1, highscores, NUM_SCORES, true);
|
|
break;
|
|
case 3:
|
|
playback_control(NULL);
|
|
break;
|
|
case 4:
|
|
do_help();
|
|
break;
|
|
case 5:
|
|
if(confirm_quit())
|
|
return PLUGIN_OK;
|
|
case 6:
|
|
if(loaded)
|
|
save_game();
|
|
return PLUGIN_OK;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return PLUGIN_OK;
|
|
}
|
|
|
|
/* plugin entry point */
|
|
enum plugin_status plugin_start(const void* param)
|
|
{
|
|
(void)param;
|
|
rb->srand(*rb->current_tick);
|
|
load_hs();
|
|
rb->lcd_setfont(WHAT_FONT);
|
|
|
|
/* now start the game menu */
|
|
enum plugin_status ret = do_2048_menu();
|
|
|
|
highscore_save(HISCORES_FILE, highscores, NUM_SCORES);
|
|
cleanup();
|
|
|
|
abnormal_exit = false;
|
|
|
|
return ret;
|
|
}
|