Skip to content

Instantly share code, notes, and snippets.

@Renatodeluna

Renatodeluna/C

Created June 7, 2026 23:40
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save Renatodeluna/88fe3732ff870c66e67336da4738acb8 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save Renatodeluna/88fe3732ff870c66e67336da4738acb8 to your computer and use it in GitHub Desktop.
Download ZIP
Jogo Torneiro dos Dados
Raw
C
/*
=============================================================
TORNEIO DOS DADOS - Batalha Suprema
=============================================================
Instituicao: Instituto Federal de Sao Paulo
Curso: Especializacao em Desenvolvimento de Sistemas Web
e Aplicativos Moveis
Aluno: Renato de Luna Guedes
Modulo: 3 - Estruturas de Repeticao (for, while, do-while)
=============================================================
DESCRICAO DO JOGO:
O jogador enfrenta um oponente (CPU) em um torneio de
dados. Ambos lancam dados e acumulam pontos ao longo de
rounds. O jogador pode usar "poder especial" limitado.
Vence quem chegar primeiro a 30 pontos (ou tiver mais
pontos ao fim dos 10 rounds).
ESTRUTURAS UTILIZADAS:
- for : controla os rounds do torneio
- while : loop principal do menu
- do-while: validacao de escolha de poder especial
CORRECOES APLICADAS (v2):
[1] system("clear") substituido por solucao compativel
com Windows (Dev C++) usando diretivas #ifdef/#else.
No Windows usa "cls"; no Linux/Mac usa "clear".
[2] Variavel "char tecla" removida (estava declarada
mas nunca utilizada - warning de compilacao).
[3] Variavel "ganhouRound" removida (estava declarada
mas nunca lida apos atribuicao - warning de compilacao).
[4] Corrigido bug de ENTER extra: quando o jogador nao
usa poder (opcao 2), o getchar() pre-lancamento nao
era necessario pois o buffer ja estava limpo.
Adicionada variavel "bufferLimpo" para controlar
isso sem usar vetores ou funcoes extras.
=============================================================
*/
#include <stdio.h> /* Para scanf, printf */
#include <stdlib.h> /* Para rand(), srand(), system() */
#include <time.h> /* Para time() - semente do random */
/*
CORRECAO [1] - Compatibilidade Windows / Linux / Mac
----------------------------------------------------
O Dev C++ roda no Windows, onde o comando de limpar
a tela e "cls". No Linux e Mac e "clear".
A diretiva #ifdef verifica o sistema operacional
em tempo de compilacao e define a macro correta.
Assim o mesmo codigo compila em qualquer plataforma.
*/
#ifdef _WIN32
#define LIMPAR_TELA system("cls")
#else
#define LIMPAR_TELA system("clear")
#endif
int main() {
/* --- Declaracao de todas as variaveis --- */
int pontosJogador = 0; /* Pontuacao total do jogador */
int pontosCPU = 0; /* Pontuacao total da CPU */
int dadoJogador = 0; /* Resultado do dado do jogador */
int dadoCPU = 0; /* Resultado do dado da CPU */
int round = 1; /* Contador de rounds (1 a 10) */
int poderes = 2; /* Qtd. de poderes especiais disp. */
int usarPoder = 0; /* Escolha: usa poder? 1=Sim 2=Nao */
int opcaoPoder = 0; /* Qual poder: 1=Dobrar 2=Bloquear */
int continuarJogo = 1; /* Controla o loop do menu principal */
int escolhaMenu = 0; /* Opcao do menu principal */
int dadoExtra = 0; /* Dado extra para o poder Dobrar */
int dadoBloqueio = 0; /* Dado da CPU no poder Bloquear */
int entradaValida = 0; /* Flag de validacao do do-while */
int bufferLimpo = 0; /* Controla se o buffer ja foi limpo */
/* --- Inicializacao do gerador de numeros aleatorios --- */
/* srand usa o tempo atual como semente para garantir */
/* que os numeros sejam diferentes a cada execucao */
srand((unsigned int)time(NULL));
/* =====================================================
TELA DE TITULO - exibida uma vez ao iniciar
===================================================== */
LIMPAR_TELA;
printf("\n");
printf(" ============================================\n");
printf(" || ||\n");
printf(" || TORNEIO DOS DADOS ||\n");
printf(" || *** BATALHA SUPREMA *** ||\n");
printf(" || ||\n");
printf(" ============================================\n");
printf(" || Modulo 3 - For, While e Do-While ||\n");
printf(" || IFSP - Renato de Luna Guedes ||\n");
printf(" ============================================\n");
printf("\n");
printf(" Pressione ENTER para comecar...\n");
getchar(); /* Aguarda ENTER do usuario */
/* =====================================================
MENU PRINCIPAL
ESTRUTURA: WHILE
- Repete enquanto o jogador nao escolher Sair
- Condicao de permanencia: continuarJogo == 1
===================================================== */
while (continuarJogo == 1) {
LIMPAR_TELA;
printf("\n");
printf(" ============================================\n");
printf(" || MENU PRINCIPAL ||\n");
printf(" ============================================\n");
printf(" || [1] Novo Jogo ||\n");
printf(" || [2] Como Jogar / Regras ||\n");
printf(" || [3] Sair ||\n");
printf(" ============================================\n");
printf("\n Escolha uma opcao: ");
scanf("%d", &escolhaMenu);
getchar(); /* Limpa o '\n' deixado pelo scanf no buffer */
/* ------------------------------------------------
OPCAO 2: Exibe as regras do jogo
------------------------------------------------ */
if (escolhaMenu == 2) {
LIMPAR_TELA;
printf("\n");
printf(" ============================================\n");
printf(" || COMO JOGAR ||\n");
printf(" ============================================\n");
printf("\n OBJETIVO:\n");
printf(" Alcance 30 pontos antes da CPU, ou tenha\n");
printf(" mais pontos ao fim de 10 rounds.\n");
printf("\n MECANICA:\n");
printf(" - Cada round: voce e a CPU lancam 1 dado\n");
printf(" - O dado tem faces de 1 a 6\n");
printf(" - Quem tirar o maior valor ganha os pontos\n");
printf(" do round (soma dos dois dados lancados)\n");
printf(" - Em caso de empate: ninguem pontua\n");
printf("\n PODERES ESPECIAIS (voce tem 2 por partida):\n");
printf(" [1] DOBRAR : voce lanca 2 dados e usa o MAIOR\n");
printf(" [2] BLOQUEAR: a CPU lanca 2 dados e usa o MENOR\n");
printf("\n VITORIA ANTECIPADA:\n");
printf(" Se alguem atingir 30 pontos antes dos\n");
printf(" 10 rounds, o jogo termina imediatamente.\n");
printf("\n ============================================\n");
printf(" Pressione ENTER para voltar ao menu...\n");
getchar();
/* ------------------------------------------------
OPCAO 3: Encerra o while e sai do jogo
------------------------------------------------ */
} else if (escolhaMenu == 3) {
continuarJogo = 0; /* Condicao do while se torna falsa */
/* ------------------------------------------------
OPCAO 1: Inicia uma nova partida
------------------------------------------------ */
} else if (escolhaMenu == 1) {
/* Reinicializa variaveis para nova partida */
pontosJogador = 0;
pontosCPU = 0;
poderes = 2;
/* =================================================
LOOP DE ROUNDS
ESTRUTURA: FOR
- Controla exatamente 10 rounds de jogo
- Variavel de controle: round (de 1 ate 10)
- Pode ser interrompido com break se alguem
atingir 30 pontos antes do round 10
================================================= */
for (round = 1; round <= 10; round++) {
LIMPAR_TELA;
printf("\n");
printf(" ============================================\n");
printf(" || ROUND %2d / 10 ||\n", round);
printf(" ============================================\n");
printf(" || Seus pontos : %3d pts ||\n", pontosJogador);
printf(" || Pontos da CPU: %3d pts ||\n", pontosCPU);
printf(" || Poderes disp.: %d ||\n", poderes);
printf(" ============================================\n");
printf("\n");
/* -----------------------------------------
ESCOLHA DO PODER ESPECIAL
ESTRUTURA: DO-WHILE (dentro do bloco if)
- So aparece se o jogador ainda tem poderes
- O do-while garante entrada valida para
a escolha do tipo de poder (1 ou 2)
- Executa ao menos 1 vez antes de checar
----------------------------------------- */
usarPoder = 0; /* Reseta: por padrao nao usa poder */
bufferLimpo = 0; /* Reseta controle de buffer */
if (poderes > 0) {
printf(" Deseja usar um PODER ESPECIAL neste round?\n");
printf(" [1] Sim [2] Nao\n");
printf(" Opcao: ");
scanf("%d", &usarPoder);
getchar(); /* Limpa o '\n' do buffer */
bufferLimpo = 1; /* Marca que o buffer ja foi limpo */
if (usarPoder == 1) {
/* DO-WHILE: repete ate o jogador digitar 1 ou 2 */
entradaValida = 0;
do {
printf("\n Escolha o poder:\n");
printf(" [1] DOBRAR - Voce lanca 2 dados, usa o MAIOR\n");
printf(" [2] BLOQUEAR - CPU lanca 2 dados, usa o MENOR\n");
printf(" Poder escolhido: ");
scanf("%d", &opcaoPoder);
getchar(); /* Limpa o '\n' do buffer */
if (opcaoPoder == 1 || opcaoPoder == 2) {
entradaValida = 1; /* Entrada valida: sai do do-while */
} else {
printf(" Opcao invalida! Digite 1 ou 2.\n");
}
} while (entradaValida == 0);
poderes--; /* Consome 1 poder especial */
printf("\n Poder ativado! Poderes restantes: %d\n", poderes);
}
}
/* -----------------------------------------
LANCAMENTO DOS DADOS
CORRECAO [4]: o getchar() so e chamado
se o buffer ainda nao foi limpo neste
round (bufferLimpo controla isso).
Quando poderes == 0: bufferLimpo = 0,
entao getchar() aguarda o ENTER.
Quando usarPoder == 2: bufferLimpo = 1,
entao getchar() nao e chamado de novo,
evitando exigir ENTER duplo do usuario.
----------------------------------------- */
printf("\n Pressione ENTER para lancar os dados...\n");
if (bufferLimpo == 0) {
getchar(); /* So limpa se ainda nao foi limpo antes */
}
/* --- Dado do jogador --- */
if (usarPoder == 1 && opcaoPoder == 1) {
/* PODER DOBRAR: lanca 2 dados, usa o maior */
dadoJogador = (rand() % 6) + 1;
dadoExtra = (rand() % 6) + 1;
printf("\n [*] PODER DOBRAR ATIVADO!\n");
printf(" Seus dados: [%d] e [%d]", dadoJogador, dadoExtra);
if (dadoExtra > dadoJogador) {
dadoJogador = dadoExtra;
}
printf(" --> usando o maior: [%d]\n", dadoJogador);
} else {
/* Lancamento normal: 1 dado de 6 faces */
dadoJogador = (rand() % 6) + 1;
printf("\n Seu dado : [%d]\n", dadoJogador);
}
/* --- Dado da CPU --- */
if (usarPoder == 1 && opcaoPoder == 2) {
/* PODER BLOQUEAR: CPU lanca 2 dados, usa o menor */
dadoCPU = (rand() % 6) + 1;
dadoBloqueio = (rand() % 6) + 1;
printf(" [*] PODER BLOQUEAR ATIVADO!\n");
printf(" Dados da CPU: [%d] e [%d]", dadoCPU, dadoBloqueio);
if (dadoBloqueio < dadoCPU) {
dadoCPU = dadoBloqueio;
}
printf(" --> forcando o menor: [%d]\n", dadoCPU);
} else {
/* Lancamento normal da CPU */
dadoCPU = (rand() % 6) + 1;
printf(" Dado da CPU : [%d]\n", dadoCPU);
}
/* -----------------------------------------
RESOLUCAO DO ROUND
Compara os dados e atribui os pontos.
Pontos do round = dado do jogador + dado CPU.
O vencedor do round leva a soma dos dois.
----------------------------------------- */
printf("\n");
if (dadoJogador > dadoCPU) {
pontosJogador += (dadoJogador + dadoCPU);
printf(" >>> VOCE GANHOU o round! +%d pontos\n",
dadoJogador + dadoCPU);
} else if (dadoCPU > dadoJogador) {
pontosCPU += (dadoJogador + dadoCPU);
printf(" >>> CPU GANHOU o round! Ela fez +%d pontos\n",
dadoJogador + dadoCPU);
} else {
/* Dados iguais: empate, ninguem pontua */
printf(" >>> EMPATE! Ninguem pontua neste round.\n");
}
printf("\n");
printf(" ------------------------------------------\n");
printf(" Placar -> Voce: %d pts | CPU: %d pts\n",
pontosJogador, pontosCPU);
printf(" ------------------------------------------\n");
printf("\n");
/* -----------------------------------------
VERIFICACAO DE VITORIA ANTECIPADA
Se qualquer jogador atingir 30 pontos,
o for e interrompido com break antes
de completar os 10 rounds.
----------------------------------------- */
if (pontosJogador >= 30 || pontosCPU >= 30) {
printf(" *** 30 PONTOS ATINGIDOS! Fim antecipado! ***\n");
printf("\n Pressione ENTER para ver o resultado final...\n");
getchar();
break; /* Interrompe o for imediatamente */
}
/* Pausa entre rounds (nao aparece apos o ultimo round) */
if (round < 10) {
printf(" Pressione ENTER para o proximo round...\n");
} else {
printf(" Pressione ENTER para ver o resultado final...\n");
}
getchar();
} /* === FIM DO FOR (loop de rounds) === */
/* =================================================
TELA DE RESULTADO FINAL
Exibida apos os 10 rounds ou vitoria antecipada
================================================= */
LIMPAR_TELA;
printf("\n");
printf(" ============================================\n");
printf(" || RESULTADO FINAL ||\n");
printf(" ============================================\n");
printf(" || Seus pontos : %3d pts ||\n", pontosJogador);
printf(" || Pontos da CPU: %3d pts ||\n", pontosCPU);
printf(" ============================================\n");
printf("\n");
if (pontosJogador > pontosCPU) {
printf(" *** PARABENS! VOCE VENCEU O TORNEIO! ***\n");
printf(" Voce dominou a batalha de dados!\n");
} else if (pontosCPU > pontosJogador) {
printf(" *** A CPU VENCEU O TORNEIO! ***\n");
printf(" Tente novamente - a sorte muda!\n");
} else {
printf(" *** EMPATE TOTAL! QUE PARTIDA EQUILIBRADA! ***\n");
printf(" Joguem novamente para desempatar!\n");
}
printf("\n");
printf(" ============================================\n");
printf(" Pressione ENTER para voltar ao menu...\n");
getchar();
} /* === FIM DO IF escolhaMenu == 1 === */
} /* === FIM DO WHILE (menu principal) === */
/* Mensagem de encerramento */
LIMPAR_TELA;
printf("\n");
printf(" Obrigado por jogar TORNEIO DOS DADOS!\n");
printf(" IFSP - Renato de Luna Guedes\n");
printf("\n");
return 0;
}
/*
=============================================================
RESUMO DAS ESTRUTURAS DE REPETICAO UTILIZADAS:
1. WHILE (menu principal):
- Condicao: continuarJogo == 1
- Repete enquanto o jogador nao escolher Sair (opcao 3)
- Ao escolher 3, continuarJogo recebe 0 e o loop encerra
2. FOR (rounds do torneio):
- Variavel de controle: round, de 1 ate 10
- Pode ser interrompido com break (vitoria antecipada)
- A cada iteracao: exibe status, recolhe escolhas,
lanca dados, resolve round e verifica vitoria
3. DO-WHILE (validacao do poder especial):
- Executa ao menos 1 vez (caracteristica do do-while)
- Condicao de repeticao: entradaValida == 0
- Repete ate o jogador digitar 1 (Dobrar) ou 2 (Bloquear)
- Exibe mensagem de erro para entradas invalidas
COMANDO RANDOM:
- srand((unsigned int)time(NULL)): define semente unica
baseada no tempo, garantindo resultados diferentes
a cada execucao do programa
- rand() % 6 + 1: gera inteiro aleatorio de 1 a 6,
simulando um dado de seis faces
- Usado para: dado normal, poder Dobrar (2x) e
poder Bloquear (2x para a CPU)
CORRECOES v2:
[1] LIMPAR_TELA: macro com #ifdef _WIN32 para
compatibilidade Dev C++ / Windows / Linux
[2] Removida variavel "char tecla" (nunca usada)
[3] Removida variavel "ganhouRound" (nunca lida)
[4] Corrigido ENTER duplo com variavel bufferLimpo
=============================================================
*/
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment