Momentum-Apps/solitaire/common/card.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]);
        }
    }
}