mirror of
https://github.com/UberGuidoZ/Flipper.git
synced 2024-12-24 23:40:12 +00:00
780 lines
24 KiB
C
780 lines
24 KiB
C
#include "yatzee_icons.h"
|
|
|
|
#include <furi.h>
|
|
#include <furi_hal.h>
|
|
|
|
#include <gui/gui.h>
|
|
#include <gui/elements.h>
|
|
#include <input/input.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#define BASE_X 18
|
|
#define BASE_Y 44
|
|
#define DICE_OFFSET 12
|
|
#define HOLD "*"
|
|
#define MAX_DICE 5
|
|
#define NUM_SCORES 13
|
|
|
|
bool new_game = true;
|
|
bool game_over = false;
|
|
bool bonus_added = false;
|
|
int8_t num_bonus_yatzees = 0;
|
|
|
|
// struct to hold image posistion for dice
|
|
typedef struct {
|
|
// +-----x
|
|
// |
|
|
// |
|
|
// y
|
|
uint8_t x;
|
|
uint8_t y;
|
|
} ImagePosition;
|
|
|
|
|
|
typedef struct {
|
|
char* name;
|
|
uint32_t value;
|
|
bool used;
|
|
int8_t row;
|
|
int8_t col;
|
|
uint8_t (*fn)(); // pointer to function that calculates score
|
|
} Score;
|
|
|
|
typedef struct {
|
|
uint8_t index;
|
|
uint8_t value;
|
|
bool isHeld;
|
|
} Die;
|
|
|
|
typedef struct {
|
|
int index;
|
|
char* symbol;
|
|
} Cursor;
|
|
|
|
// locations for the dice images
|
|
ImagePosition position[5] = {
|
|
{.x = BASE_X-DICE_OFFSET, .y = BASE_Y},
|
|
{.x = BASE_X*2-DICE_OFFSET, .y = BASE_Y},
|
|
{.x = BASE_X*3-DICE_OFFSET, .y = BASE_Y},
|
|
{.x = BASE_X*4-DICE_OFFSET, .y = BASE_Y},
|
|
{.x = BASE_X*5-DICE_OFFSET, .y = BASE_Y},
|
|
};
|
|
|
|
// these are the positions that the score cursor will cycle through
|
|
ImagePosition score_positions[13] = {
|
|
{.x=15, .y=0},
|
|
{.x=15, .y=9},
|
|
{.x=15, .y=18},
|
|
{.x=15, .y=27},
|
|
{.x=44, .y=0},
|
|
{.x=44, .y=9},
|
|
{.x=44, .y=18},
|
|
{.x=44, .y=27},
|
|
{.x=77, .y=0},
|
|
{.x=77, .y=9},
|
|
{.x=77, .y=18},
|
|
{.x=77, .y=27},
|
|
{.x=91, .y=21},
|
|
};
|
|
|
|
// cursor to select dice
|
|
Cursor cursor = {
|
|
.index = 0,
|
|
.symbol = "^"
|
|
};
|
|
|
|
// cursor to select score
|
|
Cursor scoreCursor = {
|
|
.index = -1,
|
|
.symbol = "_"
|
|
};
|
|
|
|
// setup array to store dice info
|
|
Die die[5] = {
|
|
{.index = 0, .value = 1, .isHeld = false},
|
|
{.index = 1, .value = 1, .isHeld = false},
|
|
{.index = 2, .value = 1, .isHeld = false},
|
|
{.index = 3, .value = 1, .isHeld = false},
|
|
{.index = 4, .value = 1, .isHeld = false},
|
|
};
|
|
|
|
uint8_t upperScore = 0;
|
|
int32_t lowerScore = 0;
|
|
int32_t totalScore = 0;
|
|
uint8_t roll = 0;
|
|
uint8_t totalrolls = 0;
|
|
|
|
// #############################################
|
|
// # The following methods add the score for #
|
|
// # whichever number is mentioned. #
|
|
// #############################################
|
|
static uint8_t ones() {
|
|
uint8_t sum = 0;
|
|
for (uint8_t i = 0; i < 5; i++) {
|
|
if (die[i].value == 1) {
|
|
sum++;
|
|
}
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
static uint8_t twos() {
|
|
uint8_t sum = 0;
|
|
for (uint8_t i = 0; i < 5; i++) {
|
|
if (die[i].value == 2) {
|
|
sum = sum+2;
|
|
}
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
static uint8_t threes() {
|
|
uint8_t sum = 0;
|
|
for (uint8_t i = 0; i < 5; i++) {
|
|
if (die[i].value == 3) {
|
|
sum = sum+3;
|
|
}
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
static uint8_t fours() {
|
|
uint8_t sum = 0;
|
|
for (uint8_t i = 0; i < 5; i++) {
|
|
if (die[i].value == 4) {
|
|
sum = sum+4;
|
|
}
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
static uint8_t fives() {
|
|
uint8_t sum = 0;
|
|
for (uint8_t i = 0; i < 5; i++) {
|
|
if (die[i].value == 5) {
|
|
sum = sum+5;
|
|
}
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
static uint8_t sixes() {
|
|
uint8_t sum = 0;
|
|
for (uint8_t i = 0; i < 5; i++) {
|
|
if (die[i].value == 6) {
|
|
sum = sum+6;
|
|
}
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
// ####################################################
|
|
// # Helper methods for the special score types #
|
|
// # defined before them so they can be used #
|
|
// # since this whole thing is a linear mess #
|
|
// # lol. #
|
|
// # add_dice: #
|
|
// # inputs: none #
|
|
// # output: int8_t value of roll #
|
|
// # check_if_score_used:
|
|
// # inputs: Score
|
|
// # output: true if score.used = true
|
|
// # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
int8_t add_dice() {
|
|
int8_t sum = 0;
|
|
for (int8_t i=0; i<MAX_DICE; i++) {
|
|
sum+=die[i].value;
|
|
} return sum;
|
|
}
|
|
|
|
bool check_if_score_used(Score score) {
|
|
if (score.used == true) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// #############################################
|
|
// # Methods to calculate scores for the fancy #
|
|
// # scoring types: 3 of a kind, 4 of a kind, #
|
|
// # Full house, small straight, large straight#
|
|
// # chance & yatzee. #
|
|
// #############################################
|
|
static uint8_t threekind() {
|
|
int8_t score = 0;
|
|
for (int8_t num=1; num<7; num++) {
|
|
int8_t sum = 0;
|
|
|
|
for (int8_t i=0; i<MAX_DICE; i++) {
|
|
if (die[i].value == num) {
|
|
sum++;
|
|
}
|
|
if (sum > 2) {
|
|
score = add_dice();
|
|
}
|
|
}
|
|
}
|
|
return score;
|
|
}
|
|
|
|
static uint8_t fourkind() {
|
|
int8_t score = 0;
|
|
for (int8_t num=1; num<7; num++) {
|
|
int8_t sum = 0;
|
|
|
|
for (int8_t i=0; i<MAX_DICE; i++) {
|
|
if (die[i].value == num) {
|
|
sum++;
|
|
}
|
|
if (sum > 3) {
|
|
score = add_dice();
|
|
}
|
|
}
|
|
}
|
|
return score;
|
|
}
|
|
|
|
static uint8_t fullhouse() {
|
|
|
|
bool check1 = false;
|
|
bool check2 = false;
|
|
int8_t val1 = 0;
|
|
int8_t val2 = 0;
|
|
UNUSED(val2);
|
|
UNUSED(val1);
|
|
|
|
//check 1 for three of a kind
|
|
for (int8_t num=1; num<7; num++) {
|
|
int8_t sum = 0;
|
|
|
|
for (int8_t i=0; i<MAX_DICE; i++) {
|
|
if (die[i].value == num) {
|
|
sum++;
|
|
}
|
|
if (sum > 2) {
|
|
val1 = die[i].value;
|
|
check1 = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// return if check 1 failed
|
|
if (check1 == false) {
|
|
return 0;
|
|
}
|
|
|
|
// check 2 for two of a kind.
|
|
for (int8_t num=1; num<7; num++) {
|
|
if (num==val1) {continue;}
|
|
int8_t sum = 0;
|
|
|
|
for (int8_t i=0; i<MAX_DICE; i++) {
|
|
if (die[i].value == num) {
|
|
sum++;
|
|
}
|
|
if (sum > 1) {
|
|
val2 = die[i].value;
|
|
check2 = true;
|
|
}
|
|
}
|
|
if (check1 && check2) {
|
|
return 25;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
// # I'm dumb so I asked ChatGPT to write the #
|
|
// # smallstraight function for me. Then I adapted it #
|
|
// # fo the largestraight function. #
|
|
// # # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
static uint8_t smallstraight() {
|
|
// Create a new array with the frequencies of the different die faces
|
|
int8_t frequencies[6] = {0};
|
|
|
|
for (int8_t i = 0; i < 5; i++) {
|
|
int8_t face = die[i].value;
|
|
frequencies[face - 1]++;
|
|
}
|
|
|
|
// Check if there is a sequence of 4 consecutive die faces with at least one die
|
|
bool found_small_straight = false;
|
|
for (int i = 0; i < 3 && !found_small_straight; i++) {
|
|
if (frequencies[i] > 0 && frequencies[i + 1] > 0 && frequencies[i + 2] > 0 && frequencies[i + 3] > 0) {
|
|
found_small_straight = true;
|
|
}
|
|
}
|
|
|
|
if (found_small_straight) {
|
|
return 30;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static uint8_t largestraight() {
|
|
// Create a new array with the frequencies of the different die faces
|
|
int8_t frequencies[6] = {0};
|
|
|
|
for (int8_t i = 0; i < 5; i++) {
|
|
int8_t face = die[i].value;
|
|
frequencies[face - 1]++;
|
|
}
|
|
|
|
// Check if there is a sequence of 4 consecutive die faces with at least one die
|
|
bool found_large_straight = false;
|
|
for (int i = 0; i < 3 && !found_large_straight; i++) {
|
|
if (frequencies[i] > 0 && frequencies[i + 1] > 0 && frequencies[i + 2] > 0 && frequencies[i + 3] > 0 && frequencies[i + 4] > 0) {
|
|
found_large_straight = true;
|
|
}
|
|
}
|
|
|
|
if (found_large_straight) {
|
|
return 40;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static uint8_t chance() {
|
|
// chance allows your roll to count for the raw number of pips showing
|
|
int8_t sum = 0;
|
|
for (int8_t i = 0; i<MAX_DICE; i++) {
|
|
sum+=die[i].value;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
static uint8_t yatzee() {
|
|
// checks if all die.values are equal to the first die
|
|
int8_t val = die[0].value;
|
|
for (int8_t i=1; i<MAX_DICE; i++) {
|
|
// if value is the same as the first die, continue to next
|
|
if (die[i].value == val){
|
|
continue;
|
|
} else {
|
|
// if any value is not equal to the first die,
|
|
// this is not a yatzee and we return 0
|
|
return 0;
|
|
}
|
|
}
|
|
return 50;
|
|
}
|
|
|
|
// # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
// # Method to return true if yatzee returns 50 #
|
|
// # #
|
|
// # # # # # # # # # # # # # # # # # # # # # # # # # #
|
|
// static bool check_for_bonus_yatzee() {
|
|
// if (yatzee()==50){
|
|
// return true;
|
|
// } else {
|
|
// return false;
|
|
// }
|
|
// }
|
|
|
|
// Scorecard defined here so that we can use pointers to the functions
|
|
// defined above
|
|
Score scorecard[13] = {
|
|
{.name = "1", .value = 0, .used = false, .row=0, .col=0, .fn = &ones},
|
|
{.name = "2", .value = 0, .used = false, .row=1, .col=0, .fn = &twos},
|
|
{.name = "3", .value = 0, .used = false,.row=2, .col=0, .fn = &threes},
|
|
{.name = "4", .value = 0, .used = false, .row=3, .col=0, .fn = &fours},
|
|
{.name = "5", .value = 0, .used = false, .row=0, .col=1, .fn = &fives},
|
|
{.name = "6", .value = 0, .used = false, .row=1, .col=1, .fn = &sixes},
|
|
{.name = "3k", .value = 0, .used = false, .row=2, .col=1, .fn = &threekind},
|
|
{.name = "4k", .value = 0, .used = false, .row=3, .col=1, .fn = &fourkind},
|
|
{.name = "Fh", .value = 0, .used = false, .row=0, .col=2, .fn = &fullhouse},
|
|
{.name = "Sm", .value = 0, .used = false, .row=1, .col=2, .fn = &smallstraight},
|
|
{.name = "Lg", .value = 0, .used = false, .row=2, .col=2, .fn = &largestraight},
|
|
{.name = "Ch", .value = 0, .used = false, .row=3, .col=2, .fn = &chance},
|
|
{.name = "Yz", .value = 0, .used = false, .row = 2, .col = 3, .fn = &yatzee},
|
|
};
|
|
|
|
|
|
// #############################################
|
|
// # begin draw callback #
|
|
// # #
|
|
// #############################################
|
|
// define the callback for telling ViewPort how to update the screen
|
|
// not sure what ctx is but it seems important
|
|
static void app_draw_callback(Canvas* canvas, void* ctx) {
|
|
UNUSED(ctx);
|
|
canvas_set_font(canvas, FontSecondary); //define a font so we can put letters on the screen
|
|
int8_t selectorOffsetX = 8;
|
|
int8_t selectorOffsetY = 16;
|
|
char buffer[36];
|
|
char bigbuffer[256];
|
|
|
|
canvas_clear(canvas);
|
|
|
|
// if new_game, show user instructions
|
|
if (new_game) {
|
|
canvas_set_font(canvas, FontPrimary);
|
|
elements_multiline_text_aligned(canvas, 64,0, AlignCenter, AlignTop, "Yatzee!");
|
|
canvas_set_font(canvas, FontSecondary);
|
|
snprintf(bigbuffer, sizeof(bigbuffer), "Up: Roll\nLeft/Right: Move cursor\nOK: Hold Die\nDown: Score");
|
|
elements_multiline_text_aligned(canvas, 0, 8, AlignLeft, AlignTop, bigbuffer);
|
|
elements_button_center(canvas, "Start!");
|
|
return;
|
|
|
|
|
|
} else {
|
|
|
|
// draw border lines
|
|
canvas_draw_line(canvas, 0, 37, 104, 37);
|
|
canvas_draw_line(canvas, 104, 0, 104, 64);
|
|
|
|
// iterate through dice and draw icon that correlates to die[n].value, and the x,y position indicated by position[die[i].index]
|
|
for (int8_t i = 0; i < 5; i++) {
|
|
if (die[i].value == 1) {
|
|
canvas_draw_icon(canvas, position[die[i].index].x % 128, position[die[i].index].y % 64, &I_die_1);
|
|
} else if (die[i].value == 2) {
|
|
canvas_draw_icon(canvas, position[die[i].index].x % 128, position[die[i].index].y % 64, &I_die_2);
|
|
} else if (die[i].value == 3) {
|
|
canvas_draw_icon(canvas, position[die[i].index].x % 128, position[die[i].index].y % 64, &I_die_3);
|
|
} else if (die[i].value == 4) {
|
|
canvas_draw_icon(canvas, position[die[i].index].x % 128, position[die[i].index].y % 64, &I_die_4);
|
|
} else if (die[i].value == 5) {
|
|
canvas_draw_icon(canvas, position[die[i].index].x % 128, position[die[i].index].y % 64, &I_die_5);
|
|
} else if (die[i].value == 6) {
|
|
canvas_draw_icon(canvas, position[die[i].index].x % 128, position[die[i].index].y % 64, &I_die_6);
|
|
}
|
|
}
|
|
|
|
// Puts an '*' above the die if hold is selected.
|
|
int8_t holdOffsetX = 8;
|
|
int8_t holdOffsetY = -5;
|
|
for (int8_t i = 0; i < 5; i++) {
|
|
if (die[i].isHeld == 1) {
|
|
elements_multiline_text_aligned(
|
|
canvas, position[die[i].index].x+holdOffsetX,
|
|
position[die[i].index].y+holdOffsetY, AlignCenter, AlignTop, HOLD);
|
|
}
|
|
}
|
|
|
|
// Update die cursor location
|
|
if (cursor.index != -1) {
|
|
elements_multiline_text_aligned(
|
|
canvas, position[cursor.index].x+selectorOffsetX,
|
|
position[cursor.index].y+selectorOffsetY, AlignCenter, AlignTop, cursor.symbol);
|
|
}
|
|
|
|
// Update score cursor location
|
|
if (scoreCursor.index != -1) {
|
|
elements_multiline_text_aligned(
|
|
canvas, score_positions[scoreCursor.index].x,
|
|
score_positions[scoreCursor.index].y+1, AlignLeft, AlignTop, scoreCursor.symbol);
|
|
}
|
|
|
|
// Update Roll
|
|
|
|
|
|
// Scores are updated in groups on screen to help with formatting
|
|
// first group is scorecard[0:7], second group is [8:12]
|
|
// Cycle through first 8 scores, if cursor at score, update to show possible score
|
|
// otherwise, show current scores value.
|
|
for (int8_t i = 0; i < 8; i++) {
|
|
if (scoreCursor.index == i && scorecard[i].used == false) {
|
|
int possiblescore = (int)(*scorecard[i].fn)();
|
|
|
|
snprintf(buffer, sizeof(buffer), "%s: %3u ", scorecard[i].name, possiblescore);
|
|
canvas_draw_str_aligned(canvas, 23+29*scorecard[i].col,
|
|
9*scorecard[i].row, AlignRight, AlignTop, buffer);
|
|
} else {
|
|
|
|
uint8_t currentscore = scorecard[i].value;
|
|
snprintf(buffer, sizeof(buffer), "%s: %3u ", scorecard[i].name, currentscore);
|
|
canvas_draw_str_aligned(canvas, 23+29*scorecard[i].col,
|
|
9*scorecard[i].row, AlignRight, AlignTop, buffer);
|
|
}
|
|
if (scorecard[i].used) {
|
|
canvas_draw_dot(canvas, 23+29*scorecard[i].col, 3+9*scorecard[i].row);
|
|
}
|
|
}
|
|
|
|
// cycle through lower scores
|
|
// NUM_SCORES minus one because the yatzee is 12 and is handled separately
|
|
for (int8_t i = 8; i < NUM_SCORES-1; i++) {
|
|
if (scoreCursor.index == i && scorecard[i].used == false) {
|
|
int possiblescore = (int)(*scorecard[i].fn)();
|
|
|
|
snprintf(buffer, sizeof(buffer), " %s: %3u ", scorecard[i].name, possiblescore);
|
|
canvas_draw_str_aligned(canvas, 31+27*scorecard[i].col,
|
|
9*scorecard[i].row, AlignRight, AlignTop, buffer);
|
|
} else {
|
|
uint8_t currentscore = scorecard[i].value;
|
|
snprintf(buffer, sizeof(buffer), " %s: %3u ", scorecard[i].name, currentscore);
|
|
canvas_draw_str_aligned(canvas, 31+27*scorecard[i].col,
|
|
9*scorecard[i].row, AlignRight, AlignTop, buffer);
|
|
}
|
|
if (scorecard[i].used) {
|
|
canvas_draw_dot(canvas, 31+27*scorecard[i].col, 3+9*scorecard[i].row);
|
|
}
|
|
}
|
|
|
|
// update yatzee score
|
|
if (scoreCursor.index == 12 && scorecard[12].used == false) {
|
|
int possiblescore = (int)(*scorecard[12].fn)();
|
|
|
|
snprintf(buffer, sizeof(buffer), "Yz\n%u", possiblescore);
|
|
elements_multiline_text_aligned(canvas, 93, 10, AlignCenter, AlignTop, buffer);
|
|
} else {
|
|
snprintf(buffer, sizeof(buffer), "Yz\n%ld", scorecard[12].value);
|
|
elements_multiline_text_aligned(canvas, 93, 10, AlignCenter, AlignTop, buffer);
|
|
}
|
|
|
|
|
|
// Scores and roll number updated
|
|
|
|
// sub score shows the 1-6 scores only. If this is >63 at the end of the game,
|
|
// a 35 point bonus is added to the total score
|
|
snprintf(buffer, sizeof(buffer), "Sub\n%u", upperScore);
|
|
elements_multiline_text_aligned(canvas, 117, 0, AlignCenter, AlignTop, buffer);
|
|
|
|
snprintf(buffer, sizeof(buffer), "Total\n%ld", totalScore);
|
|
elements_multiline_text_aligned(canvas, 117, 22, AlignCenter, AlignTop, buffer);
|
|
|
|
if (totalrolls == 0) {
|
|
snprintf(buffer, sizeof(buffer), "Roll\n%s", " ");
|
|
elements_multiline_text_aligned(canvas, 117, 64, AlignCenter, AlignBottom, buffer);
|
|
} else {
|
|
snprintf(buffer, sizeof(buffer), "Roll\n%u", totalrolls);
|
|
elements_multiline_text_aligned(canvas, 117, 64, AlignCenter, AlignBottom, buffer);
|
|
}
|
|
|
|
// Check for then handle end of game
|
|
|
|
// add num_bonus_yatzees to total rounds so that multiple
|
|
// yatzees can be scored without impacting the number of rounds before
|
|
// the game is over
|
|
int8_t total_rounds = num_bonus_yatzees;
|
|
// add up number of scores counted so far
|
|
for (int8_t i = 0; i<NUM_SCORES; i++) {
|
|
if (scorecard[i].used) {
|
|
total_rounds++;
|
|
}
|
|
}
|
|
|
|
// if total rounds is 13 + the number of bonus rounds,
|
|
// thats it, game over.
|
|
if (total_rounds == NUM_SCORES+num_bonus_yatzees) {
|
|
// if scores of 1-6 add up to 63, a 35 point bonus is bonus_added
|
|
// bonus_added = true keeps the game loop from
|
|
// adding bonuses indefinetly
|
|
if (upperScore >= 63 && bonus_added == false) {
|
|
totalScore+=35;
|
|
bonus_added = true;
|
|
}
|
|
// set game over to true and tell the user the game is over
|
|
game_over = true;
|
|
elements_button_center(canvas, "Game Over");
|
|
}
|
|
}
|
|
}
|
|
|
|
// define the callback for helping ViewPort get InputEvent and place it in the event_queue defined in the main method
|
|
static void app_input_callback(InputEvent* input_event, void* ctx) {
|
|
furi_assert(ctx);
|
|
|
|
FuriMessageQueue* event_queue = ctx;
|
|
furi_message_queue_put(event_queue, input_event, FuriWaitForever);
|
|
}
|
|
|
|
// roll them diiiiceeee
|
|
static void roll_dice() {
|
|
// increment roll count
|
|
totalrolls++;
|
|
for (uint8_t i = 0; i < MAX_DICE; i++) {
|
|
// dont reroll if the dice is being held
|
|
if (die[i].isHeld == false) {
|
|
die[i].value = 1 + rand() % 6;
|
|
}
|
|
}
|
|
// if 3 rolls have been used, force user to select a score.
|
|
if(totalrolls == 3) {
|
|
scoreCursor.index = 0;
|
|
}
|
|
}
|
|
|
|
static void clear_board() {
|
|
// reset board after adding score
|
|
totalrolls = 0;
|
|
for (int8_t i=0; i < MAX_DICE; i++) {
|
|
die[i].isHeld = false;
|
|
}
|
|
scoreCursor.index = -1;
|
|
cursor.index = 0;
|
|
}
|
|
|
|
static void add_score() {
|
|
// return when scoring is not possible
|
|
if (cursor.index != -1 || totalrolls == 0 || (scorecard[scoreCursor.index].used && strcmp(scorecard[scoreCursor.index].name,"Yz")!=0)){
|
|
return;
|
|
}
|
|
|
|
// extra yatzee scores
|
|
if (scoreCursor.index == 12 && scorecard[scoreCursor.index].used) {
|
|
uint8_t yatzee_score = (*scorecard[12].fn)();
|
|
scorecard[12].value += 2*yatzee_score;
|
|
lowerScore+=100;
|
|
num_bonus_yatzees++;
|
|
}
|
|
|
|
|
|
// upper score
|
|
for (int8_t i = 0; i < 6; i++) {
|
|
if (scoreCursor.index == i && scorecard[scoreCursor.index].used == false) {
|
|
scorecard[i].value =(*scorecard[i].fn)();
|
|
upperScore+=scorecard[i].value;
|
|
scorecard[i].used = true;
|
|
}
|
|
}
|
|
|
|
// lower score
|
|
for (int8_t i = 6; i < 13; i++) {
|
|
if (scoreCursor.index == i && scorecard[scoreCursor.index].used == false) {
|
|
scorecard[i].value = (*scorecard[i].fn)();
|
|
lowerScore+=scorecard[i].value;
|
|
scorecard[i].used = true;
|
|
}
|
|
}
|
|
|
|
// recalculate total score
|
|
totalScore = lowerScore + upperScore;
|
|
clear_board();
|
|
}
|
|
|
|
|
|
|
|
|
|
// Entry Point
|
|
int32_t yatzee_main(void* p) {
|
|
UNUSED(p);
|
|
|
|
// Initialize event queue to handle incoming events like button presses
|
|
// Use FuriMessageQueue as type as defined in furi api
|
|
// InputEvents are supported by app_input_callback
|
|
FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
|
|
|
|
// Initialize viewport
|
|
ViewPort* view_port = view_port_alloc();
|
|
|
|
// Set system callbacks
|
|
view_port_draw_callback_set(view_port, app_draw_callback, view_port);
|
|
view_port_input_callback_set(view_port, app_input_callback, event_queue);
|
|
|
|
// Open GUI & register viewport
|
|
Gui* gui = furi_record_open(RECORD_GUI);
|
|
gui_add_view_port(gui, view_port, GuiLayerFullscreen);
|
|
|
|
// hold input event
|
|
InputEvent event;
|
|
|
|
// Create a loop for the app to run in and handle InputEvents
|
|
bool isRunning = true;
|
|
|
|
while(isRunning) {
|
|
|
|
if (totalrolls == 3) {
|
|
cursor.index = -1;
|
|
}
|
|
if(furi_message_queue_get(event_queue, &event, 100) == FuriStatusOk) {
|
|
if((event.type == InputTypePress) || event.type == InputTypeRepeat) {
|
|
switch(event.key) {
|
|
case InputKeyLeft:
|
|
if(cursor.index == -1) {
|
|
if(scoreCursor.index == 0 && totalrolls == 3){
|
|
scoreCursor.index = NUM_SCORES-1;
|
|
} else if (scoreCursor.index==0) {
|
|
scoreCursor.index = -1;
|
|
cursor.index = 4;
|
|
} else {
|
|
scoreCursor.index--;
|
|
}
|
|
} else {
|
|
if(cursor.index == 0) {
|
|
cursor.index = -1;
|
|
scoreCursor.index = NUM_SCORES-1;
|
|
} else {
|
|
cursor.index--;
|
|
}
|
|
}
|
|
break;
|
|
case InputKeyRight:
|
|
// cursor.index == -1 means that scoreCursor is active
|
|
if(cursor.index == -1) {
|
|
if(scoreCursor.index == NUM_SCORES-1 && totalrolls == 3){
|
|
scoreCursor.index = 0;
|
|
} else if (scoreCursor.index == NUM_SCORES-1) {
|
|
scoreCursor.index = -1;
|
|
cursor.index = 0;
|
|
} else {
|
|
scoreCursor.index++;
|
|
}
|
|
// if cursor.index is not -1, then dice cursor is active
|
|
} else {
|
|
if(cursor.index == 4) {
|
|
cursor.index = -1;
|
|
scoreCursor.index = 0;
|
|
} else {
|
|
cursor.index++;
|
|
}
|
|
}
|
|
break;
|
|
case InputKeyUp:
|
|
|
|
if (totalrolls < 3) {
|
|
roll_dice();
|
|
}
|
|
// if (check_for_bonus_yatzee() && scorecard[13].used) {
|
|
// num_bonus_yatzees++;
|
|
// totalScore+=100;
|
|
//
|
|
// clear_board();
|
|
// }
|
|
break;
|
|
case InputKeyDown:
|
|
add_score();
|
|
break;
|
|
case InputKeyOk:
|
|
if (new_game) {
|
|
new_game = false;
|
|
break;
|
|
}
|
|
if (game_over) {
|
|
isRunning = false;
|
|
}
|
|
if (cursor.index == -1 || totalrolls == 0) {
|
|
break;
|
|
}
|
|
if (die[cursor.index].isHeld == false) {
|
|
die[cursor.index].isHeld = true;
|
|
} else {
|
|
die[cursor.index].isHeld = false;
|
|
}
|
|
break;
|
|
default:
|
|
isRunning = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// after every event, update view_port
|
|
// uses app_draw_callback which is set before the game loop begins.
|
|
view_port_update(view_port);
|
|
}
|
|
|
|
// cleanup
|
|
view_port_enabled_set(view_port, false);
|
|
gui_remove_view_port(gui, view_port);
|
|
view_port_free(view_port);
|
|
furi_message_queue_free(event_queue);
|
|
furi_record_close(RECORD_GUI);
|
|
|
|
return 0;
|
|
} |