FreeCell written in C

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <math.h>
#include <time.h>
#include "main.h"

/////////////////////////////////
// Cartas são enumeradas de 0 a 51
// 0 = A Copas
// 51 = K Espadas
// 0-12 = copas
// 13-25 = ouros
// 26-38 = paus
// 39-51 = espadas

// (valor+1)/13 = categoria(copas/espadas/ouros/paus); 0=C 1=O 2=P 3=E
// (valor+1)%13 = número(A,2,3,4,5,6,7,8,9,10,J,Q,K)
/////////////////////////////////

// void cardToStr(Item *card, char *c)
// transforma *c na carta
void cardToStr(Item *card, char *c)
{
    if(card == NULL)
    {
        strcpy(c, "   ");
        return;
    }

    int category = getCardNipe(card);
    int value = getCardNumber(card);
    c[0] = ' '; c[1] = ' '; c[2] = ' ';
    switch(value)
    {
        case 0: c[1] = 'A'; break; //A
        case 9: c[0] = '1'; c[1] = '0'; break; //10
        case 10: c[1] = 'J'; break; //J
        case 11: c[1] = 'Q'; break; //Q
        case 12: c[1] = 'K'; break; //K
        default: c[1] = '1'+value; break; //Isto só é possível pois os casos para números > 9 já foram cobertos acima

    }

    switch(category)
    {
        case 0: c[2] = '\3'; break;
        case 1: c[2] = '\4'; break;
        case 2: c[2] = '\5'; break;
        case 3: c[2] = '\6'; break;
        default: c[2] = ' '; break;
    }
}

void shuffleArray(int *arr, size_t n)
{
    if(n>1)
    {
        size_t i, j;
        for(i = 0; i < n-1; i++)
        {
            j = i + (rand() / (RAND_MAX / (n - i) + 1));
            int t = arr[j];
            arr[j] = arr[i];
            arr[i] = t;
        }
    }
}

void initializeCards()
{
    srand(time(NULL)); //modifica a base do gerador aleatório para não sair a mesma combinação para toda execução
    int ar[52];
    size_t i;
    //Baralho padrão, não embaralhado
    for(i=0; i<52; i++)
    {
        ar[i] = i;
    }

    shuffleArray(ar, 52); // Embaralhado


    for(i=0; i<=3; i++)
    {
        top_slots[i] = createPile();
        base_slots[i] = createPile();
        mid_slots[i] = createPile();
        mid_slots[i+4] = createPile(); //Não precisa de 2 loops
    }

    //Colocar as cartas nos mid_slots
    for(i=0; i<52; i++){
        addNewItemPile(mid_slots[i%8], ar[i]);
    }

    //Inicializar status do jogo
    gameStatus = GAME_STATUS_START;
}

void writeCards()
{
    if(!mid_slots[0])
        return;

    int i;
    Item* item;
    char *c = malloc(sizeof(char[3]));

    for(i=0; i<8; i++)
    {
        if(mid_slots[i])
        {
            item = mid_slots[i]->start;
            while(item->next != NULL)
            {
                cardToStr(item, c);
                printf("%s   ", c);
                item = item->next;
            }
            printf("\n");
        }
    }
    free(c);
}

//int moveCardToPile(Pile* from, Pile* to)
//Move a carta do topo da pilha from para a pilha to
//retorna -1 se nao conseguir, 0 se conseguir
int moveCardToPile(Pile* from, Pile* to)
{
    if(from == NULL || to == NULL)
        return -1;

    Item *prev = removeTopItemPile(from);
    if(prev == NULL)
        return -1;

    return addItemPile(to, prev);
}

int moveCardToBase(Pile *from)
{
    if(from == NULL)
        return -1;

    Item *prev = removeTopItemPile(from);
    if(prev == NULL)
        return -1;

    return addItemPile(base_slots[getCardNipe(prev)], prev);
}


//int getCardNipe
//retorna 0 para copas, 1 para ouros, 2 para paus, 3 para espadas, -1 para erro
int getCardNipe(Item* card)
{
    if(card != NULL)
        return (int)(card->value / 13);
    return -1;
}

//int getCardNumber
//retorna o número da carta, de 0 a 12
//0=A, 1=2, 2=3, etc...
int getCardNumber(Item* card)
{
    if(card != NULL)
        return (int)(card->value % 13);
    return -1;
}

//int canMove(Pile *from, Pile *to)
//retorna 1 se é possível mexer a carta do topo de from para to
//retorna 0 se não
//Toma como base apenas as regras do jogo para as pilhas do meio
//Não leva em consideração as pilhas do topo direito, que têm funcionamento diferente.
int canMove(Pile *from, Pile *to)
{
    if(from == NULL || to == NULL)
        return 0;

    if(from->start == NULL)
        return 0;

    Item *toMove = from->start;
    Item *toReceive = to->start;
    if(toReceive == NULL)
        return 1; //Sem carta = pode mecher qualquer carta

    //verificar se o número é válido
    if(getCardNumber(toMove) != getCardNumber(toReceive)-1)
        return 0; //só pode mexer uma carta 1 numero menor do que a carta alvo, ex 2 para 3

    //verificar se o nipe é válido
    //0 não pode combinar com 1, 2 não pode combinar com 3.
    //A XOR C, pois se o bit da esquerda é diferente, torna o movimento válido
    if((getCardNipe(toMove) ^ getCardNipe(toReceive)) > 1) //>1 significa 10 ou 11 vs 00 ou 01
        return 1;

    return 0;
}

//int canMoveToBase(Pile *from)
//retorna 1 de a carta pode ser posta em uma pilha base
//retorna 0 se não
int canMoveToBase(Pile *from)
{
    if(from == NULL || base_slots[0] == NULL)
        return -1;

    Item *toMove = from->start;
    if(toMove == NULL)
        return -1;


    //Verifica na pilha do nipe da carta
    Item *toReceive = base_slots[getCardNipe(toMove)]->start;
    if(toReceive != NULL)
    {
        if(getCardNumber(toReceive) == getCardNumber(toMove)-1)
            return 1;
    }
    else if(getCardNumber(toMove) == 0)
        return 1;

    //Verifica se a carta na pilha é antecessora a esta


    return 0;
}

// Função main() executa o programa.
int main()
{
    initializeCards();
    drawBoard();
    //writeCards();
    return 0;
}

#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED

#include "pilha.h"

//Slot é a casa onde as cartas são postas
//Em FreeCell, você tem 8 slots vazios na primeira linha(sendo 4 "bases") e 8 slots com cartas

Pile *top_slots[4]; //Slots da esquerda de cima, inicialmente vazios
Pile *base_slots[4]; //Slots base, para onde as cartas vão. Talvez não precise utilizar Pile aqui?
Pile *mid_slots[8]; //Slots do meio. No inicio do jogo, têm as cartas distribuídas neles


//Funções de main.c
void cardToStr(Item *card, char *c);
void shuffleArray(int *arr, size_t n);
void initializeCards();
int moveCardToPile(Pile *from, Pile *to);
int moveCardToBase(Pile *from);
int getCardNipe(Item *card);
int getCardNumber(Item *card);
int canMove(Pile *from, Pile *to);
int canMoveToBase(Pile *from);



#define NOMINMAX 1
//Usarei minha própria função max
#define max(a,b) \
   ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a > _b ? _a : _b; })


void drawCard(Item *card);
void drawBoard();
void drawMiddle();
void drawRequestHandle();
void receiveUserInput();
void checkGameStatus();


int gameStatus; //estado do jogo
#define GAME_STATUS_START 0
#define GAME_STATUS_CHOSECARD 1
#define GAME_STATUS_CHOSETARGET 2
#define GAME_STATUS_DEFEAT 3
#define GAME_STATUS_VICTORY 4

Pile *selectedSlot; //pilha selecionada para mover

#endif // MAIN_H_INCLUDED

#include "pilha.h"

// Pile* createPile();
// Retorna uma NOVA pilha inicializada
// Retorna NULL caso não consiga criar uma nova pilha
Pile* createPile()
{
    Pile* newPile = (Pile*)malloc(sizeof(Pile));
    if(newPile == NULL) //se não puder achar memória no sistema
        return NULL;

    newPile->start = NULL;
    newPile->length = 0;
    return newPile;
}


// int addItemPile(Pile* pile, int value)
// Cria e adiciona um novo item à pilha, com valor value
// Retorna -1 se não for bem sucedido, 0 se for bem sucedido
int addNewItemPile(Pile* pile, int value)
{
    Item* newItem;
    if(pile == NULL)
        return -1;

    newItem = (Item*)malloc(sizeof(Item));
    if(newItem == NULL)
        return -1;

    newItem->value = value;
    newItem->next = pile->start;
    pile->start = newItem;
    pile->length++;
    return 0;
}

int addItemPile(Pile* pile, Item* item)
{
    if(item == NULL)
        return -1;

    if(item->next != NULL) //se o next != NULL, ele está em alguma pilha
        return -1;

    item->next = pile->start;
    pile->start = item;
    pile->length++;
    return 0;
}

// Item* removeTopItemPile(Pile* pile)
// remove o primeiro item da pilha
// retorna NULL se houver algum erro, ou o item removido para uso futuro
// O "next" do item removido vira NULL, pois ele é removido da pilha.
// Nota: o item NÃO É DELETADO DA MEMÓRIA.
Item* removeTopItemPile(Pile* pile)
{
    Item* removedItem;
    if(pile == NULL || pile->length <= 0)
        return NULL;

    removedItem = pile->start;
    pile->start = removedItem->next;
    pile->length--;
    removedItem->next = NULL;
    return removedItem;
}

// int deleteItem(Item* item)
// deleta e remove o item da memória
// retorna -1 se o next não for NULL, pois siginifica que ainda está em uma pilha
// retorna 0 se for bem sucedido
int deleteItem(Item* item)
{
    if(item == NULL || item->next != NULL)
        return -1;

    free(item);
    return 0;
}

// int deletePile(Pile* pile)
// deleta a pilha e remove da memória
// remove e deleta qualquer item que esteja na pilha
// retorna -1 se a pilha não existir
int deletePile(Pile* pile)
{
    Item* item;
    if(pile == NULL)
        return -1;

    while(pile->length > 0)
    {
        item = removeTopItemPile(pile); //reduz o valor da pilha automaticamente
        if(item != NULL)
            deleteItem(item);
    }

    free(pile);
    return 0;
}

//Item* getPreviousItemOnPile(Item *item, Pile *pile)
// retorna o item anterior ao item requerido na pilha
// retorna o próprio item se ele for o topo da pilha
// retorna NULL se não for possível, ou se o item não estiver na pilha
Item* getPreviousItemOnPile(Item *item, Pile *pile)
{
    if(item == NULL || pile == NULL)
        return NULL;

    Item* Q = pile->start;
    if(Q == NULL) return NULL;
    if(Q == item) return item;

    while(Q->next != NULL)
    {
        if(Q->next == item) return Q;

        Q = Q->next;
    }

    return NULL;
}

///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
//////////////////////////Funcoes de Pilha(stack)//////////////////////
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////


#ifndef PILHA_H_INCLUDED
#define PILHA_H_INCLUDED

#include <stdlib.h>

// Definir Pilha(Pile) e suas funções para o uso no jogo
// Usar nomes genéricos para usos futuros

typedef struct ItemList
{
    int value; //No futuro, achar um método de transformar este tipo em algo mais dinâmico
    struct ItemList *next;
}Item;

typedef struct PileStructure
{
    Item *start;
    int length; // length ao inves de size, pois size ja é definido para outras coisas
}Pile;


// Pile* createPile();
// Retorna uma NOVA pilha inicializada
// Retorna NULL caso não consiga criar uma nova pilha
Pile* createPile();


// int addItemPile(Pile* pile, int value)
// Cria e adiciona um novo item à pilha, com valor value
// Retorna -1 se não for bem sucedido, 0 se for bem sucedido
int addNewItemPile(Pile* pile, int value);
int addItemPile(Pile* pile, Item* item);

// Item* removeTopItemPile(Pile* pile)
// remove o primeiro item da pilha
// retorna NULL se houver algum erro, ou o item removido para uso futuro
// O "next" do item removido vira NULL, pois ele é removido da pilha.
// Nota: o item NÃO É DELETADO DA MEMÓRIA.
Item* removeTopItemPile(Pile* pile);

// int deleteItem(Item* item)
// deleta e remove o item da memória
// retorna -1 se o next não for NULL, pois siginifica que ainda está em uma pilha
// retorna 0 se for bem sucedido
int deleteItem(Item* item);

// int deletePile(Pile* pile)
// deleta a pilha e remove da memória
// remove e deleta qualquer item que esteja na pilha
// retorna -1 se a pilha não existir
int deletePile(Pile* pile);

//Item* getPreviousItemOnPile(Item *item, Pile *pile)
// retorna o item anterior ao item requerido na pilha
// retorna o próprio item se ele for o topo da pilha
// retorna NULL se não for possível, ou se o item não estiver na pilha
Item* getPreviousItemOnPile(Item *item, Pile *pile);

#endif // PILHA_H_INCLUDED

#include <stdlib.h>
#include <stdio.h>
#include <strings.h>
#include "main.h"
#include "pilha.h"

void drawCard(Item *card)
{
    if(card != NULL)
    {
        char *c = malloc(sizeof(char[3]));
        cardToStr(card, c);
        printf("{%s} ", c);
        free(c);
    }
    else
    printf("{   } ");
}


void drawBoard()
{
    system("cls");
    int i;

    if(top_slots[0] == NULL)
        return;
/*

      #1   #2    #3    #4       C     O     P     E
    {   } {   } {   } {   } | {   } {   } {   } {   }
    -------------------------------------------------
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
    {   } {   } {   } {   }   {   } {   } {   } {   }
      a     b     c     d       e     f     g     h

    In which column is the card you want to take? _

    (depois de selecionar a carta)
    To where you want to send this card?
    Valid options: 1,2,3,4,a,b,c,d,e,f,g,h,BASE
    Enter with the target: _


   // NOTA: opções possíveis também são o, out, base, nipe


*/

    printf(" #1    #2    #3    #4       \3     \4     \5     \6 \n");
    for(i=0;i<4;i++)
        drawCard(top_slots[i]->start);

    printf("| ");

    for(i=0;i<4;i++)
        drawCard(base_slots[i]->start);
    //base e topo escritas

    printf("\n");
    printf("------------------------------------------------- \n");

    //escrever o meio
    drawMiddle();

    printf("\n\n");
    //Perguntas
    drawRequestHandle();

    //Solicitar o usuário a executar um comando
    if(gameStatus != GAME_STATUS_DEFEAT && gameStatus != GAME_STATUS_VICTORY)
        receiveUserInput();
}



void drawMiddle()
{
    //Função separada para organizar
    //Para o jogo, é mais fácil manter pilhas de baixo para cima(pelo display)
    //Porém para escrever, é mais fácil utilizar pilhas de cima para baixo

    //Então vou criar novas pilhas temporárias que são cópias das globais
    //E utilizar estas para imprimir
    if(mid_slots[0] == NULL)
        return;

    Pile *tempPile[8];
    Item *tempItem;
    Item *tmpVector[8];
    int i, j, max_length;
    max_length = -1; //Inicialização necessária para garantir o uso

    for(i=0;i<8;i++)
    {
        //Terei de criar NOVAS cartas, pois as originais precisam manter seus atributos
        //Lembrar de deletar tudo ao fim da função
        tempPile[i] = createPile();
        tempItem = mid_slots[i]->start;
        while(tempItem != NULL)
        {
            addNewItemPile(tempPile[i], tempItem->value);
            tempItem = tempItem->next;
        }

        max_length = max(max_length, tempPile[i]->length); //será usado mais tarde

    }

    //Desenhar
    for(i = 0; i < max_length; i++)
    {
        for(j = 0; j < 8; j++)
        {
            if(i == 0)
                tmpVector[j] = tempPile[j]->start;
            else if(tmpVector[j] != NULL){
                tmpVector[j] = tmpVector[j]->next;
            }

            drawCard(tmpVector[j]);
            if(j == 3)
                printf("  "); //Alinhar as cartas
        }
        printf("\n");
    }


    printf("  a     b     c     d       e     f     g     h   \n");

    //deletar pilas temporárias
    for(i= 0; i < 8; i++)
        deletePile(tempPile[i]);
    //funçoes em pile.h já lidam com os items criados
}

void drawRequestHandle()
{
    //Função para escrever as perguntas
    switch(gameStatus)
    {
        case GAME_STATUS_START:
            printf("Welcome to FreeCell! Above you will see your cards!\n");
        case GAME_STATUS_CHOSECARD:
            printf("Please chose which card you want to move!\n");
            printf("Valid options: a, b, c, d, e, f, g, h, 1, 2, 3, 4\n");
            break;
        case GAME_STATUS_CHOSETARGET:
            printf("Please chose to where you want to move ");
            drawCard(selectedSlot->start);
            printf("\nValid options: a, b, c, d, e, f, g, h, 1, 2, 3, 4, base\n");
            break;
        case GAME_STATUS_DEFEAT:
            printf("No more possible moves. Game over!");
            break;
        case GAME_STATUS_VICTORY:
            printf("Congratulations, you won!");
            break;
    }
}

void receiveUserInput()
{
    char *c = malloc(sizeof(char[5]));
    int i;
    scanf("%5s", c);
    //verificar estado do jogo
    if(gameStatus == GAME_STATUS_START || gameStatus == GAME_STATUS_CHOSECARD)
    {
        //if(c[0] == 'a') i = 0;
        //if
        if(c[0] >= 'a' && c[0] <= 'h')
        {
            i = (int)(c[0] - 'a'); //a=0, b=1, c=2, d=3, e=4, f=5, g=6, h=7
            selectedSlot = mid_slots[i];
        }
        else if(c[0] >= '1' && c[0] <= '4')
        {
            i = (int)(c[0] - '1');
            selectedSlot = top_slots[i];
        }
        else{
            printf("Invalid selection! \nValid options are a,b,c,d,e,f,g,h,1,2,3,4!\n");
            free(c);
            receiveUserInput();
            return;
        }


        if(selectedSlot->start == NULL)
        {
            printf("This pile has no cards! Please select another slot.\n");
            free(c);
            receiveUserInput();
            return;
        }

        gameStatus = GAME_STATUS_CHOSETARGET;
    }
    else if(gameStatus == GAME_STATUS_CHOSETARGET)
    {
        Pile *targetSlot;
        if(strcasecmp(c, "base") == 0)
        {
            strcpy(c, "     ");
            free(c);
            if(canMoveToBase(selectedSlot) == 1)
            {
                moveCardToBase(selectedSlot);
                checkGameStatus();
                selectedSlot = NULL;
                drawBoard();
                return;
            }
            else
            {
                selectedSlot = NULL;
                printf("Invalid move! Please select another card.\n");
                gameStatus = GAME_STATUS_CHOSECARD;
                receiveUserInput();
                return;
            }

        }
        else if(c[0] >= 'a' && c[0] <= 'h')
        {
            i = (int)(c[0] - 'a'); //a=0, b=1, c=2, d=3, e=4, f=5, g=6, h=7
            targetSlot = mid_slots[i];
        }
        else if(c[0] >= '1' && c[0] <= '4')
        {
            i = (int)(c[0] - '1');
            targetSlot = top_slots[i];
            //top_slots may only receive one card at a time
            if(targetSlot->length > 0)
            {
                printf("Invalid move! Please select another card to move.\n");
                free(c);
                selectedSlot = NULL;
                gameStatus = GAME_STATUS_CHOSECARD;
                receiveUserInput();
                return;
            }
        }
        else{
            printf("Invalid selection! \nValid options are a,b,c,d,e,f,g,h,1,2,3,4,base!");
            free(c);
            receiveUserInput();
            return;
        }

        if(canMove(selectedSlot, targetSlot) == 1)
        {
            moveCardToPile(selectedSlot, targetSlot);
            checkGameStatus();
        }
        else{
            printf("Invalid move! Please select another card to move.\n");
            free(c);
            selectedSlot = NULL;
            gameStatus = GAME_STATUS_CHOSECARD;
            receiveUserInput();
            return;
        }
    }

    free(c);
    drawBoard();
}

void checkGameStatus()
{
    //Ler os slots e verificar se o jogo acabou, e determinar o status do jogo

    //se o length dos top_slots for 13, eles estão cheios e o jogo acabou em vitória
    if(top_slots[0]->length == 13 && top_slots[1]->length == 13 && top_slots[2]->length == 13 && top_slots[4]->length == 13){
        gameStatus = GAME_STATUS_VICTORY;
        return;
    }

    //Se nenhum movimento for possível, o jogo resulta em derrota
    Pile *a, *b;
    int j;
    int isDefeat = 1; //Assume que é derrota inicialmente; se achar um movimento válido, vira vitória

    a = mid_slots[0];
    for(j=0; j<8; j++)
    {
        b = mid_slots[j];
        if(canMove(a, b) == 1 || canMove(b, a) == 1){
            isDefeat = 0;
            break; //Já foi determinado que não é derrota
        }
        if(j<4)
        {
            b = top_slots[j];
            if(top_slots[j]->length == 0)
            {
                isDefeat = 0;
                break;
            }
        }
    }

    if(isDefeat == 1)
        gameStatus = GAME_STATUS_DEFEAT;
    else
        gameStatus = GAME_STATUS_CHOSECARD;

}