mirror of
https://github.com/DarkFlippers/unleashed-firmware.git
synced 2024-12-30 00:32:06 +03:00
353 lines
9.5 KiB
C
353 lines
9.5 KiB
C
#include "card.h"
|
|
#include "dml.h"
|
|
#include "ui.h"
|
|
|
|
#define CARD_DRAW_X_START 108
|
|
#define CARD_DRAW_Y_START 38
|
|
#define CARD_DRAW_X_SPACE 10
|
|
#define CARD_DRAW_Y_SPACE 8
|
|
#define CARD_DRAW_X_OFFSET 4
|
|
#define CARD_DRAW_FIRST_ROW_LENGTH 7
|
|
|
|
uint8_t pips[4][3] = {
|
|
{21, 10, 7}, //spades
|
|
{7, 10, 7}, //hearts
|
|
{0, 10, 7}, //diamonds
|
|
{14, 10, 7}, //clubs
|
|
};
|
|
uint8_t letters[13][3] = {
|
|
{0, 0, 5},
|
|
{5, 0, 5},
|
|
{10, 0, 5},
|
|
{15, 0, 5},
|
|
{20, 0, 5},
|
|
{25, 0, 5},
|
|
{30, 0, 5},
|
|
{0, 5, 5},
|
|
{5, 5, 5},
|
|
{10, 5, 5},
|
|
{15, 5, 5},
|
|
{20, 5, 5},
|
|
{25, 5, 5},
|
|
};
|
|
|
|
//region Player card positions
|
|
uint8_t playerCardPositions[22][4] = {
|
|
//first row
|
|
{108, 38},
|
|
{98, 38},
|
|
{88, 38},
|
|
{78, 38},
|
|
{68, 38},
|
|
{58, 38},
|
|
{48, 38},
|
|
{38, 38},
|
|
//second row
|
|
{104, 26},
|
|
{94, 26},
|
|
{84, 26},
|
|
{74, 26},
|
|
{64, 26},
|
|
{54, 26},
|
|
{44, 26},
|
|
//third row
|
|
{99, 14},
|
|
{89, 14},
|
|
{79, 14},
|
|
{69, 14},
|
|
{59, 14},
|
|
{49, 14},
|
|
};
|
|
//endregion
|
|
Icon* card_graphics = NULL;
|
|
|
|
void set_card_graphics(const Icon* graphics) {
|
|
card_graphics = (Icon*)graphics;
|
|
}
|
|
|
|
void draw_card_at_colored(
|
|
int8_t pos_x,
|
|
int8_t pos_y,
|
|
uint8_t pip,
|
|
uint8_t character,
|
|
bool inverted,
|
|
Canvas* const canvas) {
|
|
DrawMode primary = inverted ? Black : White;
|
|
DrawMode secondary = inverted ? White : Black;
|
|
draw_rounded_box(canvas, pos_x, pos_y, CARD_WIDTH, CARD_HEIGHT, primary);
|
|
draw_rounded_box_frame(canvas, pos_x, pos_y, CARD_WIDTH, CARD_HEIGHT, Black);
|
|
|
|
uint8_t* drawInfo = pips[pip];
|
|
uint8_t px = drawInfo[0], py = drawInfo[1], s = drawInfo[2];
|
|
|
|
uint8_t left = pos_x + 2;
|
|
uint8_t right = (pos_x + CARD_WIDTH - s - 2);
|
|
uint8_t top = pos_y + 2;
|
|
uint8_t bottom = (pos_y + CARD_HEIGHT - s - 2);
|
|
|
|
draw_icon_clip(canvas, card_graphics, right, top, px, py, s, s, secondary);
|
|
draw_icon_clip_flipped(canvas, card_graphics, left, bottom, px, py, s, s, secondary);
|
|
|
|
drawInfo = letters[character];
|
|
px = drawInfo[0], py = drawInfo[1], s = drawInfo[2];
|
|
left = pos_x + 2;
|
|
right = (pos_x + CARD_WIDTH - s - 2);
|
|
top = pos_y + 2;
|
|
bottom = (pos_y + CARD_HEIGHT - s - 2);
|
|
|
|
draw_icon_clip(canvas, card_graphics, left, top + 1, px, py, s, s, secondary);
|
|
draw_icon_clip_flipped(canvas, card_graphics, right, bottom - 1, px, py, s, s, secondary);
|
|
}
|
|
|
|
void draw_card_at(int8_t pos_x, int8_t pos_y, uint8_t pip, uint8_t character, Canvas* const canvas) {
|
|
draw_card_at_colored(pos_x, pos_y, pip, character, false, canvas);
|
|
}
|
|
|
|
void draw_deck(const Card* cards, uint8_t count, Canvas* const canvas) {
|
|
for(int i = count - 1; i >= 0; i--) {
|
|
draw_card_at(
|
|
playerCardPositions[i][0],
|
|
playerCardPositions[i][1],
|
|
cards[i].pip,
|
|
cards[i].character,
|
|
canvas);
|
|
}
|
|
}
|
|
|
|
Vector card_pos_at_index(uint8_t index) {
|
|
return (Vector){playerCardPositions[index][0], playerCardPositions[index][1]};
|
|
}
|
|
|
|
void draw_card_back_at(int8_t pos_x, int8_t pos_y, Canvas* const canvas) {
|
|
draw_rounded_box(canvas, pos_x, pos_y, CARD_WIDTH, CARD_HEIGHT, White);
|
|
draw_rounded_box_frame(canvas, pos_x, pos_y, CARD_WIDTH, CARD_HEIGHT, Black);
|
|
|
|
draw_icon_clip(canvas, card_graphics, pos_x + 1, pos_y + 1, 35, 0, 15, 21, Black);
|
|
}
|
|
|
|
void generate_deck(Deck* deck_ptr, uint8_t deck_count) {
|
|
uint16_t counter = 0;
|
|
if(deck_ptr->cards != NULL) {
|
|
free(deck_ptr->cards);
|
|
}
|
|
|
|
deck_ptr->deck_count = deck_count;
|
|
deck_ptr->card_count = deck_count * 52;
|
|
deck_ptr->cards = malloc(sizeof(Card) * deck_ptr->card_count);
|
|
|
|
for(uint8_t deck = 0; deck < deck_count; deck++) {
|
|
for(uint8_t pip = 0; pip < 4; pip++) {
|
|
for(uint8_t label = 0; label < 13; label++) {
|
|
deck_ptr->cards[counter] = (Card){pip, label, false, false};
|
|
counter++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void shuffle_deck(Deck* deck_ptr) {
|
|
srand(DWT->CYCCNT);
|
|
deck_ptr->index = 0;
|
|
int max = deck_ptr->deck_count * 52;
|
|
for(int i = 0; i < max; i++) {
|
|
int r = i + (rand() % (max - i));
|
|
Card tmp = deck_ptr->cards[i];
|
|
deck_ptr->cards[i] = deck_ptr->cards[r];
|
|
deck_ptr->cards[r] = tmp;
|
|
}
|
|
}
|
|
|
|
uint8_t hand_count(const Card* cards, uint8_t count) {
|
|
uint8_t aceCount = 0;
|
|
uint8_t score = 0;
|
|
|
|
for(uint8_t i = 0; i < count; i++) {
|
|
if(cards[i].character == 12)
|
|
aceCount++;
|
|
else {
|
|
if(cards[i].character > 8)
|
|
score += 10;
|
|
else
|
|
score += cards[i].character + 2;
|
|
}
|
|
}
|
|
|
|
for(uint8_t i = 0; i < aceCount; i++) {
|
|
if((score + 11) <= 21)
|
|
score += 11;
|
|
else
|
|
score++;
|
|
}
|
|
|
|
return score;
|
|
}
|
|
|
|
void draw_card_animation(
|
|
Card animatingCard,
|
|
Vector from,
|
|
Vector control,
|
|
Vector to,
|
|
float t,
|
|
bool extra_margin,
|
|
Canvas* const canvas) {
|
|
float time = t;
|
|
if(extra_margin) {
|
|
time += 0.2;
|
|
}
|
|
|
|
Vector currentPos = quadratic_2d(from, control, to, time);
|
|
if(t > 1) {
|
|
draw_card_at(
|
|
currentPos.x, currentPos.y, animatingCard.pip, animatingCard.character, canvas);
|
|
} else {
|
|
if(t < 0.5)
|
|
draw_card_back_at(currentPos.x, currentPos.y, canvas);
|
|
else
|
|
draw_card_at(
|
|
currentPos.x, currentPos.y, animatingCard.pip, animatingCard.character, canvas);
|
|
}
|
|
}
|
|
|
|
void init_hand(Hand* hand_ptr, uint8_t count) {
|
|
hand_ptr->cards = malloc(sizeof(Card) * count);
|
|
hand_ptr->index = 0;
|
|
hand_ptr->max = count;
|
|
}
|
|
|
|
void free_hand(Hand* hand_ptr) {
|
|
FURI_LOG_D("CARD", "Freeing hand");
|
|
free(hand_ptr->cards);
|
|
}
|
|
|
|
void add_to_hand(Hand* hand_ptr, Card card) {
|
|
FURI_LOG_D("CARD", "Adding to hand");
|
|
if(hand_ptr->index < hand_ptr->max) {
|
|
hand_ptr->cards[hand_ptr->index] = card;
|
|
hand_ptr->index++;
|
|
}
|
|
}
|
|
|
|
void draw_card_space(int16_t pos_x, int16_t pos_y, bool highlighted, Canvas* const canvas) {
|
|
if(highlighted) {
|
|
draw_rounded_box_frame(canvas, pos_x, pos_y, CARD_WIDTH, CARD_HEIGHT, Black);
|
|
draw_rounded_box_frame(
|
|
canvas, pos_x + 2, pos_y + 2, CARD_WIDTH - 4, CARD_HEIGHT - 4, White);
|
|
} else {
|
|
draw_rounded_box(canvas, pos_x, pos_y, CARD_WIDTH, CARD_HEIGHT, Black);
|
|
draw_rounded_box_frame(
|
|
canvas, pos_x + 2, pos_y + 2, CARD_WIDTH - 4, CARD_HEIGHT - 4, White);
|
|
}
|
|
}
|
|
|
|
int first_non_flipped_card(Hand hand) {
|
|
for(int i = 0; i < hand.index; i++) {
|
|
if(!hand.cards[i].flipped) {
|
|
return i;
|
|
}
|
|
}
|
|
return hand.index;
|
|
}
|
|
|
|
void draw_hand_column(
|
|
Hand hand,
|
|
int16_t pos_x,
|
|
int16_t pos_y,
|
|
int8_t highlight,
|
|
Canvas* const canvas) {
|
|
if(hand.index == 0) {
|
|
draw_card_space(pos_x, pos_y, highlight > 0, canvas);
|
|
if(highlight == 0)
|
|
draw_rounded_box(canvas, pos_x, pos_y, CARD_WIDTH, CARD_HEIGHT, Inverse);
|
|
return;
|
|
}
|
|
|
|
int loopEnd = hand.index;
|
|
int hStart = max(loopEnd - 4, 0);
|
|
int pos = 0;
|
|
int first = first_non_flipped_card(hand);
|
|
bool wastop = false;
|
|
if(first >= 0 && first <= hStart && highlight != first) {
|
|
if(first > 0) {
|
|
draw_card_back_at(pos_x, pos_y + pos, canvas);
|
|
pos += 4;
|
|
hStart++;
|
|
wastop = true;
|
|
}
|
|
draw_card_at_colored(
|
|
pos_x, pos_y + pos, hand.cards[first].pip, hand.cards[first].character, false, canvas);
|
|
pos += 8;
|
|
hStart++;
|
|
}
|
|
if(hStart > highlight && highlight >= 0) {
|
|
if(!wastop && first > 0) {
|
|
draw_card_back_at(pos_x, pos_y + pos, canvas);
|
|
pos += 4;
|
|
hStart++;
|
|
}
|
|
draw_card_at_colored(
|
|
pos_x,
|
|
pos_y + pos,
|
|
hand.cards[highlight].pip,
|
|
hand.cards[highlight].character,
|
|
true,
|
|
canvas);
|
|
pos += 8;
|
|
hStart++;
|
|
}
|
|
for(int i = hStart; i < loopEnd; i++, pos += 4) {
|
|
if(hand.cards[i].flipped) {
|
|
draw_card_back_at(pos_x, pos_y + pos, canvas);
|
|
if(i == highlight)
|
|
draw_rounded_box(
|
|
canvas, pos_x + 1, pos_y + pos + 1, CARD_WIDTH - 2, CARD_HEIGHT - 2, Inverse);
|
|
} else {
|
|
draw_card_at_colored(
|
|
pos_x,
|
|
pos_y + pos,
|
|
hand.cards[i].pip,
|
|
hand.cards[i].character,
|
|
(i == highlight),
|
|
canvas);
|
|
if(i == highlight || i == first) pos += 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
Card remove_from_deck(uint16_t index, Deck* deck) {
|
|
FURI_LOG_D("CARD", "Removing from deck");
|
|
Card result = {0, 0, true, false};
|
|
if(deck->card_count > 0) {
|
|
deck->card_count--;
|
|
for(int i = 0, curr_index = 0; i <= deck->card_count; i++) {
|
|
if(i != index) {
|
|
deck->cards[curr_index] = deck->cards[i];
|
|
curr_index++;
|
|
} else {
|
|
result = deck->cards[i];
|
|
}
|
|
}
|
|
if(deck->index >= 0) {
|
|
deck->index--;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void extract_hand_region(Hand* hand, Hand* to, uint8_t start_index) {
|
|
FURI_LOG_D("CARD", "Extracting hand region");
|
|
if(start_index >= hand->index) return;
|
|
|
|
for(uint8_t i = start_index; i < hand->index; i++) {
|
|
add_to_hand(to, hand->cards[i]);
|
|
}
|
|
hand->index = start_index;
|
|
}
|
|
|
|
void add_hand_region(Hand* to, Hand* from) {
|
|
FURI_LOG_D("CARD", "Adding hand region");
|
|
if((to->index + from->index) <= to->max) {
|
|
for(int i = 0; i < from->index; i++) {
|
|
add_to_hand(to, from->cards[i]);
|
|
}
|
|
}
|
|
} |