Lista das funções utilizadas no Blackjack

Int initializeGame(ListCardNodePtr* deckPtr, ListCardNodePtr* tablePtr,

ListCardNodePtr* playerPtr, int* sumTable, int* sumPlayer, const char* const
wSuit[], const char* const wFace[])

Ela é responsável por inicializar o Blackjack, recebendo como parâmetros

várias estruturas de dados, ponteiros para as listas de cartas do baralho (deckPtr), da
mesa (tablePtr) e do jogador (playerPtr), além de ponteiros para variáveis que
armazenam a soma das cartas na mesa (sumTable) e do jogador (sumPlayer), e as
strings wSuit e wFace que representam os naipes e valores das cartas.
Primeiro ela define as variáveis *sumPlayer e *sumTable como 0, preenche o
baralho com cartas usando a função “fillDeck”, passando os naipes e valores das
cartas, embaralha o baralho usando a função “shuffle”, distribui duas cartas do baralho
para o jogador usando a função “deal”, passando o ponteiro playerPtr e o número 2
para indicar a quantidade de cartas a serem distribuídas, depois organiza as cartas do
jogador usando a função “organize”, imprime as cartas do jogador usando a função
“show” ,em seguida, conta os pontos das cartas do jogador usando a função
“countCards” e armazena o resultado em *sumPlayer e depois imprime os pontos do
jogador, compra uma carta do baralho e adiciona à mesa usando a função "buyCard
”passando o ponteiro tablePtr como argumento, bem como as strings wSuit e wFace e
faz de forma análoga para o delaer.

int playerTurn(ListCardNodePtr* deckPtr, ListCardNodePtr* tablePtr,

ListCardNodePtr* playerPtr, int sumTable, int* sumPlayer, const char* const
wSuit[], const char* const wFace[])

A função playerTurn representa a vez do jogador durante o jogo. Permitindo

assim que o jogador tome decisões durante sua jogada, como comprar uma carta ou
parar de comprar. Ela recebe como parâmetros os ponteiros para as listas de cartas
do baralho (deckPtr), da mesa (tablePtr) e do jogador (playerPtr), o valor atual das
cartas da mesa (sumTable), o ponteiro para a variável que armazena a soma das
cartas do jogador (sumPlayer), bem como as strings wSuit e wFace que representam
os naipes e valores das cartas.
Primeiro declara a variável “choice” para armazenar a escolha do jogador, inicia
um loop do-while que executa até que a escolha do jogador seja '2' (parar), exibindo
as opções para o jogador, solicitando que ele pressione '1' para comprar uma carta ou
'2' para parar, lê a escolha do jogador usando a função “scanf”. Caso a escolha do
jogador seja '1', exibe uma mensagem informando que o jogador escolheu comprar, e
então compra uma carta do baralho usando a função “buyCard” passando o ponteiro
playerPtr como argumento. Em seguida, calcula os pontos das cartas do jogador
usando a função “countCards” e armazena o resultado em *sumPlayer, o loop continua
enquanto a escolha do jogador for diferente de '2' e retorna 1 se a soma das cartas do
jogador for maior que 21 (indicando que o jogador perdeu) ou 0 caso contrário.
int dealerTurn(ListCardNodePtr* deckPtr, ListCardNodePtr* tablePtr,
ListCardNodePtr* playerPtr, int* sumTable, int sumPlayer, int lossPlayer, const
char* const wSuit[], const char* const wFace[])

A função dealerTurn representa a vez do dealer durante o jogo. Ela controla as

ações da mesa e decide se deve comprar cartas adicionais ou parar. A função recebe
como parâmetros os ponteiros para as listas de cartas do baralho (deckPtr), da mesa
(tablePtr) e do jogador (playerPtr), um ponteiro para a variável que armazena a soma
das cartas da mesa (sumTable), o valor atual das cartas do jogador (sumPlayer), um
indicador de perda do jogador (lossPlayer), bem como as strings wSuit e wFace que
representam os naipes e valores das cartas.
Primeiro ela exibe uma mensagem indicando que é a vez da mesa, mostra as
cartas da mesa usando a função “show”, em seguida, imprime os pontos da mesa na
tela, depois entra em um loop while que continua enquanto a soma das cartas da
mesa for menor ou igual à soma das cartas do jogador ou menor que 17 e o jogador
não tenha perdido. Verifica se ainda há cartas disponíveis no baralho usando a função
“buyCard”. Se a função retornar -1, significa que o baralho acabou e exibe uma
mensagem informando que a mesa tentou comprar uma carta, mas o baralho acabou.
Em seguida, o loop é interrompido, mas se houver cartas disponíveis no baralho, a
mesa compra uma carta usando a função “buyCard” e atualiza a soma das cartas da
mesa chamando a função “countCards”. Exibe as cartas da mesa usando a função
“show” e imprime os pontos da mesa na tela. O loop continua enquanto a soma das
cartas da mesa for menor ou igual à soma das cartas do jogador, menor que 17 e o
jogador não tenha perdido, se a soma das cartas da mesa for maior que 21, significa
que a mesa estourou e retorna 1 para indicar que a mesa perdeu, se a mesa não
estourou, exibe uma mensagem informando que a mesa parou e retorna 0 para indicar
que a mesa não perdeu.

int displayResults(int sumTable, int sumPlayer, int lossPlayer, int lossTable)

Ela exibe os resultados do jogo, comparando as pontuações da mesa e do

jogador usando a condição de vitória ou perda. A função recebe como parâmetros a
pontuação da mesa (sumTable), a pontuação do jogador (sumPlayer), uma indicação
de perda do jogador (lossPlayer) e uma indicação de perda da mesa (lossTable), e
exibe a pontuação do jogador e da mesa usando a variável sumPlayer. E sumTable
respetivamente. Após isso verifica se o jogador perdeu (lossPlayer == 1). Se for
verdadeiro, exibe uma mensagem indicando que a mesa ganhou e o jogador perdeu.
Em seguida verifica se a mesa estourou (lossTable == 1). Se for verdadeiro, exibe uma
mensagem indicando que a mesa estourou e o jogador ganhou. Porém se nenhuma
das condições acima for atendida, compara as pontuações do jogador e da mesa. Se
a pontuação do jogador for maior que a pontuação da mesa, exibe uma mensagem
indicando que o jogador ganhou e se a pontuação do jogador for menor que a
pontuação da mesa, exibe uma mensagem indicando que a mesa ganhou e o jogador
perdeu. Mas se nenhuma das condições acima for atendida, significa que há um
empate e exibe uma mensagem indicando isso. e depois retorna 0 para indicar o final
do jogo.

int countCards(ListCardNodePtr* sPtr, const char* const wSuit[], const char*

const wFace[])

Ela é responsável por calcular a pontuação total das cartas em uma mão do
jogador e da mesa. Recebendo um ponteiro para o início da lista encadeada de cartas
(sPtr), e das representações de naipes (wSuit) e faces (wFace) das cartas.
Primeiro declara as variáveis rank, aceCount e pointsHand. “rank” é usada para
armazenar o valor numérico da carta atual. “aceCount” é usado para controlar a
quantidade de Ás presentes na mão do jogador. “pointsHand” é usado para acumular a
pontuação total da mão.Inicia um loop que percorre cada carta na lista encadeada de
cartas, dentro dele, obtém o valor numérico da carta usando a função “rank_a_card”,
passando a carta atual, as representações de naipes e faces como parâmetros. O
valor retornado é armazenado em rank.
Verifica se rank é igual a 1 (Ás) e se aceCount é igual a 0. Isso indica que é o
primeiro Ás encontrado na mão do jogador. Nesse caso, incrementa aceCount para
indicar que já foi encontrado um Ás e adiciona 11 pontos a pointsHand (pois o Ás pode
valer 11 ou 1 ponto). Caso contrário, verifica se rank está entre 1 e 10 (ou seja, é uma
carta numérica). Nesse caso, adiciona o valor de rank a pointsHand. Se nenhuma das
condições anteriores for atendida, significa que a carta é uma figura (rei, rainha,
valete). Nesse caso, adiciona 10 pontos a pointsHand. Após percorrer todas as cartas,
verifica se pointsHand é maior que 21 e se aceCount é igual a 1. Isso indica que há
pelo menos um Ás na mão do jogador, e a pontuação total excede 21. Nesse caso,
subtrai 10 pontos de pointsHand (representando a conversão do valor de um Ás de 11
para 1 ponto).Retorna pointsHand, que representa a pontuação total da mão.

int isEmpty(ListCardNodePtr sPtr)

Ela realiza a verificação comparando o ponteiro sPtr com NULL. Se sPtr for
igual a NULL, significa que a lista está vazia, pois não há nenhum nó na lista. Nesse
caso, a função retorna 1 para indicar que a lista está vazia. Caso contrário, se sPtr não
for NULL, significa que a lista contém pelo menos um nó, e a função retorna 0 para
indicar que a lista não está vazia.

int fillDeck(ListCardNodePtr* sPtr, const int Ncards, const char* const wSuit[],
const char* const wFace[])

A função fillDeck preenche um deck (uma lista encadeada de cartas) com um

número específico de cartas. Ela recebe como parâmetros um ponteiro sPtr para a
lista encadeada, o número total de cartas Ncards, um array wSuit contendo os naipes
das cartas, e um array wFace contendo as faces das cartas. Verificando se o deck
está vazio (ou seja, se o ponteiro sPtr é igual a NULL) e se o número de cartas Ncards
é maior que zero. Se essas condições forem atendidas, o deck é preenchido com as
cartas.
A primeira carta é inserida manualmente no deck, criando um nó da lista
encadeada. Em seguida, um loop é executado para preencher o restante das cartas.
Cada iteração do loop cria um nó da lista, preenchendo sua estrutura cardStr com a
face e o naipe correspondentes. O novo nó é ligado ao final da lista existente e o
ponteiro lastPtr é atualizado para apontar para o novo nó. Após o loop, a função
retorna o número de cartas inseridas no deck, que é igual a Ncards. Caso a lista já
contenha cartas ou Ncards seja menor ou igual a zero, a função retorna zero,
indicando que nenhuma carta foi inserida.

int show(ListCardNodePtr cardPtr)

A função show é responsável por exibir as cartas do baralho. Ela recebe como
parâmetro um ponteiro cardPtr para o primeiro nó da lista e percorre a lista, imprimindo
cada carta na saída padrão.
O loop percorre a lista encadeada enquanto o ponteiro cardPtr não for nulo. Em
cada iteração do loop, a função imprime a face e o naipe da carta atual usando printf.
A formatação %5s é usada para imprimir a face da carta em um espaço de 5
caracteres, alinhado à direita. A formatação %-8s é usada para imprimir o naipe da
carta em um espaço de 8 caracteres, alinhado à esquerda. Após imprimir cada carta, a
função verifica se o número de cartas impressas é ímpar (usando a expressão (i + 1)
% 2) e decide se deve imprimir uma tabulação ('\t') ou uma nova linha ('\n') para
organizar as cartas em duas colunas. No final da função, o valor de i é retornado,
representando o número total de cartas exibidas.

int Nnodes(ListCardNodePtr nodePtr)

A função Nnodes é responsável por contar o número de nós na lista

encadeada. Ela recebe como parâmetro um ponteiro nodePtr para o primeiro nó da
lista e percorre a lista contando cada nó encontrado.
O loop percorre a lista encadeada enquanto o ponteiro nodePtr não for nulo.
Em cada iteração do loop, a função incrementa a variável i em 1 para contar um novo
nó e atualiza o ponteiro nodePtr para apontar para o próximo nó da lista. Quando o
loop termina, ou seja, quando o ponteiro nodePtr se torna nulo, a função retorna o
valor de i, que representa o número total de nós contados na lista.

int shuffle(ListCardNodePtr* sPtr)

 A função shuffle implementa o algoritmo de embaralhamento de cartas da lista
encadeada. Ela recebe como parâmetro um ponteiro sPtr para o primeiro nó da lista e
realiza as trocas necessárias para embaralhar aleatoriamente os nós da lista.
O algoritmo percorre a lista encadeada usando dois ponteiros PiAnt e Pi para
rastrear os nós consecutivos. Em cada iteração do loop externo, o ele seleciona
aleatoriamente um índice j entre i+1 e N-1, onde i é o índice atual do loop. Isso
determina o nó a ser trocado com o nó atual. Em seguida, percorre a lista até o nó de
índice j usando os ponteiros PjAnt e Pj. Esses ponteiros são usados para encontrar os
endereços dos nós PjAnt e Pj na lista. Depois de localizados os nós a serem trocados,
o algoritmo realiza as trocas necessárias para embaralhar os nós. Ele ajusta os
ponteiros nextCardPtr para trocar os nós Pi e Pj com os nós adjacentes. O algoritmo
atualiza os ponteiros PiAnt e Pi para avançar para o próximo par de nós na lista. O
ponteiro PiAnt é usado para atualizar corretamente o ponteiro nextCardPtr do nó
anterior ao nó Pj, enquanto o ponteiro Pi é usado para rastrear o próximo nó a ser
processado.Após o término do loop, o algoritmo retorna o número de iterações
realizadas, que é igual a N - 1, onde N é o número de nós na lista.

int rank_a_card(ListCardNodePtr cardNode, const char* const wSuit[], const

char* const wFace[])

A função rank_a_card recebe como parâmetros um ponteiro cardNode para um

nó de carta da lista encadeada e duas listas de strings wSuit e wFace que
representam os naipes e as faces das cartas, respectivamente. A função retorna o
valor numérico correspondente ao ranking da carta. A função constrói uma string card
concatenando a face e o naipe da carta contidos no nó cardNode. Em seguida, ela
itera sobre as possíveis combinações de naipes e faces usando os loops for aninhado.
Dentro do loop, a função cria uma string card2 concatenando a face e o naipe atual
das listas wSuit e wFace. Ela compara a string card com card2 usando a função
strcmp para verificar se são iguais. Quando uma correspondência é encontrada, a
função retorna um valor calculado com base no índice dos loops i e j, representando o
ranking da carta.Se não for encontrada nenhuma correspondência, a função retorna 0,
indicando que o ranking da carta não foi encontrado.

int compare(ListCardNodePtr cardNode1, ListCardNodePtr cardNode2, const

char* const wSuit[], const char* const wFace[])

A função compare recebe dois nós de carta, cardNode1 e cardNode2, juntamente com
as listas de naipes wSuit e faces wFace. A função retorna um valor inteiro indicando a
comparação entre as cartas com base em seus rankings.
Primeiro, a função chama a função rank_a_card para obter os rankings das
cartas representadas pelos nós cardNode1 e cardNode2. Os rankings são
armazenados nas variáveis rank1 e rank2, respectivamente. Em seguida, a função
compara os rankings das cartas. Se rank1 for maior que rank2, a função retorna 1,
indicando que cardNode1 tem um ranking maior e é considerada "maior" em
comparação com cardNode2. Se rank1 for menor que rank2, a função retorna -1,
indicando que cardNode1 tem um ranking menor e é considerada "menor" em
comparação com cardNode2. Se os rankings forem iguais, a função retorna 0,
indicando que as cartas são consideradas "iguais".

int buyCard(ListCardNodePtr* tableDeckPtr, ListCardNodePtr* playerHandPtr,

const char* const wSuit[],const char* const wFace[])

A função buyCard faz a ação do jogador de comprar uma carta do baralho. Ela
recebe como argumentos um ponteiro para o topo do baralho (tableDeckPtr), um
ponteiro para a mão do jogador (playerHandPtr), uma lista de naipes (wSuit) e uma
lista de faces (wFace).
Ela verifica se o baralho está vazio, verificando se o ponteiro para o topo do
baralho é nulo. Se o baralho estiver vazio, a função retorna -1 para indicar que a
compra não pode ser feita.
Em seguida, a função obtém a carta do topo do baralho (card) e aloca memória
para um novo nó da lista de cartas do jogador (newPtr). A carta é atribuída ao campo
cardStr do novo nó e o campo nextCardPtr é definido como nulo. Depois,verifica se a
mão do jogador está vazia. Se estiver vazia, o novo nó é atribuído como o primeiro nó
da mão (playerHandPtr). Caso a mão do jogador não esteja vazia, a função compara a
nova carta (newPtr) com a primeira carta da mão (aux) usando a função “compare”. Se
a nova carta for considerada menor, ou seja, compare retorna -1, a nova carta é
inserida antes da primeira carta da mão e se torna o novo primeiro nó.
Se a nova carta for considerada maior ou igual à primeira carta da mão, a
função percorre a mão até encontrar a posição correta para inserir a nova carta. A
cada iteração, a função compara a nova carta com a carta atual usando compare e
avança para o próximo nó até encontrar uma carta que seja maior que a nova carta.
Nesse ponto, a nova carta é inserida antes dessa carta. Caso a função percorra toda a
mão sem encontrar uma carta maior, a nova carta é inserida no final da mão.
Após inserir a nova carta na mão do jogador, a função atualiza o ponteiro do
topo do baralho (tableDeckPtr) para apontar para o próximo nó do baralho e libera a
memória do nó removido.

int deal(ListCardNodePtr* tableDeckPtr, ListCardNodePtr* playerHandPtr, int

Ncards, const char* const wSuit[],const char* const wFace[])

A função deal simula a distribuição de cartas para o jogador. Ela recebe como
argumentos um ponteiro para o topo do baralho (tableDeckPtr), um ponteiro para a
mão do jogador (playerHandPtr), o número de cartas a serem distribuídas (Ncards),
uma lista de naipes (wSuit) e uma lista de faces (wFace).
A função realiza um loop for para comprar Ncards cartas do baralho e adicioná-
las à mão do jogador. A cada iteração, a função chama a função buyCard, passando o
ponteiro para o topo do baralho, o ponteiro para a mão do jogador e as listas de naipes
e faces.Após comprar todas as cartas, a função retorna o número total de cartas
distribuídas (Ncards).

int organize(ListCardNodePtr* sPtr, const char* const wSuit[], const char* const
wFace[])

A função organiza as cartas em ordem crescente na lista ligada de cartas. Ela

recebe como argumentos um ponteiro para o topo da lista de cartas (sPtr), uma lista
de naipes (wSuit) e uma lista de faces (wFace).
Ela percorre a lista de cartas usando dois ponteiros auxiliares (aux e aux2).
Comparando cada par de cartas consecutivas na lista usando a função “compare”. Se
a primeira carta for maior do que a segunda, ocorre uma troca de posição entre as
cartas.
A função continua percorrendo a lista até que todas as cartas estejam em
ordem crescente. O número total de trocas realizadas durante a organização é
contado e retornado pela função.