Introdução à computação: Da lógica aos jogos com Ruby

Introdução

Programação

O profissional que cria o código por trás de um jogo, um site na internet ou um aplicativo mobile é o programador. Ele é o dono do seu, do meu, de todos os computadores. Não queremos ser apenas usuários, que ligam o computador e são obrigados a seguir as regras estabelecidas por outros. A vontade de criar algo novo, de alterar algo existente, é o que nos torna programadores.

Toda introdução a programação envolve entender por cima como funcionam o computador e um programa. As implicações nos limites da computação são sentidos no dia a dia do programador.

A ideia por trás deste material é de cobrir o conteúdo de uma matéria de Introdução à Programação do primeiro ou segundo semestre de uma faculdade de Análise de Sistemas, Ciência da Computação, Engenharia etc. Portanto não pretendemos abordar tópicos muito específicos de uma linguagem ou outra, mas sim tratar de questões sobre como um programa é criado, qual a sua base, como detectar problemas e transformar nossas ideias e soluções em código.

Vamos nos focar em conceitos extremamente importantes como construção da lógica, pilha de execução, simulação de código e a recursão.

Por isso não seguiremos ao pé da letra todos os idiomatismos da linguagem Ruby, mas mostraremos diversas variações de como se programar uma mesma estrutura lógica, tentando indicar vantagens e desvantagens de cada abordagem.

Durante essa jornada criaremos três jogos distintos, um jogo de adivinhação numérica, um jogo da forca e um baseado no clássico Pacman ─ nosso Foge-Foge.

O jogo de adivinhação permite ao jogador escolher o nível de dificuldade e ele tem que acertar o número secreto escolhido em um intervalo que depende da dificuldade. São dadas dicas em relação ao número a cada novo chute.

Já no jogo da forca, o jogador deve adivinhar uma palavra secreta lida aleatoriamente de um arquivo que funciona como um dicionário. Passaremos a armazenar quem é o grande ganhador do jogo em um arquivo local.

Por fim, no Foge-Foge veremos como implementar um jogo baseado em turnos (turn based) onde o herói pode andar por um mapa, lido entre diversos arquivos, com inimigos (fantasmas) e bombas que podemos usar.

No fim, você estará apto para tomar o próximo passo em sua carreira como profissional desenvolvedor, seja praticando mais, aprendendo Orientação a Objetos, estrutura de dados, algoritmos, tudo de acordo com o que deseja para si, uma carreira no mundo dos jogos, internet, mobile etc.

Todo o código pode ser encontrado no link a seguir, ele está separado de acordo com o final de cada capítulo.

http://bit.ly/1LGOznk

Para o professor

Ao utilizar esse material em sua sala de aula, oferecemos diversos exercícios que são extensões ligadas diretamente aos jogos implementados. Oferecemos também desafios numéricos que permitem ao aluno criar um novo programa do zero.

Sinta-se à vontade para enviar sugestões de novos exercícios, sejam eles numéricos, lógicos, jogos, ou extensões ao jogo criado.

Quem sou eu

Agora que a parte mais importante ─ nosso aprendizado ─ já foi discutido, chegamos à minha apresentação.

Meu nome é Guilherme Silveira, trabalho com desenvolvimento de software desde meu primeiro estágio em 1996. Aprendi a programar na época aos 9 anos, meu irmão era meu professor particular, que me instigou a criar pequenos jogos em Basic. Jogos são motivos interessantes pois trazem um prazer tanto no desenvolvimento quanto a possibilidade de compartilhá-los com qualquer um de nossos familiares.

Apesar de ter trabalhado por um bom tempo com Visual Basic, C e C++, cresci como profissional utilizando a linguagem Java, que até hoje é a minha principal ferramenta, mas nunca me mantive restrito a ela ─ apesar do gosto pessoal. Aprendi Ruby a primeira vez em 2009 e vejo a linguagem como um contraponto interessante à abordagem type safe e compilada do Java, o que permite entender melhor os pontos fortes e fracos de cada linguagem, e de outras que vim a aprender nos anos que se passaram.

Por gostar de ensinar computação desde criança, acabei por fundar junto ao Paulo Silveira a Caelum em 2004. De lá para cá, junto ao Maurício Aniche me tornei coordenador do Alura, onde tenho a oportunidade de criar os mais diversos cursos, efetuando extensiva pesquisa com experts em cada área. É um prazer estar sempre aprendendo com pessoas tão interessantes e cheias de conhecimento, juntá-lo e repassá-lo com a didática da Caelum nos três meios que acho mais interessantes hoje em dia: como livro, como curso online e presencial.

Agradecimentos

Dedico este livro ao meu pai, Carlos Felício, pela sua alegria, nossa felicidade, por ter acreditado em meu potencial como educador e matemático, por ter incentivado minha independência e crescimento profissional. São centenas os pontos de minha vida pessoal e profissional onde o caminho foi caminhado por mim, mas não sem antes consultá-lo.

Um agradecimento especial ao Paulo Silveira, que mais de 20 anos atrás me ensinou o conteúdo aqui presente, e que me incentivou a escrever este livro.

Agradeço à Joviane Jardim, que tanto atualiza o material didático da Caelum sobre Ruby, respectivamente de quem e onde pude aprender comos e porquês da linguagem. Agradeço ao Fábio Akita, cujo blog serve como inspiração para entender melhor a evolução da linguagem e de seu ecossistema durante todos esses anos. Ao Fábio Kung, que muitos anos atrás me introduziu ao mundo Ruby, e me levou a perguntar pela primeira vez como a linguagem influenciava diversas características de meu código, abrindo a porta para minhas primeiras críticas de todas as linguagens.

Obrigado ao Maurício Aniche, pelas inúmeras discussões semanais que temos toda vez que começamos um novo livro, onde mais aprendo do que ensino. E obrigado ao Adriano Almeida que mais uma vez aturou meus spams sobre o conteúdo, título e viabilidade deste projeto.

Obrigado a você, aluno e professor, estudante ao se aventurar comigo pelo aprendizado de programação, professor ao compartilhar com seus amigos esse novo mundo que se abre para uma nova geração de jovens brasileiros, o mundo onde somos os donos do computador.

Prefácio por Fábio Akita

As coisas mudam muito rápido no mundo da tecnologia. Eu comecei a digitar minhas primeiras linhas de código num MSX Hotbit no meio dos anos 80, na antiga linguagem Basic.

Escrever código é muito simples, literalmente qualquer um consegue pesquisar trechos de código no Google e colar tudo junto, em um emaranhado de instruções que, com sorte, consegue processar alguma coisa útil.

Todos que pensam em tecnologia imaginam um mundo onde tudo muda constantemente, onde o que aprendemos ontem vai ser jogado fora amanhã e teremos que aprender tudo de novo. Qual o sentido em estudar demais quando sabemos que podemos simplesmente pegar alguns pedaços de código e fazer tudo aparentemente funcionar?

Recentemente observei uma chef, que realmente estudou gastronomia, cozinhando. As pequenas coisas me chamaram a atenção. Para engrossar um caldo, até mesmos nós, programadores e nerds que mal sabem fritar um ovo, sabemos que basta colocar algumas colheres de maizena e voilà. Ela primeiro pegou um pouco do caldo em uma tigela e misturou a maizena bem, depois jogou na panela. Por quê? Porque se colocar a maizena diretamente ela vai empelotar.

Em um pequeno erro, ela esqueceu de colocar sal no arroz. E agora? Se fosse eu, tentaria consertar jogando sal diretamente no arroz e tentando misturar. Ia ficar uma droga, partes com sal demais, partes ainda sem sal. Ela pegou uma tigela de água, misturou o sal e daí jorrou a água salgada nesse arroz. Ficou como se não tivesse faltado sal.

O que é isso? São técnicas fundamentais, coisas que para qualquer chef é o óbvio, o nosso hello world. Mas para mim, um completo amador, são novidades que serão muito úteis no futuro.

Programar é muito fácil, como fazer arroz. Eu sempre digo que qualquer um pode colocar ingredientes numa panela e ligar o fogo, mas isso não o torna um chef. Da mesma forma, qualquer um pode digitar (ou copiar e colar) códigos, mas isso não o torna um programador.

Gastronomia, pintura, música, programação, são todas profissões de prática. A prática nos faz melhores em nossa arte. Não é algo que podemos meramente decorar e aplicar sem consciência do que significa ou aonde queremos chegar. E em qualquer profissão de prática existem fundamentos, conhecimentos essenciais, técnicas básicas, que quanto antes entendermos mais vão facilitar nossa evolução.

O Guilherme Silveira é um dos melhores programadores que já conheci, ele realmente tem não só a vocação, mas o talento tanto para assimilar esse tipo de conhecimento como para explicá-lo. É muito raro encontrar essa combinação.

Este livro que ele escreveu não vai torná-lo o grande ninja da programação. Não, ele vai lhe dar esse conhecimento essencial e as técnicas básicas que, se devidamente estudados, devem fornecer o alicerce para que quaisquer novas tecnologias do presente e do futuro que surjam sejam muito mais fáceis de assimilar.

Melhor ainda porque o Guilherme escolheu nossa amada linguagem Ruby para ajudá-los a aprender em uma plataforma que foi criada com conceitos como estética e produtividade em mente. Através da linguagem Ruby e do contexto de criar pequenas lógicas de jogos, conceitos importantes como entrada e saída, funções, recursão, são explicados com clareza. Conceitos esses que são universais e importantes, não importa qual linguagem você usa hoje ou possa usar no futuro.

Bom estudo!

Capítulo 1:

Jogo da adivinhação

1.1 O jogo: entrada e saída básica

Nosso primeiro grande projeto será a criação de um jogo que escolhe um número aleatório, e nos desafia a adivinhá-lo. O jogo permite a escolha do nível de dificuldade, nos dá feedback constante sobre nossos erros e acertos.

Portanto, nosso primeiro programa nos diz se o número é maior ou menor do que o escolhido pelo computador. Será um arquivo escrito na linguagem Ruby, que nome escolher para ele? Como o jogo brinca com maior ou menor, vamos chamar de maior_ou_menor, mas qual a extensão para ele? O padrão do Ruby é utilizar a extensão rb, portanto criamos um arquivo chamado maior_ou_menor.rb. O conteúdo? Vazio.

Dado esse programa, vazio, queremos mandar o computador executá-lo. Para isso dizemos para o ruby rodar nosso arquivo:

1 ruby maior_ou_menor.rb

E nada acontece. Claro, não havia nada para ser feito.

Um programa é uma lista de comandos que o computador obedece. Somos os donos do computador não só fisicamente, mas somos o dono de suas mentes. Somos capazes de dizer comandos que o computador deve obedecer. Esses comandos serão escritos aqui na linguagem Ruby, e um tradutor, um intérprete, será capaz de traduzir esses comandos para um código maluco que nossa máquina entende. Afinal, quem hoje em dia quer aprender a falar a língua das máquinas? Muito complicado, principalmente para começar a programar. Então aprendemos uma linguagem mais próxima de nós do que dos computadores (uma linguagem de alto nível). Qual o primeiro comando que quero dar para meu computador? Por favor, imprima uma mensagem de boas-vindas.

Para isso dizemos para o computador colocar uma mensagem na saída: coloque, puts, a mensagem Bem-vindo ao jogo da adivinhação:

1 puts Bem-vindo ao jogo da adivinhação

A saída ao rodar novamente ruby maior_ou_menor.rb é agora o que esperamos:

1 Bem-vindo ao jogo da adivinhação

Já somos os donos. Ele nos obedece, e a mágica agora está em aprender mais comandos e formas de juntar comandos para criar programas complexos que fazem as mais diversas tarefas, desde um jogo até mesmo um piloto automático de avião. Todos eles são códigos escritos por seres humanos, e o computador obedece.

No nosso caso, queremos perguntar ao usuário qual é o seu nome, para personalizarmos sua experiência. Não é à toa que os jogos de hoje em dia perguntam o nome, no fim é possível lembrar quem foi o melhor jogador, criar um rank etc. No nosso caso começaremos pedindo o nome, usando novamente o puts para colocar uma mensagem na saída do computador:

1 puts Bem-vindo ao jogo da adivinhação 2 puts Qual é o seu nome?

E o inverso? Queremos que nosso programa leia um dado, pegue (get) informação do usuário, a entrada de dados mais simples é feita com a função gets, que devolve um texto, um valor que o usuário digitou, junto com o enter (o return):

1 nome = gets

Imprimimos o nome da mesma maneira que imprimimos outras mensagem:

1 puts Bem-vindo ao jogo da adivinhação 2 puts Qual é o seu nome? 3 4 nome = gets 5 puts Começaremos o jogo para você, 6 puts nome

E após executarmos com ruby maior_ou_menor.rb temos:

1 Bem-vindo ao jogo da adivinhação 2 Qual é o seu nome? 3 Guilherme 4 Começaremos o jogo para você, 5 Guilherme

Que saída horrível. Vamos separar o momento em que o nome foi lido do resto do programa, quando notificamos o usuário que começaremos o jogo. Primeiro colocamos algumas linhas em branco, isto é, não imprimimos nada, somente uma quebra de linha:

1 puts Bem vindo ao jogo da adivinhação 2 puts Qual é o seu nome? 3 nome = gets 4 puts 5 puts 6 puts 7 puts 8 puts 9 puts 10 puts Começaremos o jogo para você, 11 puts nome

E a saída agora fica um pouco melhor:

1 Bem-vindo ao jogo da adivinhação 2 Qual é o seu nome? 3 Guilherme 4 5 6 7 8 9 10 Começaremos o jogo para você, 11 Guilherme

A saída ainda está feia, gostaríamos de jogar na tela a mensagem Começaremos o jogo para você, Guilherme. Para isso precisamos juntar dois textos, o primeiro é o nome. Como fazer isso? Em linguagens de programação em geral, chamamos de String um valor que é um conjunto de caracteres, como uma palavra, um texto, uma placa de carro etc. Portanto, queremos juntar duas String, uma depois da outra. Como fazer isso? Usaremos a soma de duas Strings, chamada de concatenação:

1 puts Começaremos o jogo para você, + nome

Ficando com o código final:

1 puts Bem-vindo ao jogo da adivinhação 2 puts Qual é o seu nome? 3 nome = gets 4 puts 5 puts 6 puts 7 puts 8 puts 9 puts 10 puts Começaremos o jogo para você, + nome

Agora sim nossa saída é bonita:

1 Bem-vindo ao jogo da adivinhação 2 Qual é o seu nome? 3 Guilherme 4 5 6 7 8 9 10 Começaremos o jogo para você, Guilherme

Desejamos escolher um número secreto. Neste instante deixaremos um número fixo e depois o alteraremos para que cada vez o número tenha um valor diferente. Primeiro, imprimimos a mensagem de anúncio do sorteio, algo que já conhecemos:

1 puts Escolhendo um número secreto entre 0 e 200...

Depois queremos definir um novo valor. O valor 175 será nosso número secreto, logo falo que numero_secreto deve receber o valor 175:

1 puts Escolhendo um número secreto entre 0 e 200... 2 numero_secreto = 175 3 puts Escolhido... que tal adivinhar hoje nosso número secreto?

Ficamos com o resultado:

1 Bem-vindo ao jogo da adivinhação 2 Qual é o seu nome? 3 Guilherme 4 5 6 7 8 9 10 Começaremos o jogo para você, Guilherme 11 Escolhendo um número secreto entre 0 e 200... 12 Escolhido... que tal adivinhar hoje nosso número secreto?

Precisamos agora perguntar um número, um chute, que o usuário deseja escolher. Já sabemos ler essa informação, portanto fazemos:

1 puts 2 puts 3 puts 4 puts 5 puts Tentativa 1 6 puts Entre com o numero 7 chute = gets

Mas o que fazer com o chute? Primeiro avisamos o usuário que processaremos seu chute, será que ele acertou? Novamente, é o código com que estamos começando a nos acostumar: puts passando Strings e concatenações:

1 puts 2 puts 3 puts 4 puts 5 puts Tentativa 1 6 puts Entre com o numero 7 chute = gets 8 puts Será que acertou? Você chutou + chute

Testamos nosso programa, chutando o número 100:

1 Bem-vindo ao jogo da adivinhação 2 Qual é o seu nome? 3 Guilherme 4 5 6 7 8 9 10 Começaremos o jogo para você, Guilherme 11 Escolhendo um número secreto entre 0 e 200... 12 Escolhido... que tal adivinhar hoje nosso número secreto? 13 14 15 16 17 Tentativa 1 18 Entre com o numero 19 100 20 Será que acertou? Você chutou 100

1.2 Será que acertou? O operador de comparação ==

Estamos prontos para verificar se o usuário acertou ou errou. Como? Queremos verificar se o valor chutado é igual ao número secreto. Qual o símbolo matemático para igualdade? O igual, =. Mas já usamos o = antes para dizer que um valor estava sendo utilizado. Como então verificar se um valor é igual a outro? Usaremos o ==. Será que o chute é igual igual ao número secreto escolhido?

Por exemplo, será que 175 é igual a 175?

1 puts 175 == 175

Levando em consideração que verdadeiro é true em inglês, a saída é:

1 true

E será que ele é igual a 174?

1 puts 175 == 175 2 puts 175 == 174

Levando em consideração que falso é false em inglês, a saída é:

1 true 2 false

Isto é, o operador == realmente compara a igualdade entre dois números. Os valores verdadeiro e falso são chamados de booleanos.

Agora podemos verificar se o número chutado é igual a