mirror of
https://github.com/Next-Flip/Momentum-Firmware.git
synced 2026-05-19 04:44:47 -07:00
330 lines
9.8 KiB
C
330 lines
9.8 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) {
|
|
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]);
|
|
}
|
|
}
|
|
} |