VisualG Jogo da forca VisuALG

Charles Ramos · 5 de julho de 2018

Bom dia, estou com uma dificuldade em um algoritmo para um jogo da forca em VisuALG, o algoritmo foi solicitado para um trabalho e um dos requisitos é que ele tenha uma função, como vocês podem ver foi colocado uma função, porém a professora disse que aquela função não retorna nenhum valor, e por isso ela se encaixa como procedimento, pesquisei, tentei e não conseguir encaixar uma função nesse algoritmo, queria acrescentar também a cada final de rodada a opção de jogar ou não novamente.

desde já agradeço a ajuda.

Abaixo segue o Algorítimo - obs o VisuALG utilizado foi o 2.0

algoritmo "Jogo da forca"
var
op,frutas,ne,na:inteiro //op: opção, ne: numero erro, na:numero de acertos
l1,l2,l3,l4,l5,l6,l7,ld1,ld2,ld3,ld4,ld5,ld6,ld7,dig,verifica:caracter //linhas(l1,l2,l3...) serão usadas para o aleatorio, já as ld (ld1, ld2, ld3) serão usadas para verificar o acerto
V,D:Caracter
funcao Derrota () :caracter
inicio

                  Escreval("============================================================")
                  escreval("============================================================")
                  escreval
                  escreval(" --------- FIM  DE JOGO! ------- ")
                  ESCREVAL
                  ESCREVAL(" --------- GAME OVER =( ------- ")
                  ESCREVAL
                  Escreval("============================================================")
                  escreval("============================================================")
fimfuncao
funcao   vitoria () : caracter
inicio


                  limpatela
                  Escreval("============================================================")
                  escreval("============================================================")
                  escreval
                  escreval(" PARABÊNS voce VENCEU!  ")
                  ESCREVAL
                  Escreval("============================================================")
                  escreval("============================================================")
                  fimfuncao
inicio

aleatorio on  // ativa o modo aleatorio fonte, palavra on é opcional
aleatorio 1,7 // seleciona o ranger do aleatorio, é preciso definir para o comando ter as opção para escolha
leia (frutas) // todo leia vai ser lançado um numero aleatorio nesse caso de 1 a 3
aleatorio off  // desativa o modo aleatorio, assim ele escolher uma das opções das palavras.

limpatela  // limpa tela

repita // (repita 1) repitir o comando ate achar o comando interrompa
escreval("---SEJA BEM VINDO---")
escreval
escreval(" ---JOGO DA FORCA--- ")
escreval("Autores: Charles Ramos, Pedro Duca, Richard Vepo")
escreval
escreval
escreval("Digite 1 para jogar e 0 para sair")
leia(op)
escolha op // verificar qual opção foi selecionada
       caso 0 //sair
            escreva("você escolheu a opção 0 para sair")
            escreval
            escreval
            fimalgoritmo  // encerrar o algoritmo
       caso 1
            interrompa  // para o loop de escolher opção
       outrocaso   // caso digite algo diferente de 0 ou 1 ele vai limpar a tela
       limpatela   // limpa a tela, e vai voltar para o loop de opção.
fimescolha

fimrepita// fim repita 1

escolha frutas // palava que vai ser escolhida automaticamente pelo aleatorio no inicio do código em aleatorio on
        caso 1
             l1 <- "d"
             l2 <- "a"
             l3 <- "m"
             l4 <- "a"
             l5 <- "s"
             l6 <- "c"
             l7 <- "o"
        caso 2
             l1 <- "a"
             l2 <- "b"
             l3 <- "a"
             l4 <- "c"
             l5 <- "a"
             l6 <- "x"
             l7 <- "i"
        caso 3
             l1 <- "a"
             l2 <- "b"
             l3 <- "a"
             l4 <- "c"
             l5 <- "a"
             l6 <- "t"
             l7 <- "e"
        caso 4
             l1 <- "a"
             l2 <- "c"
             l3 <- "e"
             l4 <- "r"
             l5 <- "o"
             l6 <- "l"
             l7 <- "a"
        caso 5
             l1 <- "l"
             l2 <- "a"
             l3 <- "r"
             l4 <- "a"
             l5 <- "n"
             l6 <- "j"
             l7 <- "a"
        caso 6
             l1 <- "p"
             l2 <- "e"
             l3 <- "s"
             l4 <- "s"
             l5 <- "e"
             l6 <- "g"
             l7 <- "o"
        caso 7
             l1 <- "g"
             l2 <- "u"
             l3 <- "a"
             l4 <- "r"
             l5 <- "a"
             l6 <- "n"
             l7 <- "a"
fimescolha


ld1 <- "_"           // LINHAS USADAS PARA ESCREVER
ld2 <- "_"
ld3 <- "_"
ld4 <- "_"
ld5 <- "_"
ld6 <- "_"
ld7 <- "_"


         // inicio do jogo
          repita //repita2

                 se (ne > 7) então  // Se número de erros for maior que 6 que é o tamanho das palavras logo, jogador perde, ou seja, jogador possui 6 chances apenas.
                   D<- Derrota

                  FIMALGORITMO

                 fimse


                 se (ld1 <> "_") e (ld2 <> "_") e (ld3 <> "_") e (ld4 <> "_") e (ld5 <> "_") e (ld6 <> "_") e (ld7 <> "_") então // Se as linhas forem diferentes de _ significa que existe letra no local,
                   V<- Vitoria

                  FIMALGORITMO

                  fimse


          limpatela

          Escreval("============================================================")
          escreval("============================================================")
          escreval("")
          escreval("    /-----|")
          escreval("   /      |")

          se (ne > 0 ) então
             escreval("  /     (x.x)")
          senao
             escreval("  /")
          fimse

          se (ne > 1 ) então
               escreval(" |      __||__  ")
          senao
               escreval(" |   ")
          fimse

          se (ne > 2 ) então
             escreval(" |     /|     |\\")
          senao
             escreval(" |   ")
          fimse

          se (ne > 3) então
             escreval(" |   /  |_____| \\")
          senao
               escreval(" |   ")
          fimse

          se (ne > 4) então
             escreval(" |       ||  ||")
          senao
               escreval(" |      ")
          fimse

          se (ne > 5) então
             escreval(" |      _|| _||")
          senao
             escreval(" |     ")
          fimse

          se (ne > 6) então
             escreval(" |     |__||__|")
             escreval("=====                ULTIMA CHANCE! ")
          senao
               escreval(" |    ")
             escreval("=====               ")
          fimse

escreval("")
escreval("Acertos: ",na)
escreval("Erros: ",ne)
escreval("")
escreva("Palavra com 7 letras:     ",ld1," ",ld2," ",ld3," ",ld4," ",ld5," ",ld6," ",ld7)
Escreval("")
escreval("Dica da palavra: FRUTA ")
escreval
escreva("digite uma letra: ")

leia(dig)


verifica <- "0"

se (l1 = dig) e (ld1 = "_") então
     ld1 <- dig
     na <- na + 1
     verifica <- "1"
fimse


se (l2 = dig) e (ld2 = "_") então
         ld2 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (l3 = dig) e (ld3 = "_") então
         ld3 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (l4 = dig) e (ld4 = "_") então
         ld4 <- dig
         na <- na + 1
         verifica <-  "1"
fimse

se (l5 = dig) e (ld5 = "_") então
         ld5 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (l6 = dig) e (ld6 = "_") então
         ld6 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (l7 = dig) e (ld7 = "_") então
         ld7 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (verifica = "0") então
ne <- ne + 1
fimse

escreval("==============================================================")
escreval("==============================================================")

          fimrepita


fimalgoritmo

devair1010 · 5 de julho de 2018

@Charles Ramos para postar seu código é melhor usar o botão <> que está lá na barra de ferramentas da janela de postar , pois senão seu código fica faltando alguns caracteres , uma função no visualg tem esse formato :

funcao derrota(x : inteiro) : inteiro
var 
  a,b : inteiro
inicio
  Escreval("============================================================")
  escreval("============================================================")
  escreval
  escreval(" --------- FIM  DE JOGO! ------- ")
  ESCREVAL
  ESCREVAL(" --------- GAME OVER =( ------- ")
  ESCREVAL
  Escreval("============================================================")
  escreval("============================================================")
  retorne x+1   // aqui ele retorna um valor
fimfuncao

Charles Ramos · 5 de julho de 2018

Boa tarde - entendi como funciona, mas como eu a encacharia ela para ser chamada ao fim do jogo, de forma que se não atingir os acertos mostre a mensagem de derrota ou vitoria.

Realmente estou com bastante dificuldade de visualizar isso.

e obrigado pela dica.

abaixo segue o código com a alteração, porém com a duvida dita a cima.

algoritmo "Jogo da forca"
var
op,frutas,ne,na:inteiro //op: opção, ne: numero erro, na:numero de acertos
l1,l2,l3,l4,l5,l6,l7,ld1,ld2,ld3,ld4,ld5,ld6,ld7,dig,verifica:caracter //linhas(l1,l2,l3...) serão usadas para o aleatorio, já as ld (ld1, ld2, ld3) serão usadas para verificar o acerto
V,D:Caracter
funcao derrota(x : inteiro) : inteiro
var
  a,b : inteiro
inicio
  Escreval("============================================================")
  escreval("============================================================")
  escreval
  escreval(" --------- FIM  DE JOGO! ------- ")
  ESCREVAL
  ESCREVAL(" --------- GAME OVER =( ------- ")
  ESCREVAL
  Escreval("============================================================")
  escreval("============================================================")
  retorne x+1   // aqui ele retorna um valor
fimfuncao
funcao vitoria(x : inteiro) : inteiro
var
  a,b : inteiro
inicio
  Escreval("============================================================")
  escreval("============================================================")
  escreval
  escreval(" --------- PARABÉNS VOCÊ VENCEU! ------- ")
   ESCREVAL
  Escreval("============================================================")
  escreval("============================================================")
  retorne x+1   // aqui ele retorna um valor
fimfuncao
inicio
aleatorio on  // ativa o modo aleatorio fonte, palavra on é opcional
aleatorio 1,7 // seleciona o ranger do aleatorio, é preciso definir para o comando ter as opção para escolha
leia (frutas) // todo leia vai ser lançado um numero aleatorio nesse caso de 1 a 3
aleatorio off  // desativa o modo aleatorio, assim ele escolher uma das opções das palavras.

limpatela  // limpa tela

repita // (repita 1) repitir o comando ate achar o comando interrompa
escreval("---SEJA BEM VINDO---")
escreval
escreval(" ---JOGO DA FORCA--- ")
escreval
escreval
escreval("Digite 1 para jogar e 0 para sair")
leia(op)
escolha op // verificar qual opção foi selecionada
       caso 0 //sair
            escreva("você escolheu a opção 0 para sair")
            escreval
            escreval
            fimalgoritmo  // encerrar o algoritmo
       caso 1
            interrompa  // para o loop de escolher opção
       outrocaso   // caso digite algo diferente de 0 ou 1 ele vai limpar a tela
       limpatela   // limpa a tela, e vai voltar para o loop de opção.
fimescolha

fimrepita// fim repita 1



escolha frutas // palava que vai ser escolhida automaticamente pelo aleatorio no inicio do código em aleatorio on
        caso 1
             l1 <- "d"
             l2 <- "a"
             l3 <- "m"
             l4 <- "a"
             l5 <- "s"
             l6 <- "c"
             l7 <- "o"
        caso 2
             l1 <- "a"
             l2 <- "b"
             l3 <- "a"
             l4 <- "c"
             l5 <- "a"
             l6 <- "x"
             l7 <- "i"
        caso 3
             l1 <- "a"
             l2 <- "b"
             l3 <- "a"
             l4 <- "c"
             l5 <- "a"
             l6 <- "t"
             l7 <- "e"
        caso 4
             l1 <- "a"
             l2 <- "c"
             l3 <- "e"
             l4 <- "r"
             l5 <- "o"
             l6 <- "l"
             l7 <- "a"
        caso 5
             l1 <- "l"
             l2 <- "a"
             l3 <- "r"
             l4 <- "a"
             l5 <- "n"
             l6 <- "j"
             l7 <- "a"
        caso 6
             l1 <- "p"
             l2 <- "e"
             l3 <- "s"
             l4 <- "s"
             l5 <- "e"
             l6 <- "g"
             l7 <- "o"
        caso 7
             l1 <- "g"
             l2 <- "u"
             l3 <- "a"
             l4 <- "r"
             l5 <- "a"
             l6 <- "n"
             l7 <- "a"
fimescolha


ld1 <- "_"           // LINHAS USADAS PARA ESCREVER
ld2 <- "_"
ld3 <- "_"
ld4 <- "_"
ld5 <- "_"
ld6 <- "_"
ld7 <- "_"


         // inicio do jogo
          repita //repita2

                 se (ne > 7) então  // Se número de erros for maior que 6 que é o tamanho das palavras logo, jogador perde, ou seja, jogador possui 6 chances apenas.
                    b<- derrota ()



                 fimse


                 se (ld1 <> "_") e (ld2 <> "_") e (ld3 <> "_") e (ld4 <> "_") e (ld5 <> "_") e (ld6 <> "_") e (ld7 <> "_") então // Se as linhas forem diferentes de _ significa que existe letra no local,
                 a<- vitoria ()



                  fimse


          limpatela

          Escreval("============================================================")
          escreval("============================================================")
          escreval("")
          escreval("    /-----|")
          escreval("   /      |")

          se (ne > 0 ) então
             escreval("  /     (x.x)")
          senao
             escreval("  /")
          fimse

          se (ne > 1 ) então
               escreval(" |      __||__  ")
          senao
               escreval(" |   ")
          fimse

          se (ne > 2 ) então
             escreval(" |     /|     |\\")
          senao
             escreval(" |   ")
          fimse

          se (ne > 3) então
             escreval(" |   /  |_____| \\")
          senao
               escreval(" |   ")
          fimse

          se (ne > 4) então
             escreval(" |       ||  ||")
          senao
               escreval(" |      ")
          fimse

          se (ne > 5) então
             escreval(" |      _|| _||")
          senao
             escreval(" |     ")
          fimse

          se (ne > 6) então
             escreval(" |     |__||__|")
             escreval("=====                ULTIMA CHANCE! ")
          senao
               escreval(" |    ")
             escreval("=====               ")
          fimse

escreval("")
escreval("Acertos: ",na)
escreval("Erros: ",ne)
escreval("")
escreva("Palavra com 7 letras:     ",ld1," ",ld2," ",ld3," ",ld4," ",ld5," ",ld6," ",ld7)
Escreval("")
escreval("Dica da palavra: FRUTA ")
escreval
escreva("digite uma letra: ")

leia(dig)


verifica <- "0"

se (l1 = dig) e (ld1 = "_") então
     ld1 <- dig
     na <- na + 1
     verifica <- "1"
fimse


se (l2 = dig) e (ld2 = "_") então
         ld2 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (l3 = dig) e (ld3 = "_") então
         ld3 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (l4 = dig) e (ld4 = "_") então
         ld4 <- dig
         na <- na + 1
         verifica <-  "1"
fimse

se (l5 = dig) e (ld5 = "_") então
         ld5 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (l6 = dig) e (ld6 = "_") então
         ld6 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (l7 = dig) e (ld7 = "_") então
         ld7 <- dig
         na <- na + 1
         verifica <- "1"
fimse

se (verifica = "0") então
ne <- ne + 1
fimse

escreval("==============================================================")
escreval("==============================================================")

          fimrepita




fimalgoritmo

devair1010 · 6 de julho de 2018

@Charles Ramos seu código está bom , só vi um erro na hora de imprimir o desenho do boneco , ele estava com três braços , então seu código com algumas modificações poderia ser assim :

algoritmo "Jogo da forca"
var
  op,frutas,ne,na,l,a,b,vit,der : inteiro //op: opção, ne: numero erro, na:numero de acertos
  l1,l2,l3,l4,l5,l6,l7,ld1,ld2  : caracter
  ld3,ld4,ld5,ld6,ld7,dig       : caracter //linhas(l1,l2,l3...) serão usadas para o aleatorio, já as ld (ld1, ld2, ld3) serão usadas para verificar o acerto
  V,D,verifica                  : Caracter
funcao derrota(x : inteiro) : inteiro
var
  a,b : inteiro
inicio
  Escreval("============================================================")
  escreval("============================================================")
  escreval
  escreval(" --------- FIM  DE JOGO! ------- ")
  ESCREVAL
  ESCREVAL(" --------- GAME OVER =( ------- ")
  ESCREVAL
  Escreval("============================================================")
  escreval("============================================================")
  escreval("          Tercle Enter")
  leia(l)
  retorne x+1   // aqui ele retorna um valor
fimfuncao
funcao vitoria(x : inteiro) : inteiro
var
  a,b : inteiro
inicio
  Escreval("============================================================")
  escreval("============================================================")
  escreval
  escreval(" --------- PARABÉNS VOCÊ VENCEU! ------- ")
   ESCREVAL
  Escreval("============================================================")
  escreval("============================================================")
  escreval("              Tecle Enter")
  leia(l)
  retorne x+1   // aqui ele retorna um valor
fimfuncao
//----------------INICIO---------------------------------------------------
inicio
  repita
    limpatela
    escreval("---SEJA BEM VINDO---")
    escreval
    escreval("---JOGO DA FORCA---")
    para l de 1 ate 10 faca
      escreval
    fimpara
    escreva("   Tecle Enter  ")
    leia(l)
    op := 3
    aleatorio on  // ativa o modo aleatorio fonte, palavra on é opcional
    aleatorio 1,7 // seleciona o ranger do aleatorio, é preciso definir para o comando ter as opção para escolha
    leia (frutas) // todo leia vai ser lançado um numero aleatorio nesse caso de 1 a 3
    aleatorio off  // desativa o modo aleatorio, assim ele escolher uma das opções das palavras.
    se op <> 0 ENTÃO
      escolha frutas // palava que vai ser escolhida automaticamente pelo aleatorio no inicio do código em aleatorio on
      caso 1
        l1 <- "d"
        l2 <- "a"
        l3 <- "m"
        l4 <- "a"
        l5 <- "s"
        l6 <- "c"
        l7 <- "o"
      caso 2
        l1 <- "a"
        l2 <- "b"
        l3 <- "a"
        l4 <- "c"
        l5 <- "a"
        l6 <- "x"
        l7 <- "i"
      caso 3
        l1 <- "a"
        l2 <- "b"
        l3 <- "a"
        l4 <- "c"
        l5 <- "a"
        l6 <- "t"
        l7 <- "e"
      caso 4
        l1 <- "a"
        l2 <- "c"
        l3 <- "e"
        l4 <- "r"
        l5 <- "o"
        l6 <- "l"
        l7 <- "a"
      caso 5
        l1 <- "l"
        l2 <- "a"
        l3 <- "r"
        l4 <- "a"
        l5 <- "n"
        l6 <- "j"
        l7 <- "a"
      caso 6
        l1 <- "p"
        l2 <- "e"
        l3 <- "s"
        l4 <- "s"
        l5 <- "e"
        l6 <- "g"
        l7 <- "o"
      caso 7
        l1 <- "g"
        l2 <- "u"
        l3 <- "a"
        l4 <- "r"
        l5 <- "a"
        l6 <- "n"
        l7 <- "a"
      fimescolha
      ld1 <- "_"           // LINHAS USADAS PARA ESCREVER
      ld2 <- "_"
      ld3 <- "_"
      ld4 <- "_"
      ld5 <- "_"
      ld6 <- "_"
      ld7 <- "_"
      // inicio do jogo
      repita //repita2
        se (ne > 7) ENTÃO  // Se número de erros for maior que 6 que 
                           // é o tamanho das palavras logo, jogador perde,
                           // ou seja, jogador possui 6 chances apenas.
          der <- derrota (der)
          op := 101
        fimse
        se (ld1 <> "_") e (ld2 <> "_") e (ld3 <> "_") e (ld4 <> "_") e (ld5 <> "_") e (ld6 <> "_") e (ld7 <> "_") ENTÃO // Se as linhas forem diferentes de _ significa que existe letra no local,
          vit <- vitoria (vit)
          op := 101
        fimse
        se op <> 101 ENTÃO
          limpatela
          Escreval("============================================================")
          escreval("============================================================")
          escreval("")
          escreval("    /-----|")
          escreval("   /      |")
          se (ne > 0 ) ENTÃO
            escreval("  /     (x.x)")
          senao
            escreval("  /")
          fimse
          se (ne > 1 ) ENTÃO
            escreval(" |      __||__  ")
          senao
            escreval(" |   ")
          fimse
          se (ne > 2 ) ENTÃO
            escreval(" |     /|     |\")
          senao
            escreval(" |   ")
          fimse
          se (ne > 3) ENTÃO
            escreval(" |    / |_____| \")
          senao
            escreval(" |   ")
          fimse
          se (ne > 4) ENTÃO
            escreval(" |       ||  ||")
          senao
            escreval(" |      ")
          fimse
          se (ne > 5) ENTÃO
            escreval(" |      _|| _||")
          senao
            escreval(" |     ")
          fimse
          se (ne > 6) ENTÃO
            escreval(" |     |__||__|")
            escreval("=====                ULTIMA CHANCE! ")
          senao
            escreval(" |    ")
            escreval("=====               ")
          fimse
          escreval("")
          escreval("Acertos ------------: ",na)
          escreval("Erros --------------: ",ne)
          escreval("")
          escreva("Palavra com 7 letras:     ",ld1," ",ld2," ",ld3," ",ld4," ",ld5," ",ld6," ",ld7)
          escreval("")
          escreval("Dica da palavra ----: FRUTA ")
          escreval
          escreva("digite uma letra ---: ")
          leia(dig)
          verifica <- "0"
          se (l1 = dig) e (ld1 = "_") ENTÃO
            ld1 <- dig
            na <- na + 1
            verifica <- "1"
          fimse
          se (l2 = dig) e (ld2 = "_") ENTÃO
            ld2 <- dig
            na <- na + 1
            verifica <- "1"
          fimse
          se (l3 = dig) e (ld3 = "_") ENTÃO
            ld3 <- dig
            na <- na + 1
            verifica <- "1"
          fimse
          se (l4 = dig) e (ld4 = "_") ENTÃO
            ld4 <- dig
            na <- na + 1
            verifica <-  "1"
          fimse
          se (l5 = dig) e (ld5 = "_") ENTÃO
            ld5 <- dig
            na <- na + 1
            verifica <- "1"
          fimse
          se (l6 = dig) e (ld6 = "_") ENTÃO
            ld6 <- dig
            na <- na + 1
            verifica <- "1"
          fimse
          se (l7 = dig) e (ld7 = "_") ENTÃO
            ld7 <- dig
            na <- na + 1
            verifica <- "1"
          fimse
          se (verifica = "0") ENTÃO
            ne <- ne + 1
          fimse
          escreval("==============================================================")
          escreval("==============================================================")
        fimse
      ate op = 101
    fimse
    escreval("Quer Jogar Novamente ")
    escreval("0 - Não")
    escreval("1 - Sim ")
    leia(op)
  ate op = 0
  escreval("Total De Vitórias -------: ",vit)
  escreval("Total De Derrotas -------: ",der)
  escreval
  escreval("      Tecle Enter")
  leia(l)
fimalgoritmo

CarlosCumbane · 9 de julho de 2021

@devair1010
não percebi a o porque de op receber o valor 101 (OP <- 101)
podia explicar melhor?

devair1010 · 9 de julho de 2021

@CarlosCumbane Olá , e nessa foto , ela está deitada , por que fotografou assim mesmo ou foi na hora de colocar a imagem , que girou ela para o lado esquerdo ? , e sobre essa Questão de a

 variáveL  " op  "

receber um valor qq ou até mesmo 101, se deve ao fato de antigamente Quando eu estava iniciando a estudar Lógica de programação lá no Senac , e ainda tinha pouco conhecimento dessas coisa de programação , e não conhecia todos os comandos do visualG 3.0 , coloquei assim para após certa qtd de jogadas se chegasse a uma decisão de vitória ou derrota do jogador , e assim repetir o jogo , pois foi para isso que o @Charles Ramos pediu uma ajudinha , mas atualmente fiz algum progresso e já sei que poderia ter usado o comando " interrompa " , que faria a mesma coisa , e então o que fiz com aquele

op := 101

foi substituir esse comando " interrompa " , pois ali como você pode ver ao carregar a variável op com esse valor , o programa pula para o final da partida , mas não termina o jogo , e pergunta se quer jogar novamente , pois op tem nesse momento o valor 101 , e para terminar e sair do jogo será apenas Quando op tiver o valor zero , . , . ,, ,, , , .

Simon Viegas · 9 de julho de 2021

A postagem é de 2008, mas caso alguém se esbarre:

Sobre:

Em 05/07/2018 às 10:46, Charles Ramos disse:

[...] como vocês podem ver foi colocado uma função, porém a professora disse que aquela função não retorna nenhum valor, e por isso ela se encaixa como procedimento, pesquisei, tentei e não conseguir encaixar uma função nesse algoritmo, queria acrescentar também a cada final de rodada a opção de jogar ou não novamente.

Funções e Procedimentos são praticamente a mesma coisa!!! Um procedimento nada mais é que uma função que não tem retorno nela mesma!!! Só muda isso. No resto é exatamente igual. Isso de chamar de "função" (function) ou "procedimento" (procedure) seria apenas* no Pascal/Delphi... e o VisualG herdou essa característica (já que é baseado neles... só que traduzido para Português). É mais normal chamar tudo de função mesmo...

O VisualG utiliza mais ou menos essa estrutura:

Quando precisasse retornar algo, definiria um tipo ali no final da assinatura:

funcao NomeDaMinhaFuncao(parametro :tipo): tipo
inicio

  
  retorne xxx //xxx seria algum valor do tipo que está definido ali na assinatura
  
fimFuncao

Quando não precisasse retornar algo, muda para procedimento:

procedimento NomeDoMeuProcedimento(parametro :tipo)
inicio

fimProcedimento

Mas tipo... qualquer* outra linguagem meio que continua utilizando funcao (ou algo do tipo), e apenas define o tipo de retorno como vazio (void). Se o VisualG fosse seguir o padrão, seria algo assim:

funcao NomeDaMinhaFuncao(parametro :tipo): vazio
inicio

fimFuncao

Percebe? Procedimento é simplesmente uma função que não tem retorno nela mesmo! É bem mais simples esta estrutura assim..

Sobre o jogo da forca... dá para armazenar as palavras em vetores... segue um esboço para base:

algoritmo "Teste palavras armazenadas em vetor"

funcao LetraPosicao(c: caractere; p: inteiro): caractere
inicio
   retorne Copia(c, p, 1)
fimFuncao

var
   vetPalavras: vetor [1..10] de caractere
   posPalavra: inteiro
   posLetra: inteiro
inicio
   vetPalavras[1] <- "damasco"
   vetPalavras[2] <- "abacaxi"
   vetPalavras[3] <- "abacate"
   
   posPalavra <- Randi(3)+1
   posLetra <- Randi(8)+1
   
   escrevaL("Posição da palavra: ", posPalavra:1)
   escreval("Palavra na posição: ", vetPalavras[posPalavra])
   escrevaL("Posicao da letra  : ", posLetra:1)
   escrevaL("Letra na posição  : ", LetraPosicao(vetPalavras[posPalavra], posLetra):1)
fimAlgoritmo

...aos poucos vou tentar reformular esse código.

Adendo: daí, daria por exemplo para deixar as palavras num arquivo de texto e o programa carregaria as palavras.

Adendo 2: outra opção é utilizando "listas". Uma funcionalidade que existe no VisualG. Vide:

Essas "listas" ficam no arquivo "listas.txt" lá na pasta doVisualG... Aí utilizam o comando ALEATORIO para utilizar... nesse tópico falo um pouco sobre:

Por ai vai..