len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2025-10-13 18:17:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

calendar: fix bug when add new event text longer than last entry.

Browse source 
blackjack: fix bug that bet becomes 10 when resume saved game.
bubbles: save high level to sparate file.
clix, spacerocks, jewels, bubbles: correct text of menu item.
wormlet: clean up code: removed unused defines and functions.
pluginlib display_text: insert sleep so that the screen doesn't quit immediately.

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@22143 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Teruaki Kawashima 2009-08-03 16:30:08 +00:00
parent 3228756324
commit 2357ec4178
9 changed files with 410 additions and 743 deletions
Download patch file Download diff file Expand all files Collapse all files

280
apps/plugins/blackjack.c
View file

@ -406,7 +406,7 @@ struct highscore highest[NUM_SCORES];
#endif #endif
#ifdef HAVE_TOUCHSCREEN #ifdef HAVE_TOUCHSCREEN
#ifndef BJACK_DOUBLEDOWN #ifndef BJACK_DOUBLEDOWN
#define BJACK_DOUBLEDOWN BUTTON_MIDLEFT #define BJACK_DOUBLEDOWN BUTTON_MIDLEFT
#define BJACK_DOUBLE_NAME "BUTTON_MIDLEFT" #define BJACK_DOUBLE_NAME "BUTTON_MIDLEFT"
#endif #endif
@ -475,27 +475,26 @@ typedef struct card {
typedef struct game_context { typedef struct game_context {
struct card player_cards[2][22]; /* 22 Cards means the deal was all aces */ struct card player_cards[2][22]; /* 22 Cards means the deal was all aces */
struct card dealer_cards[22]; /* That is the worst-case scenario */ struct card dealer_cards[22]; /* That is the worst-case scenario */
unsigned int player_total; unsigned int player_total;
unsigned int dealer_total; unsigned int dealer_total;
signed int player_money; signed int player_money;
unsigned int num_player_cards[2]; unsigned int num_player_cards[2];
unsigned int num_dealer_cards; unsigned int num_dealer_cards;
unsigned int current_bet; unsigned int current_bet;
unsigned int split_status; /* 0 = split hasn't been asked, * unsigned int split_status; /* 0 = split hasn't been asked, *
* 1 = split did not occur * * 1 = split did not occur *
* 2 = split occurred * * 2 = split occurred *
* 3 = split occurred and 1st hand done */ * 3 = split occurred and 1st hand done */
bool is_blackjack; bool is_blackjack;
bool end_hand; bool end_hand;
bool asked_insurance; bool asked_insurance;
bool resume; bool resume;
bool dirty;
} game_context; } game_context;
/***************************************************************************** /*****************************************************************************
* blackjack_init() initializes blackjack data structures. * blackjack_init() initializes blackjack data structures.
******************************************************************************/ ******************************************************************************/
static void blackjack_init(struct game_context* bj) { static void blackjack_init(struct game_context* bj) {
/* seed the rand generator */ /* seed the rand generator */
rb->srand(*rb->current_tick); rb->srand(*rb->current_tick);
@ -504,7 +503,7 @@ static void blackjack_init(struct game_context* bj) {
dealer_y = LCD_HEIGHT/4 - CARD_HEIGHT/2; dealer_y = LCD_HEIGHT/4 - CARD_HEIGHT/2;
player_x = 4; player_x = 4;
player_y = LCD_HEIGHT - LCD_HEIGHT/4 - CARD_HEIGHT/2; player_y = LCD_HEIGHT - LCD_HEIGHT/4 - CARD_HEIGHT/2;
/* check for resumed game */ /* check for resumed game */
if(bj->resume) return; if(bj->resume) return;
@ -517,7 +516,7 @@ static void blackjack_init(struct game_context* bj) {
bj->end_hand = false; bj->end_hand = false;
bj->split_status = 0; bj->split_status = 0;
bj->is_blackjack = false; bj->is_blackjack = false;
bj->asked_insurance = false; bj->asked_insurance = false;
} }
/***************************************************************************** /*****************************************************************************
@ -526,7 +525,7 @@ static void blackjack_init(struct game_context* bj) {
static void blackjack_drawtable(struct game_context* bj) { static void blackjack_drawtable(struct game_context* bj) {
unsigned int w, h, y_loc; unsigned int w, h, y_loc;
char str[10]; char str[10];
#if LCD_HEIGHT <= 64 #if LCD_HEIGHT <= 64
rb->lcd_getstringsize("Bet", &w, &h); rb->lcd_getstringsize("Bet", &w, &h);
rb->lcd_putsxy(LCD_WIDTH - w, 2*h + 1, "Bet"); rb->lcd_putsxy(LCD_WIDTH - w, 2*h + 1, "Bet");
@ -577,19 +576,19 @@ static unsigned int find_value(unsigned int number) {
/***************************************************************************** /*****************************************************************************
* draw_card() draws a card to the screen. * draw_card() draws a card to the screen.
******************************************************************************/ ******************************************************************************/
static void draw_card(struct card temp_card, bool shown, unsigned int x, static void draw_card(struct card temp_card, bool shown,
unsigned int y) { unsigned int x, unsigned int y) {
if(shown) if(shown)
rb->lcd_bitmap_part(card_deck, CARD_WIDTH*temp_card.num, rb->lcd_bitmap_part(card_deck, CARD_WIDTH*temp_card.num,
CARD_HEIGHT*temp_card.suit, BMPWIDTH_card_deck, CARD_HEIGHT*temp_card.suit, BMPWIDTH_card_deck,
x+1, y+1, CARD_WIDTH, CARD_HEIGHT); x+1, y+1, CARD_WIDTH, CARD_HEIGHT);
else else
rb->lcd_bitmap(card_back, x+1, y+1,CARD_WIDTH, CARD_HEIGHT); rb->lcd_bitmap(card_back, x+1, y+1,CARD_WIDTH, CARD_HEIGHT);
#if LCD_DEPTH > 1 #if LCD_DEPTH > 1
rb->lcd_set_foreground(LCD_BLACK); rb->lcd_set_foreground(LCD_BLACK);
#endif #endif
/* Print outlines */ /* Print outlines */
#if CARD_WIDTH >= 26 #if CARD_WIDTH >= 26
rb->lcd_hline(x+2, x+CARD_WIDTH-1, y); rb->lcd_hline(x+2, x+CARD_WIDTH-1, y);
rb->lcd_hline(x+2, x+CARD_WIDTH-1, y+CARD_HEIGHT+1); rb->lcd_hline(x+2, x+CARD_WIDTH-1, y+CARD_HEIGHT+1);
@ -618,7 +617,7 @@ static struct card new_card(void) {
struct card new_card; struct card new_card;
new_card.suit = rb->rand()%4; /* Random number 0-3 */ new_card.suit = rb->rand()%4; /* Random number 0-3 */
new_card.num = rb->rand()%13; /* Random number 0-12 */ new_card.num = rb->rand()%13; /* Random number 0-12 */
new_card.value = find_value(new_card.num); new_card.value = find_value(new_card.num);
new_card.is_soft_ace = new_card.num == 0 ? true : false; new_card.is_soft_ace = new_card.num == 0 ? true : false;
return new_card; return new_card;
} }
@ -645,7 +644,7 @@ static void deal_init_cards(struct game_context* bj) {
bj->player_cards[0][1] = new_card(); bj->player_cards[0][1] = new_card();
bj->player_total += bj->player_cards[0][1].value; bj->player_total += bj->player_cards[0][1].value;
draw_card(bj->player_cards[0][1], true, player_x, player_y); draw_card(bj->player_cards[0][1], true, player_x, player_y);
player_x += CARD_WIDTH + 4; player_x += CARD_WIDTH + 4;
} }
/***************************************************************************** /*****************************************************************************
@ -669,7 +668,7 @@ static void redraw_board(struct game_context* bj) {
dealer_x += CARD_WIDTH + 4; dealer_x += CARD_WIDTH + 4;
} }
draw_card(bj->dealer_cards[i], true, dealer_x, dealer_y); draw_card(bj->dealer_cards[i], true, dealer_x, dealer_y);
if (bj->num_dealer_cards > MAX_CARDS-1) if (bj->num_dealer_cards > MAX_CARDS-1)
dealer_x += 10; dealer_x += 10;
else else
@ -682,7 +681,7 @@ static void redraw_board(struct game_context* bj) {
if (bj->split_status>1 || bj->num_player_cards[n]>MAX_CARDS) if (bj->split_status>1 || bj->num_player_cards[n]>MAX_CARDS)
player_x += 10; player_x += 10;
else else
player_x += CARD_WIDTH + 4; player_x += CARD_WIDTH + 4;
} }
if (bj->split_status > 1) if (bj->split_status > 1)
player_x = LCD_WIDTH/2 + 4; player_x = LCD_WIDTH/2 + 4;
@ -709,12 +708,11 @@ static void update_total(struct game_context* bj) {
* check_for_aces() is passed an array of cards and returns where an ace is * check_for_aces() is passed an array of cards and returns where an ace is
* located. Otherwise, returns -1. * located. Otherwise, returns -1.
******************************************************************************/ ******************************************************************************/
static signed int check_for_aces(struct card temp_cards[], static signed int check_for_aces(struct card temp_cards[], unsigned int size) {
unsigned int size) {
unsigned int i; unsigned int i;
for(i = 0; i < size; i++) { for(i = 0; i < size; i++) {
if (temp_cards[i].is_soft_ace == true) if (temp_cards[i].is_soft_ace == true)
return i; return i;
} }
return -1; return -1;
} }
@ -723,26 +721,26 @@ static signed int check_for_aces(struct card temp_cards[],
* check_totals() compares player and dealer totals. * check_totals() compares player and dealer totals.
* 0: bust 1: loss, 2: push, 3: win, 4: blackjack, 5: something's not right... * 0: bust 1: loss, 2: push, 3: win, 4: blackjack, 5: something's not right...
******************************************************************************/ ******************************************************************************/
static unsigned int check_totals(struct game_context* bj) static unsigned int check_totals(struct game_context* bj) {
{
unsigned int temp; unsigned int temp;
if (bj->player_total > 21) if (bj->player_total > 21)
temp = 0; temp = 0;
else if (bj->player_total == 21 && bj->is_blackjack) else if (bj->player_total == 21 && bj->is_blackjack) {
if (bj->dealer_total == 21 && bj->num_dealer_cards == 2) if (bj->dealer_total == 21 && bj->num_dealer_cards == 2)
temp = 2; temp = 2;
else else
temp = 4; temp = 4;
}
else if (bj->player_total == bj->dealer_total) else if (bj->player_total == bj->dealer_total)
temp = 2; temp = 2;
else if (bj->dealer_total > 21 && bj->player_total < 22) else if (bj->dealer_total > 21 && bj->player_total < 22)
temp = 3; temp = 3;
else if (bj->dealer_total > bj->player_total) else if (bj->dealer_total > bj->player_total)
temp = 1; temp = 1;
else if (bj->player_total > bj->dealer_total) else if (bj->player_total > bj->dealer_total)
temp = 3; temp = 3;
else else
temp = 5; temp = 5;
return temp; return temp;
} }
@ -752,24 +750,24 @@ static unsigned int check_totals(struct game_context* bj)
******************************************************************************/ ******************************************************************************/
static void finish_dealer(struct game_context* bj) { static void finish_dealer(struct game_context* bj) {
signed int temp = 0; signed int temp = 0;
if (bj->dealer_total > 16 && bj->dealer_total < 22) if (bj->dealer_total > 16 && bj->dealer_total < 22)
return; return;
while (bj->dealer_total < 17) { while (bj->dealer_total < 17) {
bj->dealer_cards[bj->num_dealer_cards] = new_card(); bj->dealer_cards[bj->num_dealer_cards] = new_card();
bj->dealer_total += bj->dealer_cards[bj->num_dealer_cards].value; bj->dealer_total += bj->dealer_cards[bj->num_dealer_cards].value;
bj->num_dealer_cards++; bj->num_dealer_cards++;
} }
while (bj->dealer_total > 21) { while (bj->dealer_total > 21) {
temp = check_for_aces(bj->dealer_cards, bj->num_dealer_cards); temp = check_for_aces(bj->dealer_cards, bj->num_dealer_cards);
if(temp != -1) { if(temp != -1) {
bj->dealer_cards[temp].is_soft_ace = false; bj->dealer_cards[temp].is_soft_ace = false;
bj->dealer_total -= 10; bj->dealer_total -= 10;
} }
else else
return; return;
} }
} }
@ -783,31 +781,31 @@ static void finish_game(struct game_context* bj) {
do { do {
finish_dealer(bj); finish_dealer(bj);
} while (bj->dealer_total < 17); } while (bj->dealer_total < 17);
redraw_board(bj); redraw_board(bj);
rValue = check_totals(bj); rValue = check_totals(bj);
if (rValue == 0) { if (rValue == 0) {
rb->snprintf(str, sizeof(str), " Bust! "); rb->snprintf(str, sizeof(str), " Bust! ");
bj->player_money -= bj->current_bet; bj->player_money -= bj->current_bet;
} }
else if (rValue == 1) { else if (rValue == 1) {
rb->snprintf(str, sizeof(str), " Sorry, you lost. "); rb->snprintf(str, sizeof(str), " Sorry, you lost. ");
bj->player_money -= bj->current_bet; bj->player_money -= bj->current_bet;
} }
else if (rValue == 2) { else if (rValue == 2) {
rb->snprintf(str, sizeof(str), " Push "); rb->snprintf(str, sizeof(str), " Push ");
} }
else if (rValue == 3) { else if (rValue == 3) {
rb->snprintf(str, sizeof(str), " You won! "); rb->snprintf(str, sizeof(str), " You won! ");
bj->player_money+= bj->current_bet; bj->player_money+= bj->current_bet;
} }
else { else {
rb->snprintf(str, sizeof(str), " Blackjack! "); rb->snprintf(str, sizeof(str), " Blackjack! ");
bj->player_money += bj->current_bet * 3 / 2; bj->player_money += bj->current_bet * 3 / 2;
} }
rb->lcd_getstringsize(str, &w, &h); rb->lcd_getstringsize(str, &w, &h);
#if LCD_HEIGHT <= 64 #if LCD_HEIGHT <= 64
rb->lcd_set_drawmode(DRMODE_BG+DRMODE_INVERSEVID); rb->lcd_set_drawmode(DRMODE_BG+DRMODE_INVERSEVID);
rb->lcd_fillrect(0, LCD_HEIGHT/2, LCD_WIDTH, LCD_HEIGHT/2); rb->lcd_fillrect(0, LCD_HEIGHT/2, LCD_WIDTH, LCD_HEIGHT/2);
@ -835,7 +833,7 @@ static bool blackjack_loadgame(struct game_context* bj) {
/* read in saved game */ /* read in saved game */
while(true) { while(true) {
if(rb->read(fd, &bj->player_money, sizeof(bj->player_money)) <= 0) if(rb->read(fd, &bj->player_money, sizeof(bj->player_money)) <= 0)
break; break;
if(rb->read(fd, &bj->player_total, sizeof(bj->player_total)) <= 0) if(rb->read(fd, &bj->player_total, sizeof(bj->player_total)) <= 0)
break; break;
@ -845,19 +843,19 @@ static bool blackjack_loadgame(struct game_context* bj) {
break; break;
if(rb->read(fd, &bj->num_dealer_cards, sizeof(bj->num_dealer_cards))<=0) if(rb->read(fd, &bj->num_dealer_cards, sizeof(bj->num_dealer_cards))<=0)
break; break;
if(rb->read(fd, &bj->current_bet, sizeof(bj->current_bet)) <= 0) if(rb->read(fd, &bj->current_bet, sizeof(bj->current_bet)) <= 0)
break; break;
if(rb->read(fd, &bj->is_blackjack, sizeof(bj->is_blackjack)) <= 0) if(rb->read(fd, &bj->is_blackjack, sizeof(bj->is_blackjack)) <= 0)
break; break;
if(rb->read(fd, &bj->split_status, sizeof(bj->split_status)) <= 0) if(rb->read(fd, &bj->split_status, sizeof(bj->split_status)) <= 0)
break; break;
if(rb->read(fd, &bj->asked_insurance, sizeof(bj->asked_insurance)) <= 0) if(rb->read(fd, &bj->asked_insurance, sizeof(bj->asked_insurance)) <= 0)
break; break;
if(rb->read(fd, &bj->end_hand, sizeof(bj->end_hand)) <= 0) if(rb->read(fd, &bj->end_hand, sizeof(bj->end_hand)) <= 0)
break; break;
if(rb->read(fd, &bj->player_cards, sizeof(bj->player_cards)) <= 0) if(rb->read(fd, &bj->player_cards, sizeof(bj->player_cards)) <= 0)
break; break;
if(rb->read(fd, &bj->dealer_cards, sizeof(bj->dealer_cards)) <= 0) if(rb->read(fd, &bj->dealer_cards, sizeof(bj->dealer_cards)) <= 0)
break; break;
bj->resume = true; bj->resume = true;
loaded = true; loaded = true;
@ -911,7 +909,7 @@ static unsigned int blackjack_get_yes_no(char message[20]) {
rb->strcat(message_no, " No"); rb->strcat(message_no, " No");
rb->lcd_getstringsize(message_yes, &w, &h); rb->lcd_getstringsize(message_yes, &w, &h);
const char *stg[] = {message_yes, message_no}; const char *stg[] = {message_yes, message_no};
#if LCD_HEIGHT <= 64 #if LCD_HEIGHT <= 64
b = 2*h+1; b = 2*h+1;
#else #else
@ -928,10 +926,10 @@ static unsigned int blackjack_get_yes_no(char message[20]) {
rb->lcd_set_drawmode(DRMODE_SOLID); rb->lcd_set_drawmode(DRMODE_SOLID);
#endif #endif
rb->lcd_drawrect(LCD_WIDTH/2 - w/2 - 1, LCD_HEIGHT/2 + b - 1, w+3, h+4); rb->lcd_drawrect(LCD_WIDTH/2 - w/2 - 1, LCD_HEIGHT/2 + b - 1, w+3, h+4);
while(!breakout) { while(!breakout) {
rb->lcd_putsxy(LCD_WIDTH/2 - w/2, LCD_HEIGHT/2 + b +1, stg[choice]); rb->lcd_putsxy(LCD_WIDTH/2 - w/2, LCD_HEIGHT/2 + b +1, stg[choice]);
rb->lcd_update_rect(LCD_WIDTH/2 - w/2 - 1, LCD_HEIGHT/2 + b -1, rb->lcd_update_rect(LCD_WIDTH/2 - w/2 - 1, LCD_HEIGHT/2 + b -1,
w+3, h+4); w+3, h+4);
button = rb->button_get(true); button = rb->button_get(true);
@ -949,7 +947,7 @@ static unsigned int blackjack_get_yes_no(char message[20]) {
break; break;
} }
} }
#if LCD_DEPTH > 1 #if LCD_DEPTH > 1
rb->lcd_set_foreground(FG_COLOR); rb->lcd_set_foreground(FG_COLOR);
rb->lcd_set_background(BG_COLOR); rb->lcd_set_background(BG_COLOR);
@ -961,16 +959,16 @@ static unsigned int blackjack_get_yes_no(char message[20]) {
* blackjack_get_amount() gets an amount from the player to be used * blackjack_get_amount() gets an amount from the player to be used
******************************************************************************/ ******************************************************************************/
static signed int blackjack_get_amount(char message[20], signed int lower_limit, static signed int blackjack_get_amount(char message[20], signed int lower_limit,
signed int upper_limit, signed int upper_limit,
signed int start) { signed int start) {
int button; int button;
char str[6]; char str[9];
bool changed = false; bool changed = false;
unsigned int w, h; unsigned int w, h;
signed int amount; signed int amount;
rb->lcd_getstringsize("A", &w, &h); /* find the size of one character */ rb->lcd_getstringsize("A", &w, &h); /* find the size of one character */
if (start > upper_limit) if (start > upper_limit)
amount = upper_limit; amount = upper_limit;
else if (start < lower_limit) else if (start < lower_limit)
@ -995,11 +993,11 @@ static signed int blackjack_get_amount(char message[20], signed int lower_limit,
rb->lcd_update(); rb->lcd_update();
#else #else
rb->lcd_set_drawmode(DRMODE_BG+DRMODE_INVERSEVID); rb->lcd_set_drawmode(DRMODE_BG+DRMODE_INVERSEVID);
rb->lcd_fillrect(LCD_WIDTH/2 - 9*w - 1, LCD_HEIGHT/2 - 4*h - 3, 37*w / 2, rb->lcd_fillrect(LCD_WIDTH/2 - 9*w - 1, LCD_HEIGHT/2 - 4*h - 3,
8*h -3); 37*w / 2, 8*h -3);
rb->lcd_set_drawmode(DRMODE_SOLID); rb->lcd_set_drawmode(DRMODE_SOLID);
rb->lcd_drawrect(LCD_WIDTH/2 - 9*w - 1, LCD_HEIGHT/2 - 4*h - 3, 37*w / 2, rb->lcd_drawrect(LCD_WIDTH/2 - 9*w - 1, LCD_HEIGHT/2 - 4*h - 3,
8*h -3); 37*w / 2, 8*h -3);
rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 4*h - 1, message); rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 4*h - 1, message);
rb->snprintf(str, 9, "$%d", amount); rb->snprintf(str, 9, "$%d", amount);
rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 3*h, str); rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 3*h, str);
@ -1021,21 +1019,21 @@ static signed int blackjack_get_amount(char message[20], signed int lower_limit,
rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + h, "UP: +10"); rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + h, "UP: +10");
rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + 2*h + 1, "DOWN: -10"); rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + 2*h + 1, "DOWN: -10");
#endif #endif
rb->lcd_update_rect(LCD_WIDTH/2 - 9*w - 2, LCD_HEIGHT/2 - 9*h/2, 37*w/2 + 1, rb->lcd_update_rect(LCD_WIDTH/2 - 9*w - 1, LCD_HEIGHT/2 - 4*h - 3,
8*h-2); 37*w / 2, 8*h -3);
#endif #endif
while(true) { while(true) {
button = rb->button_get(true); button = rb->button_get(true);
switch(button) { switch(button) {
case BJACK_UP: case BJACK_UP:
case (BJACK_UP|BUTTON_REPEAT): case (BJACK_UP|BUTTON_REPEAT):
if (amount + 10 < upper_limit + 1) { if (amount + 10 < upper_limit + 1) {
amount += 10; amount += 10;
changed = true; changed = true;
} }
break; break;
case BJACK_DOWN: case BJACK_DOWN:
case (BJACK_DOWN|BUTTON_REPEAT): case (BJACK_DOWN|BUTTON_REPEAT):
if (amount - 10 > lower_limit - 1) { if (amount - 10 > lower_limit - 1) {
@ -1074,9 +1072,9 @@ static signed int blackjack_get_amount(char message[20], signed int lower_limit,
#endif #endif
rb->lcd_clear_display(); rb->lcd_clear_display();
return amount; return amount;
} }
if(changed) { if(changed) {
rb->snprintf(str, 9, "$%d", amount); rb->snprintf(str, 9, "$%d", amount);
#if LCD_HEIGHT <= 64 #if LCD_HEIGHT <= 64
rb->lcd_puts(0, 2, str); rb->lcd_puts(0, 2, str);
@ -1097,7 +1095,7 @@ static signed int blackjack_get_amount(char message[20], signed int lower_limit,
* blackjack_get_bet() gets the player's bet. * blackjack_get_bet() gets the player's bet.
******************************************************************************/ ******************************************************************************/
static void blackjack_get_bet(struct game_context* bj) { static void blackjack_get_bet(struct game_context* bj) {
bj->current_bet = blackjack_get_amount("Please enter a bet", 10, bj->current_bet = blackjack_get_amount("Please enter a bet", 10,
bj->player_money, bj->current_bet); bj->player_money, bj->current_bet);
} }
@ -1133,11 +1131,11 @@ static void split(struct game_context* bj) {
* insurance() see if the player wants to buy insurance and how much. * insurance() see if the player wants to buy insurance and how much.
******************************************************************************/ ******************************************************************************/
static unsigned int insurance(struct game_context* bj) { static unsigned int insurance(struct game_context* bj) {
unsigned int insurance, max_amount; unsigned int insurance, max_amount;
insurance = blackjack_get_yes_no("Buy Insurance?"); insurance = blackjack_get_yes_no("Buy Insurance?");
bj->asked_insurance = true; bj->asked_insurance = true;
max_amount = bj->current_bet < (unsigned int)bj->player_money ? max_amount = bj->current_bet < (unsigned int)bj->player_money ?
bj->current_bet/2 : (unsigned int)bj->player_money; bj->current_bet/2 : (unsigned int)bj->player_money;
if (insurance == 1) return 0; if (insurance == 1) return 0;
@ -1153,7 +1151,10 @@ static unsigned int play_again(void) {
return blackjack_get_yes_no("Play Again?"); return blackjack_get_yes_no("Play Again?");
} }
void showhelp(void) { /*****************************************************************************
* blackjack_help() displays help text.
******************************************************************************/
static bool blackjack_help(void) {
#define WORDS (sizeof help_text / sizeof (char*)) #define WORDS (sizeof help_text / sizeof (char*))
static char *help_text[] = { static char *help_text[] = {
"Blackjack", "", "Blackjack", "",
@ -1184,16 +1185,16 @@ void showhelp(void) {
#endif #endif
if (display_text(WORDS, help_text, formation, NULL)) if (display_text(WORDS, help_text, formation, NULL))
return; return true;
do { do {
button = rb->button_get(true); button = rb->button_get(true);
if (rb->default_event_handler(button) == SYS_USB_CONNECTED) { if (rb->default_event_handler(button) == SYS_USB_CONNECTED) {
return; return true;
} }
} while( ( button == BUTTON_NONE ) } while( ( button == BUTTON_NONE )
|| ( button & (BUTTON_REL|BUTTON_REPEAT) ) ); || ( button & (BUTTON_REL|BUTTON_REPEAT) ) );
rb->lcd_setfont(FONT_SYSFIXED); rb->lcd_setfont(FONT_SYSFIXED);
return; return false;
} }
/***************************************************************************** /*****************************************************************************
@ -1202,9 +1203,11 @@ void showhelp(void) {
static unsigned int blackjack_menu(struct game_context* bj) { static unsigned int blackjack_menu(struct game_context* bj) {
int selection=0; int selection=0;
bool breakout = false; bool breakout = false;
MENUITEM_STRINGLIST(menu,"BlackJack Menu",NULL,"Start Game","Resume Game", MENUITEM_STRINGLIST(menu, "BlackJack Menu", NULL,
"High Scores", "Help", "Playback Control", "Quit"); "Start Game","Resume Game",
"High Scores", "Help",
"Playback Control", "Quit");
while(!breakout) { while(!breakout) {
switch(rb->do_menu(&menu, &selection, NULL, false)) { switch(rb->do_menu(&menu, &selection, NULL, false)) {
@ -1215,7 +1218,6 @@ static unsigned int blackjack_menu(struct game_context* bj) {
if(!blackjack_loadgame(bj)) { if(!blackjack_loadgame(bj)) {
rb->splash(HZ*2, "Nothing to resume"); rb->splash(HZ*2, "Nothing to resume");
} else { } else {
rb->splash(HZ*2, "Loading...");
breakout = true; breakout = true;
} }
break; break;
@ -1223,18 +1225,19 @@ static unsigned int blackjack_menu(struct game_context* bj) {
highscore_show(NUM_SCORES, highest, NUM_SCORES, false); highscore_show(NUM_SCORES, highest, NUM_SCORES, false);
break; break;
case 3: case 3:
showhelp(); if(blackjack_help())
return BJ_USB;
break; break;
case 4: case 4:
if (playback_control(NULL)) if (playback_control(NULL))
return 1; return BJ_USB;
break; break;
case 5: case 5:
return BJ_QUIT; return BJ_QUIT;
case MENU_ATTACHED_USB: case MENU_ATTACHED_USB:
return BJ_USB; return BJ_USB;
default: default:
break; break;
} }
@ -1253,6 +1256,11 @@ static int blackjack(struct game_context* bj) {
bool breakout = false; bool breakout = false;
bool dbl_down = false; bool dbl_down = false;
#if LCD_DEPTH > 1
rb->lcd_set_background(BG_COLOR);
rb->lcd_set_foreground(FG_COLOR);
#endif
/* don't resume by default */ /* don't resume by default */
bj->resume = false; bj->resume = false;
@ -1268,7 +1276,6 @@ static int blackjack(struct game_context* bj) {
* init * * init *
********************/ ********************/
blackjack_init(bj); blackjack_init(bj);
bj->current_bet=10;
/******************** /********************
* play * * play *
@ -1279,21 +1286,21 @@ static int blackjack(struct game_context* bj) {
bj->resume = false; bj->resume = false;
redraw_board(bj); redraw_board(bj);
if (bj->split_status == 2) { if (bj->split_status == 2) {
todo=2; todo=2;
player_x = bj->num_player_cards[0] * 10 + 4; player_x = bj->num_player_cards[0] * 10 + 4;
} }
else if (bj->split_status == 3) { else if (bj->split_status == 3) {
player_x = bj->num_player_cards[1] * 10 + LCD_WIDTH/2 + 4; player_x = bj->num_player_cards[1] * 10 + LCD_WIDTH/2 + 4;
todo=2; todo=2;
done=1; done=1;
} }
} }
else { else {
bj->player_money = 1000; bj->player_money = 1000;
bj->current_bet = 10;
blackjack_get_bet(bj); blackjack_get_bet(bj);
if (bj->current_bet == 0) if (bj->current_bet == 0)
return BJ_QUIT; return -1;
rb->lcd_clear_display(); rb->lcd_clear_display();
deal_init_cards(bj); deal_init_cards(bj);
blackjack_drawtable(bj); blackjack_drawtable(bj);
@ -1309,7 +1316,7 @@ static int blackjack(struct game_context* bj) {
bj->end_hand = true; bj->end_hand = true;
finish_game(bj); finish_game(bj);
} }
else if(bj->dealer_cards[1].is_soft_ace && !breakout && else if(bj->dealer_cards[1].is_soft_ace && !breakout &&
!bj->asked_insurance) { !bj->asked_insurance) {
temp_var = insurance(bj); temp_var = insurance(bj);
if (bj->dealer_total == 21) { if (bj->dealer_total == 21) {
@ -1328,7 +1335,7 @@ static int blackjack(struct game_context* bj) {
rb->lcd_update(); rb->lcd_update();
} }
} }
if(!bj->end_hand && bj->split_status == 0 && if(!bj->end_hand && bj->split_status == 0 &&
bj->player_cards[0][0].num == bj->player_cards[0][1].num) { bj->player_cards[0][0].num == bj->player_cards[0][1].num) {
split(bj); split(bj);
redraw_board(bj); redraw_board(bj);
@ -1350,16 +1357,16 @@ static int blackjack(struct game_context* bj) {
bj->num_player_cards[done]++; bj->num_player_cards[done]++;
if (bj->num_player_cards[done] == MAX_CARDS + 1) { if (bj->num_player_cards[done] == MAX_CARDS + 1) {
redraw_board(bj); redraw_board(bj);
rb->lcd_update_rect(0, LCD_HEIGHT/2, LCD_WIDTH, rb->lcd_update_rect(0, LCD_HEIGHT/2, LCD_WIDTH,
LCD_HEIGHT/2); LCD_HEIGHT/2);
} }
else if (bj->num_player_cards[done]>MAX_CARDS || todo > 1) { else if (bj->num_player_cards[done]>MAX_CARDS || todo > 1) {
rb->lcd_update_rect(player_x, player_y, CARD_WIDTH+2, rb->lcd_update_rect(player_x, player_y, CARD_WIDTH+2,
CARD_HEIGHT+2); CARD_HEIGHT+2);
player_x += 10; player_x += 10;
} }
else { else {
rb->lcd_update_rect(player_x, player_y, CARD_WIDTH+2, rb->lcd_update_rect(player_x, player_y, CARD_WIDTH+2,
CARD_HEIGHT+2); CARD_HEIGHT+2);
player_x += CARD_WIDTH + 4; player_x += CARD_WIDTH + 4;
} }
@ -1370,7 +1377,8 @@ static int blackjack(struct game_context* bj) {
bj->end_hand = true; bj->end_hand = true;
break; break;
case BJACK_DOUBLEDOWN: case BJACK_DOUBLEDOWN:
if ((signed int)bj->current_bet * 2 < bj->player_money + 1&& if ((signed int)bj->current_bet * 2 <
bj->player_money + 1 &&
bj->num_player_cards[0]==2 && todo==1) { bj->num_player_cards[0]==2 && todo==1) {
double_down(bj); double_down(bj);
dbl_down = true; dbl_down = true;
@ -1379,7 +1387,8 @@ static int blackjack(struct game_context* bj) {
finish_game(bj); finish_game(bj);
} }
} }
else if((signed int)bj->current_bet * 2 > bj->player_money){ else if((signed int)bj->current_bet * 2 >
bj->player_money){
rb->splash(HZ, "Not enough money to double down."); rb->splash(HZ, "Not enough money to double down.");
redraw_board(bj); redraw_board(bj);
rb->lcd_update(); rb->lcd_update();
@ -1395,7 +1404,7 @@ static int blackjack(struct game_context* bj) {
} }
while (bj->player_total > 21 && !bj->end_hand) { while (bj->player_total > 21 && !bj->end_hand) {
temp = check_for_aces(bj->player_cards[done], temp = check_for_aces(bj->player_cards[done],
bj->num_player_cards[done]); bj->num_player_cards[done]);
if(temp != -1) { if(temp != -1) {
bj->player_cards[done][temp].is_soft_ace = false; bj->player_cards[done][temp].is_soft_ace = false;
@ -1409,7 +1418,7 @@ static int blackjack(struct game_context* bj) {
else else
bj->end_hand = true; bj->end_hand = true;
} }
if (bj->end_hand) { if (bj->end_hand) {
done++; done++;
if(todo > 1) { if(todo > 1) {
@ -1426,7 +1435,7 @@ static int blackjack(struct game_context* bj) {
bj->current_bet /= 2; bj->current_bet /= 2;
rb->lcd_update_rect(LCD_WIDTH/2-w/2, LCD_HEIGHT/2-3*h/2, rb->lcd_update_rect(LCD_WIDTH/2-w/2, LCD_HEIGHT/2-3*h/2,
w,h); w,h);
rb->sleep(HZ*2); rb->sleep(HZ*2);
bj->player_total = temp_var; bj->player_total = temp_var;
finish_game(bj); finish_game(bj);
rb->lcd_getstringsize(" Split 2 ", &w, &h); rb->lcd_getstringsize(" Split 2 ", &w, &h);
@ -1446,7 +1455,7 @@ static int blackjack(struct game_context* bj) {
player_x += 10; player_x += 10;
rb->lcd_update(); rb->lcd_update();
} }
} }
else else
finish_game(bj); finish_game(bj);
} }
@ -1462,7 +1471,11 @@ static int blackjack(struct game_context* bj) {
return BJ_END; return BJ_END;
else { /* User keeps playing */ else { /* User keeps playing */
breakout = false; breakout = false;
temp = bj->current_bet;
bj->current_bet = 0;
redraw_board(bj); redraw_board(bj);
rb->lcd_update();
bj->current_bet = temp;
if(dbl_down) { if(dbl_down) {
bj->current_bet /= 2; bj->current_bet /= 2;
dbl_down = false; dbl_down = false;
@ -1477,7 +1490,7 @@ static int blackjack(struct game_context* bj) {
blackjack_drawtable(bj); blackjack_drawtable(bj);
rb->lcd_update(); rb->lcd_update();
} }
} }
} }
/* Never reached */ /* Never reached */
return PLUGIN_OK; return PLUGIN_OK;
@ -1509,33 +1522,26 @@ enum plugin_status plugin_start(const void* parameter)
/* fall through to BJ_END */ /* fall through to BJ_END */
case BJ_END: case BJ_END:
if(!bj.resume) { if(!bj.resume && bj.player_money > 10) {
/* There is no level, so store -1 to blank column */ /* There is no level, so store -1 to blank column */
int position = highscore_update(bj.player_money, -1, "", int position = highscore_update(bj.player_money, -1, "",
highest, NUM_SCORES); highest, NUM_SCORES);
if (position == 0) { if (position == 0) {
rb->splash(HZ*2, "New High Score"); rb->splash(HZ*2, "New High Score");
} }
if (position != -1) { if (position != -1) {
highscore_show(position, highest, NUM_SCORES, false); highscore_show(position, highest, NUM_SCORES, false);
bj.dirty=true;
} else {
rb->sleep(3);
} }
} }
break; break;
case BJ_USB: case BJ_USB:
rb->lcd_setfont(FONT_UI); rb->lcd_setfont(FONT_UI);
if(bj.dirty) { highscore_save(HIGH_SCORE,highest,NUM_SCORES);
highscore_save(HIGH_SCORE,highest,NUM_SCORES);
}
return PLUGIN_USB_CONNECTED; return PLUGIN_USB_CONNECTED;
case BJ_QUIT: case BJ_QUIT:
if(bj.dirty) { highscore_save(HIGH_SCORE,highest,NUM_SCORES);
highscore_save(HIGH_SCORE,highest,NUM_SCORES);
}
exit = true; exit = true;
break; break;

130
apps/plugins/bubbles.c
View file

@ -36,12 +36,13 @@ PLUGIN_HEADER
/* files */ /* files */
#define SCORE_FILE PLUGIN_GAMES_DIR "/bubbles.score" #define SCORE_FILE PLUGIN_GAMES_DIR "/bubbles.score"
#define SAVE_FILE PLUGIN_GAMES_DIR "/bubbles.save" #define SAVE_FILE PLUGIN_GAMES_DIR "/bubbles.save"
#define DATA_FILE PLUGIN_GAMES_DIR "/bubbles.data"
/* final game return status */ /* final game return status */
enum { enum {
BB_LOSE, BB_LOSE,
BB_QUIT, BB_QUIT,
BB_QUIT_AND_SAVE, BB_SAVE_AND_QUIT,
BB_USB, BB_USB,
BB_END, BB_END,
BB_WIN, BB_WIN,
@ -1241,7 +1242,6 @@ struct tile {
/* the game context struct /* the game context struct
* score is the current score * score is the current score
* level is the current level * level is the current level
* highlevel is the highest level beaten
* angle is the current cannon direction * angle is the current cannon direction
* shots is the number of shots fired since last compression * shots is the number of shots fired since last compression
* compress is the height of the compressor * compress is the height of the compressor
@ -1252,13 +1252,11 @@ struct tile {
* elapsedlvl is level elapsed time in 1/100s of seconds * elapsedlvl is level elapsed time in 1/100s of seconds
* elapsedshot is the shot elapsed time in 1/100s of seconds * elapsedshot is the shot elapsed time in 1/100s of seconds
* startedshot is when the current shot began * startedshot is when the current shot began
* resume denotes whether to resume the currently loaded game
* playboard is the game playing board * playboard is the game playing board
*/ */
struct game_context { struct game_context {
unsigned int score; unsigned int score;
unsigned int level; unsigned int level;
unsigned int highlevel;
int angle; int angle;
int shots; int shots;
int compress; int compress;
@ -1276,6 +1274,8 @@ struct highscore highscores[NUM_SCORES];
/* used to denote available resume info */ /* used to denote available resume info */
static bool resume = false; static bool resume = false;
static unsigned int highlevel = 0; /* the highest level beaten */
static unsigned int last_highlevel = 0;
static void bubbles_init(struct game_context* bb); static void bubbles_init(struct game_context* bb);
static bool bubbles_nextlevel(struct game_context* bb); static bool bubbles_nextlevel(struct game_context* bb);
@ -1291,7 +1291,6 @@ static void bubbles_anchored(struct game_context* bb, int row, int col);
static int bubbles_fall(struct game_context* bb); static int bubbles_fall(struct game_context* bb);
static int bubbles_checklevel(struct game_context* bb); static int bubbles_checklevel(struct game_context* bb);
static void bubbles_recordscore(struct game_context* bb); static void bubbles_recordscore(struct game_context* bb);
static void bubbles_savescores(struct game_context* bb);
static bool bubbles_loadgame(struct game_context* bb); static bool bubbles_loadgame(struct game_context* bb);
static void bubbles_savegame(struct game_context* bb); static void bubbles_savegame(struct game_context* bb);
static inline void bubbles_setcolors(void); static inline void bubbles_setcolors(void);
@ -1326,15 +1325,14 @@ static void bubbles_init(struct game_context* bb) {
static bool bubbles_nextlevel(struct game_context* bb) { static bool bubbles_nextlevel(struct game_context* bb) {
int i, j, pos; int i, j, pos;
/* save highest level */
if (bb->level > bb->highlevel)
bb->highlevel = bb->level;
bb->level++; bb->level++;
/* check if there are no more levels */ /* check if there are no more levels */
if(bb->level > NUM_LEVELS) return false; if(bb->level > NUM_LEVELS) return false;
/* save highest level */
if (bb->level-1 > highlevel)
highlevel = bb->level-1;
/* set up the play board */ /* set up the play board */
rb->memset(bb->playboard, 0, sizeof(bb->playboard)); rb->memset(bb->playboard, 0, sizeof(bb->playboard));
@ -2165,7 +2163,7 @@ static void bubbles_recordscore(struct game_context* bb) {
int position; int position;
position = highscore_update(bb->score, bb->level, "", position = highscore_update(bb->score, bb->level-1, "",
highscores, NUM_SCORES); highscores, NUM_SCORES);
if (position==0) if (position==0)
rb->splash(HZ*2, "New High Score"); rb->splash(HZ*2, "New High Score");
@ -2174,36 +2172,43 @@ static void bubbles_recordscore(struct game_context* bb) {
} }
/***************************************************************************** /*****************************************************************************
* bubbles_loadscores() loads the high scores saved file. * bubbles_loaddata() loads highest level beaten.
******************************************************************************/ ******************************************************************************/
static void bubbles_loadscores(struct game_context* bb) { static void bubbles_loaddata(void) {
int fd;
int i; last_highlevel = highlevel = 0;
int highlevel = 0; /* open data file */
/* highlevel and highscores */ fd = rb->open(DATA_FILE, O_RDONLY);
highscore_load(SCORE_FILE, highscores, NUM_SCORES); if (fd < 0) return;
/* level X in the high scores means one succeeded the level before (X-1) */ /* read in saved game */
for (i = 0; i < NUM_SCORES; i++) if (rb->read(fd, &highlevel, sizeof(highlevel)) < (long)sizeof(highlevel))
{ {
if (highscores[i].level-1 > highlevel) highlevel = 0;
{
highlevel = highscores[i].level-1;
}
} }
if (highlevel >= NUM_LEVELS)
highlevel = NUM_LEVELS-1;
last_highlevel = highlevel;
if (bb->highlevel < (unsigned)highlevel) rb->close(fd);
bb->highlevel = highlevel;
} }
/***************************************************************************** /*****************************************************************************
* bubbles_savescores() saves the high scores saved file. * bubbles_savedata() saves the current game state.
******************************************************************************/ ******************************************************************************/
static void bubbles_savescores(struct game_context* bb) { static void bubbles_savedata(void) {
int fd;
/* highscores */ if (last_highlevel >= highlevel) /* no need to save */
(void)bb; return;
highscore_save(SCORE_FILE, highscores, NUM_SCORES+1);
fd = rb->open(DATA_FILE, O_WRONLY|O_CREAT);
if (fd < 0) return;
rb->write(fd, &highlevel, sizeof(highlevel));
rb->close(fd);
} }
/***************************************************************************** /*****************************************************************************
@ -2225,6 +2230,9 @@ static bool bubbles_loadgame(struct game_context* bb) {
} }
rb->close(fd); rb->close(fd);
/* delete saved file */
rb->remove(SAVE_FILE);
return ret; return ret;
} }
@ -2266,8 +2274,8 @@ static inline void bubbles_setcolors(void) {
* on usb connect and shutdown. * on usb connect and shutdown.
******************************************************************************/ ******************************************************************************/
static void bubbles_callback(void* param) { static void bubbles_callback(void* param) {
struct game_context* bb = (struct game_context*) param; (void) param;
bubbles_savescores(bb); highscore_save(SCORE_FILE, highscores, NUM_SCORES);
} }
/***************************************************************************** /*****************************************************************************
@ -2353,23 +2361,20 @@ static int bubbles_handlebuttons(struct game_context* bb, bool animblock,
} }
/***************************************************************************** /*****************************************************************************
* bubbles() is the main game subroutine, it returns the final game status. * bubbles_menu() is the initial menu at the start of the game.
******************************************************************************/ ******************************************************************************/
static int bubbles(struct game_context* bb) { static int bubbles_menu(struct game_context* bb) {
int buttonres; static unsigned int startlevel = 0;
unsigned int startlevel = 0; int selected = resume?0:1;
bool startgame = false; bool startgame = false;
long timeout;
/********************
* menu *
********************/
MENUITEM_STRINGLIST(menu,"Bubbles Menu",NULL, MENUITEM_STRINGLIST(menu,"Bubbles Menu",NULL,
"Resume Game", "Start New Game", "Resume Game", "Start New Game",
"Level", "High Scores", "Playback Control", "Level", "High Scores", "Playback Control",
"Quit", "Quit and Save"); "Quit", "Save and Quit");
while(!startgame){ while(!startgame){
switch (rb->do_menu(&menu, NULL, NULL, false)) switch (rb->do_menu(&menu, &selected, NULL, false))
{ {
case 0: /* resume game */ case 0: /* resume game */
if (!resume) if (!resume)
@ -2379,11 +2384,8 @@ static int bubbles(struct game_context* bb) {
} }
else else
{ {
startlevel = bb->level - 1;
startgame = true; startgame = true;
} }
/* delete saved file */
rb->remove(SAVE_FILE);
break; break;
case 1: /* new game */ case 1: /* new game */
bb->level = startlevel; bb->level = startlevel;
@ -2393,7 +2395,7 @@ static int bubbles(struct game_context* bb) {
case 2: /* choose level */ case 2: /* choose level */
startlevel++; startlevel++;
rb->set_int("Choose start level", "", UNIT_INT, &startlevel, rb->set_int("Choose start level", "", UNIT_INT, &startlevel,
NULL, 1, 1, MIN(NUM_LEVELS,bb->highlevel+1), NULL); NULL, 1, 1, highlevel+1, NULL);
startlevel--; startlevel--;
break; break;
case 3: /* High scores */ case 3: /* High scores */
@ -2404,13 +2406,30 @@ static int bubbles(struct game_context* bb) {
break; break;
case 5: /* quit */ case 5: /* quit */
return BB_QUIT; return BB_QUIT;
case 6: /* quit and save */ case 6: /* save and quit */
return BB_QUIT_AND_SAVE; return BB_SAVE_AND_QUIT;
case MENU_ATTACHED_USB: case MENU_ATTACHED_USB:
bubbles_callback(bb); bubbles_callback(bb);
return BB_USB; return BB_USB;
} }
} }
return 0;
}
/*****************************************************************************
* bubbles() is the main game subroutine, it returns the final game status.
******************************************************************************/
static int bubbles(struct game_context* bb) {
int buttonres;
long timeout;
/********************
* menu *
********************/
buttonres = bubbles_menu(bb);
if(buttonres != 0)
return buttonres;
/******************** /********************
* init * * init *
********************/ ********************/
@ -2464,13 +2483,12 @@ enum plugin_status plugin_start(const void* parameter) {
bool exit = false; bool exit = false;
enum plugin_status ret = PLUGIN_OK; enum plugin_status ret = PLUGIN_OK;
/* plugin init */
(void)parameter; (void)parameter;
/* end of plugin init */
/* load files */ /* load files */
resume = bubbles_loadgame(&bb); resume = bubbles_loadgame(&bb);
bubbles_loadscores(&bb); bubbles_loaddata();
highscore_load(SCORE_FILE, highscores, NUM_SCORES);
rb->lcd_clear_display(); rb->lcd_clear_display();
/* start app */ /* start app */
@ -2484,7 +2502,7 @@ enum plugin_status plugin_start(const void* parameter) {
case BB_WIN: case BB_WIN:
rb->splash(HZ*2, "You Win!"); rb->splash(HZ*2, "You Win!");
/* record high level */ /* record high level */
bb.highlevel = NUM_LEVELS; highlevel = NUM_LEVELS-1;
/* record high score */ /* record high score */
bubbles_recordscore(&bb); bubbles_recordscore(&bb);
break; break;
@ -2501,15 +2519,17 @@ enum plugin_status plugin_start(const void* parameter) {
case BB_USB: case BB_USB:
ret = PLUGIN_USB_CONNECTED; ret = PLUGIN_USB_CONNECTED;
exit = true;
break; break;
case BB_QUIT_AND_SAVE: case BB_SAVE_AND_QUIT:
rb->splash(HZ/2, "Saving Game and Scors"); rb->splash(HZ/2, "Saving Game ...");
bubbles_savescores(&bb);
bubbles_savegame(&bb); bubbles_savegame(&bb);
/* fall through */ /* fall through */
case BB_QUIT: case BB_QUIT:
bubbles_savedata();
highscore_save(SCORE_FILE, highscores, NUM_SCORES);
exit = true; exit = true;
break; break;

138
apps/plugins/calendar.c
View file

@ -272,7 +272,7 @@ static int is_leap_year(int yr)
(!((yr) % 4) && ((yr) % 100)) || !((yr) % 400)) ? 1:0 ; (!((yr) % 4) && ((yr) % 100)) || !((yr) % 400)) ? 1:0 ;
} }
/* searches the weekday of the first day in month, /* searches the weekday of the first day in month,
* relative to the given values */ * relative to the given values */
static int calc_weekday( struct shown *shown ) static int calc_weekday( struct shown *shown )
{ {
@ -343,19 +343,9 @@ static void draw_calendar(struct shown *shown)
int x,y,pos,days_per_month,j; int x,y,pos,days_per_month,j;
char buffer[9]; char buffer[9];
const char *monthname[] = { const char *monthname[] = {
"Jan", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Feb", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
"Mar", };
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
};
if(use_system_font) if(use_system_font)
rb->lcd_setfont(FONT_SYSFIXED); rb->lcd_setfont(FONT_SYSFIXED);
rb->lcd_getstringsize("A",&w,&h); rb->lcd_getstringsize("A",&w,&h);
@ -421,7 +411,7 @@ static int memos_in_shown_memory = 0;
static void load_memo(struct shown *shown) static void load_memo(struct shown *shown)
{ {
int i, k, fp; int k, fp;
bool exit = false; bool exit = false;
char temp_memo1[2]; char temp_memo1[2];
char temp_memo2[3]; char temp_memo2[3];
@ -429,18 +419,6 @@ static void load_memo(struct shown *shown)
temp_memo1[1] = 0; temp_memo1[1] = 0;
temp_memo2[2] = 0; temp_memo2[2] = 0;
temp_memo4[4] = 0; temp_memo4[4] = 0;
for (k = 0; k < memos_in_memory; k++)
{
memos[k].day = 0;
memos[k].month = 0;
memos[k].file_pointer_start = 0;
memos[k].file_pointer_end = 0;
memos[k].year = 0;
memos[k].type = 0;
memos[k].wday = 0;
for (i = 0; i < MAX_CHAR_MEMO_LEN; i++)
memos[k].message[i] = 0;
}
for (k = 1; k < 32; k++) for (k = 1; k < 32; k++)
day_has_memo[k] = false; day_has_memo[k] = false;
for (k = 0; k < 7; k++) for (k = 0; k < 7; k++)
@ -449,12 +427,13 @@ static void load_memo(struct shown *shown)
fp = rb->open(ROCKBOX_DIR "/.memo",O_RDONLY); fp = rb->open(ROCKBOX_DIR "/.memo",O_RDONLY);
if (fp > -1) if (fp > -1)
{ {
int count = rb->filesize(fp);
rb->lseek(fp, 0, SEEK_SET); rb->lseek(fp, 0, SEEK_SET);
while (!exit) while (!exit)
{ {
memos[memos_in_memory].file_pointer_start = rb->lseek(fp, 0, bool load_to_memory;
SEEK_CUR); rb->memset(&memos[memos_in_memory].message, 0, MAX_CHAR_MEMO_LEN);
memos[memos_in_memory].file_pointer_start =
rb->lseek(fp, 0, SEEK_CUR);
if (rb->read(fp, temp_memo2, 2) == 2) if (rb->read(fp, temp_memo2, 2) == 2)
memos[memos_in_memory].day = rb->atoi(&temp_memo2[0]); memos[memos_in_memory].day = rb->atoi(&temp_memo2[0]);
else else
@ -472,7 +451,7 @@ static void load_memo(struct shown *shown)
if (memos[memos_in_memory].year > (shown->year * 10)) if (memos[memos_in_memory].year > (shown->year * 10))
memos[memos_in_memory].year = (memos[memos_in_memory].year - memos[memos_in_memory].year = (memos[memos_in_memory].year -
memos[memos_in_memory].month) / memos[memos_in_memory].month) /
100; 100;
if (rb->read(fp, temp_memo1, 1) == 1) if (rb->read(fp, temp_memo1, 1) == 1)
memos[memos_in_memory].wday = rb->atoi(&temp_memo1[0]); memos[memos_in_memory].wday = rb->atoi(&temp_memo1[0]);
else else
@ -481,48 +460,16 @@ static void load_memo(struct shown *shown)
memos[memos_in_memory].type = rb->atoi(&temp_memo1[0]); memos[memos_in_memory].type = rb->atoi(&temp_memo1[0]);
else else
memos[memos_in_memory].type = 0; memos[memos_in_memory].type = 0;
for (k = 0; k <= count; k++) load_to_memory = ((memos[memos_in_memory].type < 2) ||
((memos[memos_in_memory].type == 2) &&
(memos[memos_in_memory].month == shown->mon)) ||
((memos[memos_in_memory].type > 2) &&
(memos[memos_in_memory].month == shown->mon) &&
(memos[memos_in_memory].year == shown->year)));
k = 0;
while (1)
{ {
if (rb->read(fp, temp_memo1, 1) == 1) if (rb->read(fp, temp_memo1, 1) != 1)
{
if (
(memos[memos_in_memory].type < 2)
||
(
(memos[memos_in_memory].type == 2)
&&
(memos[memos_in_memory].month == shown->mon)
)
||
(
(memos[memos_in_memory].type > 2)
&&
(memos[memos_in_memory].month == shown->mon)
&&
(memos[memos_in_memory].year == shown->year)
)
)
{
if (temp_memo1[0] == '\n')
{
if (memos[memos_in_memory].type > 0)
day_has_memo[memos[memos_in_memory].day] =
true;
else
wday_has_memo[memos[memos_in_memory].wday] =
true;
memos[memos_in_memory++].file_pointer_end =
rb->lseek(fp, 0, SEEK_CUR);
}
else if ( (temp_memo1[0] != '\r') &&
(temp_memo1[0] != '\t') &&
k < MAX_CHAR_MEMO_LEN-1 )
memos[memos_in_memory].message[k] = temp_memo1[0];
}
if (temp_memo1[0] == '\n')
break;
}
else
{ {
memos[memos_in_memory].day = 0; memos[memos_in_memory].day = 0;
memos[memos_in_memory].month = 0; memos[memos_in_memory].month = 0;
@ -535,6 +482,26 @@ static void load_memo(struct shown *shown)
exit = true; exit = true;
break; break;
} }
if (load_to_memory)
{
if (temp_memo1[0] == '\n')
{
if (memos[memos_in_memory].type > 0)
day_has_memo[memos[memos_in_memory].day] =
true;
else
wday_has_memo[memos[memos_in_memory].wday] =
true;
memos[memos_in_memory++].file_pointer_end =
rb->lseek(fp, 0, SEEK_CUR);
}
else if ( (temp_memo1[0] != '\r') &&
(temp_memo1[0] != '\t') &&
k < MAX_CHAR_MEMO_LEN-1 )
memos[memos_in_memory].message[k++] = temp_memo1[0];
}
if (temp_memo1[0] == '\n')
break;
} }
} }
} }
@ -546,7 +513,7 @@ static bool save_memo(int changed, bool new_mod, struct shown *shown)
int fp,fq; int fp,fq;
fp = rb->open(ROCKBOX_DIR "/.memo",O_RDONLY | O_CREAT); fp = rb->open(ROCKBOX_DIR "/.memo",O_RDONLY | O_CREAT);
fq = rb->creat(ROCKBOX_DIR "/~temp"); fq = rb->creat(ROCKBOX_DIR "/~temp");
if ( (fq != -1) && (fp != -1) ) if ( (fq > -1) && (fp > -1) )
{ {
int i; int i;
char temp[MAX_CHAR_MEMO_LEN]; char temp[MAX_CHAR_MEMO_LEN];
@ -578,9 +545,9 @@ static bool save_memo(int changed, bool new_mod, struct shown *shown)
load_memo(shown); load_memo(shown);
return true; return true;
} }
else if (fp != -1) else if (fp > -1)
rb->close(fp); rb->close(fp);
else if (fq != -1) else if (fq > -1)
rb->close(fq); rb->close(fq);
return false; return false;
} }
@ -714,7 +681,7 @@ static bool view_events(int selected, struct shown *shown)
rb->gui_synclist_set_nb_items(&gui_memos, memos_in_shown_memory); rb->gui_synclist_set_nb_items(&gui_memos, memos_in_shown_memory);
rb->gui_synclist_select_item(&gui_memos, selected); rb->gui_synclist_select_item(&gui_memos, selected);
rb->gui_synclist_draw(&gui_memos); rb->gui_synclist_draw(&gui_memos);
while (!exit) while (!exit)
{ {
button = rb->get_action(CONTEXT_LIST,TIMEOUT_BLOCK); button = rb->get_action(CONTEXT_LIST,TIMEOUT_BLOCK);
@ -746,19 +713,10 @@ static void update_memos_shown(struct shown *shown)
int i; int i;
memos_in_shown_memory = 0; memos_in_shown_memory = 0;
for (i = 0; i < memos_in_memory; i++) for (i = 0; i < memos_in_memory; i++)
if ( if (((memos[i].type >= 1) &&
( (memos[i].day == shown->mday)) ||
(memos[i].type >= 1) ((memos[i].type < 1) &&
&& (memos[i].wday == shown->wday)))
(memos[i].day == shown->mday)
)
||
(
(memos[i].type < 1)
&&
(memos[i].wday == shown->wday)
)
)
pointer_array[memos_in_shown_memory++] = i; pointer_array[memos_in_shown_memory++] = i;
} }
@ -836,7 +794,7 @@ enum plugin_status plugin_start(const void* parameter)
struct shown shown; struct shown shown;
bool exit = false; bool exit = false;
int button; int button;
(void)(parameter); (void)(parameter);
calendar_init(&today, &shown); calendar_init(&today, &shown);

2
apps/plugins/clix.c
View file

@ -605,7 +605,7 @@ static int clix_menu(struct clix_game_state_t* state, bool ingame)
"Resume Game", "Resume Game",
"Start New Game", "Start New Game",
"Help", "Help",
"High Score", "High Scores",
"Playback Control", "Playback Control",
"Quit"); "Quit");

2
apps/plugins/jewels.c
View file

@ -1323,7 +1323,7 @@ static int jewels_game_menu(struct game_context* bj, bool ingame)
"Start New Game", "Start New Game",
"Mode", "Mode",
"Help", "Help",
"High Score", "High Scores",
"Playback Control", "Playback Control",
"Quit without Saving", "Quit without Saving",
"Quit"); "Quit");

3
apps/plugins/lib/highscore.c
View file

@ -129,7 +129,6 @@ void highscore_show(int position, struct highscore *scores, int num_scores, bool
rb->lcd_set_background(LCD_BLACK); rb->lcd_set_background(LCD_BLACK);
rb->lcd_set_foreground(LCD_WHITE); rb->lcd_set_foreground(LCD_WHITE);
#endif #endif
rb->button_clear_queue();
rb->lcd_clear_display(); rb->lcd_clear_display();
rb->lcd_setfont(FONT_UI); rb->lcd_setfont(FONT_UI);
@ -174,6 +173,8 @@ void highscore_show(int position, struct highscore *scores, int num_scores, bool
} }
} }
rb->lcd_update(); rb->lcd_update();
rb->sleep(HZ/2);
rb->button_clear_queue();
rb->button_get(true); rb->button_get(true);
rb->lcd_setfont(FONT_SYSFIXED); rb->lcd_setfont(FONT_SYSFIXED);
} }

2
apps/plugins/rocklife.c
View file

@ -77,7 +77,7 @@ PLUGIN_HEADER
#define PATTERN_GROWTH_1 1 #define PATTERN_GROWTH_1 1
#define PATTERN_GROWTH_2 2 #define PATTERN_GROWTH_2 2
#define PATTERN_ACORN 3 #define PATTERN_ACORN 3
#define PATTERN_GLIDER_GUN 4 /* not yet implemented */ #define PATTERN_GLIDER_GUN 4
const struct button_mapping *plugin_contexts[] const struct button_mapping *plugin_contexts[]
= {generic_directions, generic_actions}; = {generic_directions, generic_actions};

2
apps/plugins/spacerocks.c
View file

@ -644,7 +644,7 @@ static int spacerocks_menu(bool ingame)
"Resume Game", "Resume Game",
"Start New Game", "Start New Game",
"Help", "Help",
"High Score", "High Scores",
"Playback Control", "Playback Control",
"Quit"); "Quit");

594
apps/plugins/wormlet.c
View file

File diff suppressed because it is too large Load diff