Ir ao conteúdo
  • Cadastre-se

VisualG Avaliar Jogo da Forca


Posts recomendados

Oi pessoal, fiz meu primeiro jogo, jogo da forca. Amei o resultado. Poderiam avaliar meu algoritmo :)? 

Algoritmo "Jogo da Forca"
// Disciplina  :  [Linguagem e Lógica de Programação] 
// Professor   : Antonio Carlos Nicolodi 
// Descrição   : Jogo da Forca
// Autor(a)    : Vinícius Viana Werneck
// Data atual  : 30/01/2018

funcao Caract(palavra: caractere; posicao: inteiro): caractere
var
   R : caractere
inicio
   R <- copia(palavra, posicao,1)
   Retorne R
fimfuncao

procedimento sortear(var palavraAleatoria:caractere)
   var
      palavraDisponivel: vetor[0..15] de caractere
      ind: inteiro
   inicio
      palavraDisponivel[0] <- "reflexao"
      palavraDisponivel[1] <- "interrupcao"
      palavraDisponivel[2] <- "necessarios"
      palavraDisponivel[3] <- "ambulantes"
      palavraDisponivel[4] <- "humanidade"
      palavraDisponivel[5] <- "juventude"
      palavraDisponivel[6] <- "shopping"
      palavraDisponivel[7] <- "supermercado"
      palavraDisponivel[8] <- "proporcionar"
      palavraDisponivel[9] <- "sensatez"
      palavraDisponivel[10] <- "incidente"
      palavraDisponivel[11] <- "administracao"
      palavraDisponivel[12] <- "paralelepipedo"
      palavraDisponivel[13] <- "abacaxizeiro"
      palavraDisponivel[14] <- "autocentrado"
      palavraDisponivel[15] <- "acidente"

   ind <- Randi(15)
   palavraAleatoria <- palavraDisponivel[6]
fimprocedimento

procedimento desenhaForca()
   inicio
      EscrevaL("---+")
      EscrevaL("   |")
      EscrevaL("   |")

fimprocedimento

procedimento desenhaBoneco(n_parteBoneco: inteiro)
   var
      contador: inteiro
   inicio
      Se (n_partesBoneco = 1) então
         EscrevaL("   o  ")
      Fimse
      Se (n_partesBoneco = 2) então
         EscrevaL("   o  ")
         EscrevaL("  /   ")
      Fimse
      Se (n_partesBoneco = 3) então
         EscrevaL("   o  ")
         EscrevaL("  /|  ")
      Fimse
      Se (n_partesBoneco = 4) então
         EscrevaL("   o  ")
         EscrevaL("  /|\ ")
      Fimse
      Se (n_partesBoneco = 5) então
         EscrevaL("   o  ")
         EscrevaL("  /|\ ")
         EscrevaL("   |  ")
      Fimse
      Se (n_partesBoneco = 6) então
         EscrevaL("   o  ")
         EscrevaL("  /|\ ")
         EscrevaL("   |  ")
         EscrevaL("  /   ")
      Fimse
      Se (n_partesBoneco = 7) então
         EscrevaL("   o  ")
         EscrevaL("  /|\ ")
         EscrevaL("   |  ")
         EscrevaL("  / \ ")
      Fimse
      Para contador de n_partesBoneco ate 6 faca
         EscrevaL()
      Fimpara
fimprocedimento

procedimento Pedir(var Letra: caractere)
   inicio
      EscrevaL()
      EscrevaL("Chute uma letra: ")
      EscrevaL()
      Leia(Letra)
fimprocedimento

funcao ehRealmenteLetra(Letra: caractere): logico
var
   Resultado: logico
inicio
   Se (maiusc(Letra) >= "A") e (maiusc(Letra) <= "Z") então
      Resultado <- verdadeiro
   Senao
      Resultado <- falso
   Fimse
   Retorne Resultado
fimfuncao

funcao jafoiDita(Letra:caractere):logico
var
   Resultado: logico
   contador: inteiro
Inicio
   Resultado <- falso
   Para contador de 1 ate compr(LetrasJaDitas) faca
      Se (Caract(Letra,contador) = Caract(LetrasJaDitas,contador)) então
         Resultado <- verdadeiro
      Fimse
   Fimpara
   Se (Resultado = falso) então
      LetrasJaDitas <- LetrasJaDitas + Letra
   Fimse
   Retorne Resultado
fimfuncao

funcao acertou(Letra:caractere):logico
var
   contador: inteiro
   Resultado : logico
inicio
   contador <- 1
   Resultado <- falso
   Para contador de 1 ate compr(palavraAleatoria) faca
      Se (Letra = Caract(palavraAleatoria,contador)) então
         ParteDescoberta[contador] <- Letra
         Resultado <- verdadeiro
      Fimse
   Fimpara
   Retorne Resultado
fimfuncao

procedimento EscreverVetor()
var
   cont: inteiro
inicio
   Escreva("   ")
   Para cont de 1 ate TamMaiorPalavra faca
      Escreva(parteDescoberta[cont], " ")
   Fimpara
fimprocedimento

procedimento Desenhae_Escreve(quadro,letra: caractere)
inicio
   EscrevaL("+-------+")
   EscrevaL("|",quadro:7,"|")
   EscrevaL("+-------+")
   EscrevaL()
fimprocedimento

funcao revelouTudo():logico
var
   i: inteiro
   letrasDescobertas: inteiro
   JogoFinalizou : logico
inicio
   i<-1
   letrasDescobertas <- 0
   Para i de 1 ate compr(palavraAleatoria) faca
      Se (parteDescoberta[i] = copia(palavraAleatoria,i,1)) então
         letrasDescobertas <- letrasDescobertas + 1
      Fimse
   FimPara
   Se (letrasDescobertas = compr(palavraAleatoria)) então
      JogoFinalizou <- verdadeiro
   Fimse
   Retorne JogoFinalizou
fimfuncao

const
   TamMaiorPalavra = 46

Var
// Seção de Declarações das variáveis 
   palavraAleatoria: caractere
   quadro: caractere
   n_partesBoneco: inteiro
   ParteDescoberta: vetor[1..TamMaiorPalavra] de caractere
   contador: inteiro
   Letra: caractere
   LetrasJaDitas: caractere
   Boneco_esta_Completo: logico
Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
   sortear(palavraAleatoria)      //Ok
   DesenhaForca()
   DesenhaBoneco(n_partesBoneco)

   //Atribui valores a parteDescoberta e escreve:
      Escreva("   ")
      Para contador de 1 ate compr(palavraAleatoria) faca
         ParteDescoberta[contador] <- "__"
         Escreva(ParteDescoberta[contador])
         Escreva(" ")
      FimPara
      EscrevaL()
   //-----------

   n_partesBoneco <- 0
   Boneco_esta_Completo <- falso
   Repita
      Pedir(Letra)
      Se ehRealmenteLetra(Letra) então
         Se jafoiDita(Letra) então
            LimpaTela
            DesenhaForca()
            DesenhaBoneco(n_partesBoneco)
            Desenhae_Escreve(quadro,letra)
            EscreverVetor()
         Senao
            LimpaTela
            DesenhaForca()
            Se acertou(Letra) então
               //Vai atribuir letra às posições correspondente na função acertou()
            Senao
               n_partesBoneco <- n_partesBoneco + 1
               Se (n_partesBoneco = 7) então
                  Boneco_esta_Completo <- verdadeiro
               Fimse
               quadro <- quadro + Letra
            Fimse
            DesenhaBoneco(n_partesBoneco)
            Desenhae_Escreve(quadro,letra)
            EscreverVetor()
         Fimse
      Senao
         LimpaTela
         DesenhaForca()
         DesenhaBoneco(n_partesBoneco)
         Desenhae_Escreve(quadro,letra)
         EscreverVetor()
      Fimse
   Ate revelouTudo() ou (Boneco_esta_Completo)

Fimalgoritmo

 

  • Curtir 2
Link para o comentário
Compartilhar em outros sites

  • Membro VIP

Olá @Vinícius Werneck.

 

Bacana a proposta... mas vamos direto à avaliação:

 

1) SORTEIO DA PALAVRA

13 horas atrás, Vinícius Werneck disse:

   ind <- Randi(15)
   palavraAleatoria <- palavraDisponivel[6]

Está usando sempre a mesma palavra. Não está sorteando. No caso precisa ajustar outras partes do código para essa questão.

 

 

 

2) LER UMA LETRA

Na hora de chutar, está aceitando mais de um caractere de uma só vez. Não deveria. Inclusive pode dar pau, com se digitar uma letra válida junto com outra. Não dará mais para digitar...

 

 

 

3) ACEITANDO SOMENTE LETRAS

Na visão do usuário, ao digitar uma "não letra", não acontece nada. Precisaria de um feedback. Quando acerta a palavra também precisa...

 

 

 

4) ACEITANDO LETRAS REPETIDAS

O programa está aceitando digitar letras que já foram digitadas.

 

 

 

***

 

Por enquanto é isso.

 

No aguardo.

 

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

Oi, fiz as correções. Não tinha percebido. Também coloquei a descrição do programa e resumi mais para não repetir comandos. Também coloquei dica de palavra para facilitar rs

 

Algoritmo "Jogo da Forca"
// Descrição   : Jogo da Forca.
// Para mostrar a parte oculta, o programa usa um vetor parteDescoberta, [i] que recebe underline
// ("_") no início da execução.
//
// Também usa uma matriz palavraDisponivel[x,y] que contém as palavras
// aleatórias. A variável x informa o tipo da palavra, e y é a identi-
// -ficação da palavra.
//
//    Ex.: palavraDisponivel[1,1] = gato (x = 1 (de animal))
//         palavraDisponivel[2,1] = sandália (x = 2 (de roupa))
//
//    Vai sortear uma das palavras de palavraDisponivel[x,y] e armaze-
//    -nar no string palavraAleatoria.
//
//    Depois disso vai desenhar a forca, a dica do tipo da palavra
//    , o vetor parteDescoberta[i] e vai pedir uma letra. Se acertar,
//    o vetor "parteDescoberta[i]  recebe a letra na posição certa.
//    Se errar, a variável "quadro" recebe a letra errada.
//
//    Vai limpar a tela e desenhar a forca, parte descoberta, o quadro
//    e a dica. Irá pedir outra letra. O procedimento vai se repetir
//    até o boneco estiver completo (n_Tentativas_Erradas = 7) ou
//    quando "parteDescoberta" estiver completo, ou seja, quando
//    quando não houver mais underlines no vetor. (n_Tracinhos = 0)
//
// Autor(a)    : Vinícius Viana Werneck

procedimento pulaLinha(linha:inteiro)
   var
      i: inteiro

   inicio
      Para i de 1 ate linha faca
         EscrevaL()
      FimPara
fimprocedimento


procedimento sortear(var palavraAleatoria: caractere; var Dicax: inteiro)
   var
      palavraDisponivel: vetor[0..2,0..4] de caractere
      palavra:inteiro
   inicio
      palavraDisponivel[0,0] <-  "gato"
      palavraDisponivel[0,1] <-  "cachorro"
      palavraDisponivel[0,2] <-  "papagaio"
      palavraDisponivel[0,3] <-  "tartaruga"
      palavraDisponivel[0,4] <-  "rato"
      palavraDisponivel[1,0] <-  "sandalia"
      palavraDisponivel[1,1] <-  "sapato"
      palavraDisponivel[1,2] <-  "camisa"
      palavraDisponivel[1,3] <-  "bermuda"
      palavraDisponivel[1,4] <-  "calca"
      palavraDisponivel[2,0] <-  "Estados Unidos"
      palavraDisponivel[2,1]  <-  "Brasil"
      palavraDisponivel[2,2]  <-  "Angola"
      palavraDisponivel[2,3]  <-  "Mocambique"
      palavraDisponivel[2,4]  <-  "Inglaterra"

   palavra <- Randi(4)
   Dicax <- Randi(2)
   palavraAleatoria <- palavraDisponivel[Dicax,palavra]
fimprocedimento

procedimento desenhaForca()

   inicio
      EscrevaL("---+")
      EscrevaL("   |")
      EscrevaL("   |")
fimprocedimento

procedimento desenhaBoneco(n_erros: inteiro)
   var
      contador: inteiro
   inicio

      Escolha n_erros
        Caso 1
          EscrevaL("   o  ")
        Caso 2
          EscrevaL("   o  ")
          EscrevaL("  /   ")
        Caso 3
          EscrevaL("   o  ")
          EscrevaL("  /|  ")
        Caso 4
          EscrevaL("   o  ")
          EscrevaL("  /|\ ")
        Caso 5
          EscrevaL("   o  ")
          EscrevaL("  /|\ ")
          EscrevaL("   |  ")
        Caso 6
          EscrevaL("   o  ")
          EscrevaL("  /|\ ")
          EscrevaL("   |  ")
          EscrevaL("  /   ")
        Caso 7
          EscrevaL("   o  ")
          EscrevaL("  /|\ ")
          EscrevaL("   |  ")
          EscrevaL("  / \ ")
      FimEscolha

      //Deixando sempre o mesmo espaçamento entre a forca e os tracinhos:
      Escolha n_erros
         Caso 1
            pulaLinha(6)
         Caso 2,3,4
            pulaLinha(5)
         Caso 5
            pulaLinha(4)
         Caso 6 , 7
            pulaLinha(3)
         OutroCaso
            pulaLinha(7)
      FimEscolha
fimprocedimento

procedimento MostrarDica(dica:inteiro)
   inicio
      Escolha dica
        Caso 0
          EscrevaL("   Dica: Animal")
        Caso 1
          EscrevaL("   Dica: Roupa")
        Caso 2
          EscrevaL("   Dica: País")
      FimEscolha
fimprocedimento

procedimento Pedir(var Letra: caractere)
   inicio
      EscrevaL("   Chute uma letra: ")
      Leia(Letra)
fimprocedimento

funcao ehCaracterValido(Letra: caractere): logico
   var
   Resultado: logico
   TamLetra: inteiro

   inicio

   TamLetra <- Compr(Letra)
   Se (maiusc(Letra) >= "A") e (maiusc(Letra) <= "Z") e (TamLetra = 1) então
      Resultado <- verdadeiro
   Senao
      Resultado <- falso
   Fimse

   Retorne Resultado
fimfuncao


procedimento msg(mensg: caractere ; atraso: inteiro)
   inicio
      EscrevaL(mensg)
      timer atraso
      timer 0

fimprocedimento

funcao jafoiDita(Letra:caractere):logico
   var
   Resultado: logico
   contador: inteiro

   Inicio
   Resultado <- falso

   Para contador de 1 ate compr(LetrasJaDitas) faca
      Se (Letra = Copia(LetrasJaDitas,contador,1)) então
         Resultado <- verdadeiro
      Fimse
   Fimpara

   Se (Resultado = falso) então
      LetrasJaDitas <- LetrasJaDitas + Letra
   Fimse

   Retorne Resultado
fimfuncao

funcao verificao_deAcerto(Letra:caractere):logico
   var
      i: inteiro
      Resultado : logico
      CaracterePosicaoI: caractere

   inicio
   Resultado <- falso

   Para i de 1 ate compr(palavraAleatoria) faca
      CaracterePosicaoI <- Copia(palavraAleatoria,i,1)
      Se (Letra = CaracterePosicaoI) então
         ParteDescoberta[i] <- CaracterePosicaoI
         n_Tracinhos <- n_Tracinhos - 1
         Resultado <- verdadeiro
      Fimse
   FimPara

   Retorne Resultado
fimfuncao

procedimento EscreverParteQueJaSabe()
   var
      cont: inteiro

   inicio
      Escreva("   ")
      Para cont de 1 ate TamMaiorPalavra faca
         Escreva(parteDescoberta[cont], " ")
      Fimpara
      EscrevaL()
fimprocedimento

procedimento Desenhae_Escreve(quadrox,letra: caractere)
   inicio
   
      Se (quadrox <> "") então
         EscrevaL("   +-------+")
         EscrevaL("   |",quadrox:7,"|")
         EscrevaL("   +-------+")
         EscrevaL()
      Fimse
fimprocedimento

const

   TamMaiorPalavra = 14

Var

// Seção de Declarações das variáveis 
   palavraAleatoria: caractere
   quadro: caractere
   ParteDescoberta: vetor[1..TamMaiorPalavra] de caractere
   contador: inteiro
   Letra: caractere
   LetrasJaDitas: caractere
   esperarTempo: inteiro
   tipo_dePalavra: inteiro
   n_Tracinhos: inteiro
   n_Tentativas_Erradas: inteiro

Inicio
   sortear(palavraAleatoria, tipo_dePalavra)

   //Atribui valores à parteDescoberta[i] e escrever:

      Para contador de 1 ate compr(palavraAleatoria) faca
         ParteDescoberta[contador] <- "__"
      FimPara


   n_Tracinhos <- compr(palavraAleatoria)
   n_Tentativas_Erradas <- 0
   esperarTempo <- 750

   Repita
     
      EscrevaL("+----------------+")
      Escreval("| JOGO DA FORCA! |")
      EscrevaL("+----------------+")

      DesenhaForca()
      DesenhaBoneco(n_Tentativas_Erradas)

      Se (quadro <> "") então
         Desenhae_Escreve(quadro,letra)
      Fimse
   
   
      EscreverParteQueJaSabe()   //Escreve vetor ParteDescoberta[i]
      pulaLinha(2)
      MostrarDica(tipo_dePalavra)


      Pedir(Letra)
      Escolha ehCaracterValido(Letra)
        Caso verdadeiro
           Se (jafoiDita(Letra)) então
              msg("Letra já foi dita!",esperarTempo)
           Senao
              Escolha verificao_deAcerto(Letra))
                Caso verdadeiro
                  msg("Acertou!",esperarTempo)
                Caso falso
                  msg("'Errooou'",esperarTempo)
                  n_Tentativas_Erradas <- n_Tentativas_Erradas + 1
                  quadro <- quadro + Letra
              FimEscolha
           Fimse
        Caso falso
           msg("Entrada Inválida! Não pode ter espaços nem símbolos.",2000)
      FimEscolha
      
   Limpatela
   Ate (n_Tracinhos = 0) ou (n_Tentativas_Erradas = 7)
   
   DesenhaForca()
   DesenhaBoneco(n_Tentativas_Erradas)
   Desenhae_Escreve(quadro,letra)
   EscreverParteQueJaSabe()
   
fimalgoritmo

 

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...