VisualG Joguinho no VisualG 3.0

zLuks · 26 de setembro de 2019

Galera, tô começando a me interessar em programação e falaram pra eu começar com o visualg pra eu pegar a manha das lógicas, eu dei umas lidas aqui e não consigo pensar em nada pra montar um jogo de lógica pra rodar no visualg 3 que é o que estou a usar.

Um jogo que minha irmã tem e eu acho que seria legal entender como funciona é o Genius, aquele de memorizar cores e depois repetir, se acertar passa o nível e vai ficando mais difícil.

Alguém sabe construir um algoritmo em visualg que simule esse joguinho?

Se puder não detalha pra eu analisar o que cada coisa vai fazer, se eu tiver duvida sobre o código chamo no privado pois eu sou iniciantão mesmo, eu vejo alguns videos mas n entendo muito ok, agradeço se alguém puder ajudar, vou por o jogo pra rodar no pc pra minha irmã ver e jogar se funcionar aqui, abraços!

Simon Viegas · 27 de setembro de 2019

@zLuks, sugiro resolver questões simples. Procure listas no Google e vá resolvendo. Ex.: http://docente.ifrn.edu.br/abrahaolopes/2014.1-subsequente/1.2411.1v-algoritmos/lista-de-exercicios-1-entrada-saida-calculos/view

Quanto tiver uma base te ajudamos a criar o jogo Genius. (por sinal, esse jogo leva meu nome: https://www.google.com/search?q=jogo+simon)

zLuks · 27 de setembro de 2019

@Simon Viegas já resolvi questões do tipo, eu vi o curso do Gustavo Guanabara.

Só não consigo estruturar algo em visualg pra mostrar um número ou cor, apagar e fazer o jogador informar a cor ou número que apareceu, e se ele acertar aumentar o nível..

Simon Viegas · 27 de setembro de 2019

7 horas atrás, zLuks disse:

@Simon Viegas já resolvi questões do tipo, eu vi o curso do Gustavo Guanabara.

Só não consigo estruturar algo em visualg pra mostrar um número ou cor, apagar e fazer o jogador informar a cor ou número que apareceu, e se ele acertar aumentar o nível..

De cara cores não é o forte do Visualg... o posicionamento dos caracteres na tela é meio rudimentar também... mas dá para fazer... uma forma que eu pensei aqui seria ir reescrevendo o jogo a cada ciclo. Segue um esboço:

algoritmo "Genius v.0001"
var
   casa :inteiro
   cont :inteiro

inicio
   repita
      casa <- randi(4) + 1
      cont <- cont + 1
      timer 700
      timer 0
      limpaTela
      escreval(" - -")
      escreval(" - -")
      timer 300
      timer 0
      limpaTela
      escolha casa
      caso 1
         escreval(" a -")
         escreval(" - -")
      caso 2
         escreval(" - b")
         escreval(" - -")
      caso 3
         escreval(" - -")
         escreval(" c -")
      caso 4
         escreval(" - -")
         escreval(" - d")
      fimEscolha
   ate cont = 20

fimAlgoritmo

Aí teria que ir inserindo a lógica do jogo. Acho que poderia ir usando um vetor para armazenar os números sorteados.

zLuks · 30 de setembro de 2019

Algoritmo "GENIUS.ALG"

const
nivel1=2
nivel2=4
nivel3=6
nivel4=8
MAX_ELEMENTOS=11
Var
comandoDigitado: inteiro
tamanhoSequencia: inteiro
s: inteiro
sequencia: vetor[0..nivel1] de inteiro
sequencia2: vetor[0..nivel2] de inteiro
sequencia3: vetor[0..nivel3] de inteiro
sequencia4: vetor[0..nivel4] de inteiro
sequencia5: vetor[0..MAX_ELEMENTOS] de inteiro
sequenciaDeCores: vetor[0..4] de caractere
sair:logico
comando:inteiro



procedimento niv1()
var
resp1,resp2:caractere
inicio
s<-0
    sequenciaDeCores[0] <- "azul"
   sequenciaDeCores[1] <- "vermelho"
   sequenciaDeCores[2] <- "amarelo"
   sequenciaDeCores[3] <- "verde"
   tamanhoSequencia <- 1
  timer 100
  escreval("aguarde....")
  limpatela
   enquanto (tamanhoSequencia < nivel1) faca
      sequencia[tamanhoSequencia + 1] <- randi(1)+1
      tamanhoSequencia <- tamanhoSequencia + 1
      para s de 1 ate tamanhoSequencia faca
         timer 300
         mudacor[sequenciaDeCores[sequencia[s]],"fundos"]
         timer 0
    mudacor("preto","fundos")
      fimpara
    fimenquanto
    escreval("diga a sequencia:")
    leia(resp1)
    leia(resp2)
     escolha resp1,resp2
      caso "azul","vermelho"
       escreval ("voce acertou")
       ni2()
      outrocaso
       escreval("GAME OVER")
     fimescolha
    fimprocedimento


procedimento ni2()
var
resp2,resp3,resp4, resp5:caractere
inicio
s<-0
    sequenciaDeCores[0] <- "azul"
   sequenciaDeCores[1] <- "vermelho"
   sequenciaDeCores[2] <- "amarelo"
   sequenciaDeCores[3] <- "verde"
   tamanhoSequencia <- 1
  timer 100
  escreval("aguarde....")
  limpatela
   enquanto (tamanhoSequencia < nivel2) faca
      sequencia2[tamanhoSequencia + 1] <- randi(2)+1
      tamanhoSequencia <- tamanhoSequencia + 1
      para s de 1 ate tamanhoSequencia faca
         timer 1000
         mudacor(sequenciaDeCores[sequencia2[s]],"fundos")
         timer 0
    mudacor("preto","fundos")
      fimpara
    fimenquanto
    escreval("diga a sequencia:")
    leia(resp2,resp3,resp4,resp5)
     escolha resp2,resp3,resp4,resp5
      caso "azul","vermelho","vermelho","vermelho","amarelo","vermelho","amarelo"
       escreval ("voce acertou")
       ni3()
      outrocaso
       escreval("GAME OVER")
     fimescolha
    fimprocedimento



procedimento ni3
var
resp6,resp7,resp8,resp9,resp10,resp11:caractere
inicio
 escreval ("NIVEL 3")
   timer 900
  escreval("aguarde...")
  limpatela
   enquanto (tamanhoSequencia < nivel3) faca
      sequencia[tamanhoSequencia + 1] <- randi(3)+1
      tamanhoSequencia <- tamanhoSequencia + 1
      para s de 1 ate tamanhoSequencia faca
         timer 2500
         mudacor(sequenciaDeCores[sequencia3[s]],"fundos")
         timer 0
    mudacor("preto","fundos")
      fimpara
    fimenquanto
    escreval("diga a sequencia:")
    leia (resp6,resp7,resp8,resp9,resp10,resp11,resp12)
     escolha resp6,resp7,resp8,resp9,resp10,resp11
      caso
       escreval ("voce acertou")
       ni4()
      outrocaso
       escreval("GAME OVER")
      fimescolha
fimprocedimento


procedimento ni4
var
resp6,resp7,resp8,resp9,resp10,resp11,resp12,resp13:caractere
inicio
escreval ("NIVEL 4 ")
   timer 900
  escreval("aguarde...")
  limpatela
   enquanto (tamanhoSequencia < niv4) faca
      sequencia[tamanhoSequencia + 1] <- randi(4)+1
      tamanhoSequencia <- tamanhoSequencia + 1
      para s de 1 ate tamanhoSequencia faca
         timer 500
         mudacor(sequenciaDeCores[sequencia[s]],"fundos")
         timer 0
    mudacor("preto","fundos")
      fimpara
    fimenquanto
       escreval("diga a sequencia:")
    leia (resp6,resp7,resp8,resp9,resp10,resp11,resp12)
     escolha resp6,resp7,resp8,resp9,resp10,resp11,resp12,resp13
      caso
       escreval ("voce acertou")
       ni5()
      outrocaso
       escreval("GAME OVER")
      fimescolha
fimprocedimento

    
    
procedimento ni5
var
resp6,resp7,resp8,resp9,resp10,resp11,resp12,resp13,resp14:caractere
inicio
escreval ("NIVEL 5 ")
   timer 900
  escreval("aguarde...")
  limpatela
   enquanto (tamanhoSequencia < MAX_ELEMENTOS ) faca
      sequencia[tamanhoSequencia + 1] <- randi(4)+1
      tamanhoSequencia <- tamanhoSequencia + 1
      para s de 1 ate tamanhoSequencia faca
         timer 500
         mudacor(sequenciaDeCores[sequencia[s]],"fundos")
         timer 0
    mudacor("preto","fundos")
      fimpara
    fimenquanto
    escreval("diga a sequencia:")
    leia (resp6,resp7,resp8,resp9,resp10,resp11,resp12)
     escolha resp6,resp7,resp8,resp9,resp10,resp11,resp12,resp13,resp14
      caso
       escreval ("voce acertou,e finalizou o jogo PARABENS!!!!!")
      outrocaso
       escreval("GAME OVER")
      fimescolha
fimprocedimento
Inicio
escreval("-----------------------------------")
escreval("      Bem vindo ao genius!    "   )
escreval("-----------------------------------")
  escreval("digite 1 para iniciar: ")
  escreval("digite 2 para sair:")
  leia(comando)
   se (comando=1) entao
    niv1()
     senao
     se(comando=2) entao
     escreval("ok até a proxima")
   fimse
  fimse
Fimalgoritmo

Um amigo me ajudou, mas ainda não consigo corrigir, alguém?

Simon Viegas · 30 de setembro de 2019

1 hora atrás, zLuks disse:

Um amigo me ajudou, mas ainda não consigo corrigir, alguém?

Corrigir o quê? por favor, especifique o que está errado e/ou o que quer mudar.

adicionado 21 minutos depois

Adendo:

O jogo não é separado por níveis, e não deve-se ler todas as reposta para posteriormente analisar, ou seja: a cada resposta, já deve verificar se está na sequência correta ou não. Errou um! o jogo acaba. Simplesmente trata-se de uma sequência crescente... a cada "ciclo" uma nova cor (e um som) aleatória é lançada na sequência, e o jogador deve ir repetindo exatamente na mesma ordem.

Ex.

- Sequência gerada pelo computador

- Sequência informada pelo jogador

Azul
Azul

Azul Vermelho
Azul Vermelho

Azul Vermelho Vermelho
Azul Vermelho Vermelho

Azul Vermelho Vermelho Verde
Azul Vermelho Vermelho Verde

Azul Vermelho Vermelho Verde Vermelho
Azul Vermelho Vermelho Verde Vermelho

Azul Vermelho Vermelho Verde Vermelho Amarelo
Azul Vermelho Vermelho Azul

Fim do jogo!

Enquanto o usuário acertar, a sequência vai crescendo "indefinidamente". (óbvio que existe um limite lógico e físico no computador, mas poderia ter um tamanho suficiente grande).

A base do seu código está boa... mas sugeriria utilizar apenas um vetor de cores que iria crescendo a cada acerto.

adicionado 23 minutos depois

Adendo 2:
"Um nível" poderia ser associado à "quantidade de cores"... no exemplo acima poderia dizer que o jogador chegou ao nível 6 (mas acho isso desnecessário. Não faz parte do jogo original).

zLuks · 1 de outubro de 2019

@Simon Viegas

Algoritmo "simon"
Var

comando,pontos: inteiro
numaleatorio: vetor [1..10] de inteiro
resultado: vetor [1..10] de inteiro


procedimento acertou ()
var
inicio
pontos <- pontos + 1
escreval ("O total de pontos até agora é ", pontos)
timer 500
limpatela
fimprocedimento



procedimento errou ()

var
inicio
escreval ("Você errou e foi derrotado pelo GENIUS!")
escreval ("Você obteve um total de ",pontos," ponto(s)")
fimprocedimento



procedimento continue ()
var
inicio
pontos <- pontos + 1
fimprocedimento


Inicio

pontos <- 0
escreval ("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-")
escreval ("Seja bem-vindo ao Genius            " )
escreval ("Projetado por: zLks")
escreval ("-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-")
escreval ()
escreval ("Deseja iniciar o jogo?")
escreval ("Digite 1 para sim ou 2 para não")
         leia (comando)
         se (comando=1) entao
         escreval ("Grave a sequência")
         senao
         escreval ("Bye")
         fimse
         timer 1000
         limpatela
         escreval ("           Nível 1          ")
         escreval ("============================")
         escreval ("Mostrando números aleatórios")
         timer 1000
         limpatela
         aleatorio 1,4
         leia (numaleatorio[1])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[2])
         aleatorio off
         timer 500
         limpatela
         escreval ("           Nível 1           ")
         escreval ("=============================")
         escreval ("Digite a sequência de números")
         leia (resultado[1])
         leia (resultado[2])
         se (resultado[1]<>numaleatorio[1]) entao
         errou ()
         senao
         continue ()
         se (resultado[2]<>numaleatorio[2]) entao
         errou ()
         senao
         acertou ()
         fimse
         fimse
         limpatela
         escreval ("           Nível 2          ")
         escreval ("============================")
         escreval ("Mostrando números aleatórios")
         timer 1000
         limpatela
         aleatorio 1,4
         leia (numaleatorio[1])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[2])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[3])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[4])
         aleatorio off
         timer 500
         limpatela
         escreval ("           Nível 2           ")
         escreval ("=============================")
         escreval ("Digite a sequência de números")
         leia (resultado[1])
         leia (resultado[2])
         leia (resultado[3])
         leia (resultado[4])
         se (resultado[1]<>numaleatorio[1]) entao
         errou ()
         senao
         continue ()
         se (resultado[2]<>numaleatorio[2]) entao
         errou ()
         senao
         continue ()
         se (resultado[3]<>numaleatorio[3]) entao
         errou ()
         senao
         continue ()
         se (resultado[4]<>numaleatorio[4]) entao
         errou ()
         senao
         acertou ()
         fimse
         fimse
         fimse
         fimse
         limpatela
         escreval ("           Nível 3          ")
         escreval ("============================")
         escreval ("Mostrando números aleatórios")
         timer 1000
         limpatela
         aleatorio 1,4
         leia (numaleatorio[1])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[2])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[3])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[4])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[5])
         aleatorio off
         timer 500
         limpatela
         aleatorio 1,4
         leia (numaleatorio[6])
         aleatorio off
         timer 500
         limpatela
         escreval ("           Nível 3           ")
         escreval ("=============================")
         escreval ("Digite a sequência de números")
         leia (resultado[1])
         leia (resultado[2])
         leia (resultado[3])
         leia (resultado[4])
         leia (resultado[5])
         leia (resultado[6])
         se (resultado[1]<>numaleatorio[1]) entao
         errou ()
         senao
         continue ()
         se (resultado[2]<>numaleatorio[2]) entao
         errou ()
         senao
         continue ()
         se (resultado[3]<>numaleatorio[3]) entao
         errou ()
         senao
         continue ()
         se (resultado[4]<>numaleatorio[4]) entao
         errou ()
         senao
         continue ()
         se (resultado[5]<>numaleatorio[5]) entao
         errou ()
         senao
         continue ()
         se (resultado[6]<>numaleatorio[6]) entao
         errou ()
         senao
         acertou ()
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         escreval ("           Nível 4          ")
         escreval ("============================")
         escreval ("Mostrando números aleatórios")
         timer 1000
         limpatela
         aleatorio 1,4
         leia (numaleatorio[1])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[2])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[3])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[4])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[5])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[6])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[7])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[8])
         aleatorio off
         limpatela
         escreval ("           Nível 4           ")
         escreval ("=============================")
         escreval ("Digite a sequência de números")
         leia (resultado[1])
         leia (resultado[2])
         leia (resultado[3])
         leia (resultado[4])
         leia (resultado[5])
         leia (resultado[6])
         leia (resultado[7])
         leia (resultado[8])
         se (resultado[1]<>numaleatorio[1]) entao
          errou ()
         senao
         continue ()
         se (resultado[2]<>numaleatorio[2]) entao
         errou ()
         senao
         continue ()
         se (resultado[3]<>numaleatorio[3]) entao
         errou ()
         senao
         continue ()
         se (resultado[4]<>numaleatorio[4]) entao
         errou ()
         senao
         continue ()
         se (resultado[5]<>numaleatorio[5]) entao
         errou ()
         senao
         continue ()
         se (resultado[6]<>numaleatorio[6]) entao
         errou ()
         senao
         continue ()
         se (resultado[7]<>numaleatorio[7]) entao
         errou ()
         senao
         continue ()
         se (resultado[6]<>numaleatorio[8]) entao
         errou ()
         senao
         acertou ()
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         escreval ("           Nível 5          ")
         escreval ("============================")
         escreval ("Mostrando números aleatórios")
         timer 1000
         limpatela
         aleatorio 1,4
         leia (numaleatorio[1])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[2])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[3])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[4])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[5])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[6])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[7])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[8])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[9])
         aleatorio off
         limpatela
         aleatorio 1,4
         leia (numaleatorio[10])
         aleatorio off
         limpatela
         escreval ("           Nível 5           ")
         escreval ("=============================")
         escreval ("Digite a sequência de números")
         leia (resultado[1])
         leia (resultado[2])
         leia (resultado[3])
         leia (resultado[4])
         leia (resultado[5])
         leia (resultado[6])
         leia (resultado[7])
         leia (resultado[8])
         leia (resultado[9])
         leia (resultado[10])
           se (resultado[1]<>numaleatorio[1]) entao
          errou ()
         senao
         continue ()
         se (resultado[2]<>numaleatorio[2]) entao
         errou ()
         senao
         continue ()
         se (resultado[3]<>numaleatorio[3]) entao
         errou ()
         senao
         continue ()
         se (resultado[4]<>numaleatorio[4]) entao
         errou ()
         senao
         continue ()
         se (resultado[5]<>numaleatorio[5]) entao
         errou ()
         senao
         continue ()
         se (resultado[6]<>numaleatorio[6]) entao
         errou ()
         senao
         continue ()
         se (resultado[7]<>numaleatorio[7]) entao
         errou ()
         senao
         continue ()
         se (resultado[8]<>numaleatorio[8]) entao
         errou ()
         senao
         continue ()
         se (resultado[9]<>numaleatorio[9]) entao
         errou ()
         senao
         continue ()
         se (resultado[10]<>numaleatorio[10]) entao
         errou ()
         senao
         acertou ()
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         fimse
         se (pontos = 30) entao
         escreval ("Você ganhou o Genius, obtendo o total de ",pontos)
         senao
         escreval ("voce perdeu e obteve os seguintes pontos ",pontos)
         fimse
Fimalgoritmo

Decidi fazer um simples sem cor, mas quando a pessoa erra nao encerra o algoritmo, o que preciso fazer?

Queria que quando errar ja aparecer a mensagem que errou e quantos pontos fez, dai dar por fim a execução.

Simon Viegas · 1 de outubro de 2019

Inicialmente acho que precisar ajustar a lógica do jogo. O jogo Genius não funciona assim.

Vide:

12 horas atrás, Simon Viegas disse:

Adendo:

O jogo não é separado por níveis, e não deve-se ler todas as reposta para posteriormente analisar, ou seja: a cada resposta, já deve verificar se está na sequência correta ou não. Errou um! o jogo acaba. Simplesmente trata-se de uma sequência crescente... a cada "ciclo" uma nova cor [ou no caso um novo número] (e um som) aleatória é lançada na sequência, e o jogador deve ir repetindo exatamente na mesma ordem.

O jogo ficaria algo assim:

1
1

1 2
1 2

1 2 1
1 2 1

1 2 1 3
1 2 1 3

1 2 1 3 3
1 2 1 3 3

1 2 1 3 3 2
1 2 1 3 3 2

1 2 1 3 3 2 1
1 2 1 3 3 2 1

1 2 1 3 3 2 1 3
1 2 1 3 3 1

Errou! Fim do jogo

Sugiro assistir alguns vídeos demonstrando o jogo, ex.:

ADENDO:

Não adianta "enfeitar" o jogo, por enquanto, se ele não está seguindo a lógica original. Se está proposto a fazer o Game Simon, tem que tentar se aproximar da lógica dele, entende? Fazendo uma analogia: imagine você ir num restaurante e pedir um hambúrguer de frango, ai o garçom de traz uma completa e deliciosa feijoada! ou seja: pode está bom, ser supostamente mais gostosa etc etc, mas não foi aquilo que você pediu. "Se quero um hambúrguer, me traga um hambúrguer".

O enunciado deve ser seguido... ou deve-se mudar o enunciado. "Senhor, não temos carne de hambúrguer, mas apesar de ser diferente, posso de oferecer uma feijoada pelo mesmo preço. O Senhor aceita?"

No aguardo.