Repository navigation
Expand file tree
/
Copy pathinterface.c
More file actions
184 lines (145 loc) · 6.92 KB
/
Copy pathinterface.c
File metadata and controls
184 lines (145 loc) · 6.92 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
#include <stdio.h>
#include "interface.h"
// Repõe os campos de destaque do estado a -1 (sem sugestão activa).
void limparDestaques(EstadoJogo *e) {
e->destaque_coluna = -1; // -1 significa que nenhuma coluna está selecionada
e->destaque_baralho = -1; // -1 significa que o baralho não está selecionado
}
// Emite o código de cor ANSI adequado antes de desenhar uma carta.
static void setCorCarta(Cartas c, int destaque) {
// PRIORIDADE 1: Se a carta for a dica da jogada, pinta de Roxo
if (destaque) printf(COR_ROXA);
// PRIORIDADE 2: Se for Copas (1) ou Ouros (2), pinta de Vermelho
else if (c.naipe == 1 || c.naipe == 2) printf(COR_VERMELHA);
// (Se não for nada disto, o terminal usa a cor branca/padrão naturalmente)
}
// Repõe a cor do terminal se esta tiver sido alterada.
static void resetCor(Cartas c, int destaque) {
// Só manda o comando de RESET se a cor tiver sido alterada na função acima..
if (destaque || c.naipe == 1 || c.naipe == 2) printf(COR_RESET);
}
// Desenha a linha superior de todas as cartas visíveis na linha
static void imprimirLinhaTopo(EstadoJogo *e, int linha) {
FOR(i, 7) {
// Verifica se a coluna atual (i) tem cartas suficientes para chegar a esta altura (linha)
if (linha <= e->colunas[i].topo) {
Cartas c = e->colunas[i].cartas[linha];
int dest = (i == e->destaque_coluna); // True se esta coluna for a dica
setCorCarta(c, dest);
printf("┌─────┐"); // Imprime o topo do retângulo
resetCor(c, dest);
printf("\t"); // Dá um TAB para alinhar a próxima coluna
} else {
// Se não houver carta nesta altura, imprime 7 espaços vazios para manter a formatação
// (1 borda + 5 dentro + 1 borda = 7 caracteres) + o TAB
printf(" \t");
}
}
printf("\n"); // Quebra de linha no fim das 7 colunas
}
// Desenha a linha central de todas as cartas (valor e naipe).
static void imprimirLinhaMeio(EstadoJogo *e, int linha) {
FOR(i, 7) {
if (linha <= e->colunas[i].topo) {
Cartas c = e->colunas[i].cartas[linha];
int dest = (i == e->destaque_coluna);
setCorCarta(c, dest);
// O %-2s força a letra/número a ocupar sempre 2 espaços à esquerda
// Assim, a parede direita da carta "│" fica sempre no mesmo sítio, sem entortar
printf("│ %-2s%s │", letraValor(c.valor), simboloNaipe(c.naipe));
resetCor(c, dest);
printf("\t");
} else {
printf(" \t"); // 7 espaços vazios para alinhar
}
}
printf("\n");
}
// Desenha a linha inferior de todas as cartas
static void imprimirLinhaFundo(EstadoJogo *e, int linha) {
FOR(i, 7) {
if (linha <= e->colunas[i].topo) {
Cartas c = e->colunas[i].cartas[linha];
int dest = (i == e->destaque_coluna);
setCorCarta(c, dest);
printf("└─────┘"); // Imprime o fundo do retângulo
resetCor(c, dest);
printf("\t");
} else {
printf(" \t"); // 7 espaços vazios para alinhar
}
}
printf("\n");
}
// Desenha uma das 3 linhas da carta do descarte (parte 1/2/3).
static void desenharDescarte(EstadoJogo *e, int parte) {
// Se o monte de descarte estiver vazio, imprime apenas buracos em branco
if (e->descarte.topo < 0) { printf(" \n"); return; }
Cartas d = e->descarte.cartas[e->descarte.topo];
setCorCarta(d, 0); // Passamos 0 no destaque porque o descarte nunca é sugerido a roxo
// A variável 'parte' diz à função se deve desenhar o teto, o meio ou o chão
if (parte == 1) printf("┌─────┐\n");
if (parte == 2) printf("│ %-2s%s │\n", letraValor(d.valor), simboloNaipe(d.naipe));
if (parte == 3) printf("└─────┘\n");
resetCor(d, 0);
}
/* (auxiliar de imprimirCabecalho)
Desenha uma linha do baralho (topo/meio/fundo) com cor condicional
e chama a parte correspondente do descarte. */
static void desenharLinhaBaralho(EstadoJogo *e, int dest, int parte) {
// Guarda as 3 partes num array para não ter de fazer 'if(parte == 1)' etc.
const char *linhas[] = {"┌─────┐", "│ ? │", "└─────┘"};
if (dest) printf(COR_ROXA);
// Imprime a parte correspondente (-1 porque os arrays começam no índice 0)
printf("%s\t\t", linhas[parte - 1]);
if (dest) printf(COR_RESET);
// Aproveita e manda desenhar a mesma parte para a carta do descarte, que fica ao lado
desenharDescarte(e, parte);
}
// Desenha a zona superior: baralho (lado esquerdo) e descarte.
static void imprimirCabecalho(EstadoJogo *e) {
printf("\n========================================================================\n");
// O +1 serve porque o topo é um índice (começa no 0). Se o topo for 15, há 16 cartas.
printf("Baralho (%d)\tDescarte\n", e->baralho.topo + 1);
// O código 7 foi o que escolhemos no calcularMelhorJogada para indicar "Tirar do Baralho"
int dest = (e->destaque_baralho == 7);
// Pede à função auxiliar para desenhar as 3 fatias das cartas de cima
desenharLinhaBaralho(e, dest, 1);
desenharLinhaBaralho(e, dest, 2);
desenharLinhaBaralho(e, dest, 3);
printf("\n"); // Separa o cabeçalho do resto da mesa
}
/* imprimirCabecalhosColunas (auxiliar de mostrarMesa)
Imprime os rótulos "Col 1" … "Col 7", destacando o sugerido. */
static void imprimirCabecalhosColunas(EstadoJogo *e) {
FOR(i, 7) {
if (i == e->destaque_coluna) printf(COR_ROXA); // Pinta a roxo se a coluna for a melhor jogada
printf("Col %d\t", i + 1); // +1 para mostrar "Col 1" ao jogador em vez de "Col 0"
if (i == e->destaque_coluna) printf(COR_RESET);
}
printf("\n\n");
}
/* (auxiliar de mostrarMesa)
Devolve o número de linhas necessárias para desenhar o tabuleiro. */
static int calcularMaxLinhas(EstadoJogo *e) {
int max = 0;
/* O terminal imprime de cima para baixo. Precisamos saber qual é a coluna com
mais cartas para saber quantas vezes o ciclo principal tem de rodar */
FOR(i, 7) {
if (e->colunas[i].topo + 1 > max) max = e->colunas[i].topo + 1;
}
return max;
}
// Função principal da interface: desenha o estado completo do jogo.
void mostrarMesa(EstadoJogo *e) {
imprimirCabecalho(e);
imprimirCabecalhosColunas(e);
int max_linhas = calcularMaxLinhas(e);
// Imprime as cartas linha a linha
FOR(linha, max_linhas) {
imprimirLinhaTopo(e, linha);
imprimirLinhaMeio(e, linha);
imprimirLinhaFundo(e, linha);
}
printf("========================================================================\n");
}