Use o código e tenha 10% de desconto!

Introdução à Computação Da Lógica aos jogos com Ruby

Guilherme Silveira
Capa

Introdução à Computação: Da Lógica aos jogos com Ruby

Introduçã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 de 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*), no qual 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.

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 em um 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 de 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 em uma 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!

Sumário

  • 1 - Introdução
    • 1.1 - Programação
    • 1.2 - Para o professor
    • 1.3 - Quem sou eu
    • 1.4 - Agradecimentos
  • 2 - Prefácio por Fábio Akita
    • 3 - Jogo da adivinhação
      • 3.1 - O jogo: entrada e saída básica
      • 3.2 - Será que acertou? O operador de comparação ==
      • 3.3 - Operador de atribuição e variáveis
      • 3.4 - Operadores de comparação
      • 3.5 - Entrada e saída
      • 3.6 - O que são funções
      • 3.7 - Refatoração: \n
      • 3.8 - Interpretador ou compilador
      • 3.9 - Resumindo
    • 4 - Controle de fluxo
      • 4.1 - Mas e se... if e else
      • 4.2 - Code smell: comentários
      • 4.3 - Condições aninhadas (nested ifs)
      • 4.4 - Code smell: copy e paste
      • 4.5 - O laço for (loop)
      • 4.6 - Aplicando o laço for ao nosso programa
      • 4.7 - Code smell: Magic numbers
      • 4.8 - Refatoração: extrair variável
      • 4.9 - Quebrando o laço com o break
      • 4.10 - Resumindo
    • 5 - Funções
      • 5.1 - Funções
      • 5.2 - Boa prática: encapsulamento de comportamento
      • 5.3 - Escopo de variáveis
      • 5.4 - Code smell: variáveis sem controle de escopo e variáveis globais
      • 5.5 - Retorno de função
      • 5.6 - Variáveis locais
      • 5.7 - Extraindo mais uma função
      • 5.8 - Boa prática: early return
      • 5.9 - Pequenas refatorações específicas da linguagem
      • 5.10 - Resumindo: o poder da extração de código
      • 5.11 - Resumindo
    • 6 - Arrays
      • 6.1 - Criando e manipulando arrays
      • 6.2 - Aplicando o array ao nosso jogo
      • 6.3 - Facilidades de um array
      • 6.4 - Simplificando nosso código de array
      • 6.5 - Arrays e Strings
      • 6.6 - Interpolação de Strings
      • 6.7 - Funções e métodos
      • 6.8 - Testando métodos no IRB
      • 6.9 - Resumindo
    • 7 - Pontos e matemática
      • 7.1 - Ponto flutuante
      • 7.2 - Simulação do código
      • 7.3 - Matemática
      • 7.4 - Unless... e a dupla negação
      • 7.5 - Número aleatório
      • 7.6 - Operadores matemáticos
      • 7.7 - Sistema de tipos
      • 7.8 - Resumindo
    • 8 - Binário
      • 8.1 - Binário
      • 8.2 - Binário e letras
      • 8.3 - Bits: 8, 16, 32, 64
      • 8.4 - Bits e números com ponto flutuante
      • 8.5 - Hexadecimal
      • 8.6 - Bits e imagens
      • 8.7 - Resumindo
    • 9 - Nível de dificuldade e o case
      • 9.1 - Case...when...end
      • 9.2 - Escopo de variável local
      • 9.3 - Trapaceando
      • 9.4 - Corrigindo o número sorteado
      • 9.5 - While: jogando diversas vezes
      • 9.6 - loop do...end
      • 9.7 - Resumindo
    • 10 - Arte ASCII: jogo da adivinhação
      • 10.1 - Melhorando nossa interface com o usuário
    • 11 - Exercícios extras: jogo da adivinhação
      • 11.1 - Melhorando o jogo de adivinhação
      • 11.2 - Outros desafios
    • 12 - Jogo da forca
      • 12.1 - Chute de uma palavra completa e a comparação com ==
      • 12.2 - Encontrando um algoritmo
      • 12.3 - Implementando o algoritmo
      • 12.4 - Boa prática: explorando a documentação
      • 12.5 - next... Evitando chutes repetidos
      • 12.6 - Resumindo
    • 13 - Responsabilidades
      • 13.1 - Mostrando parte da palavra secreta
      • 13.2 - Separando a interface com o usuário da lógica de negócios
      • 13.3 - Extraindo a lógica de negócios
      • 13.4 - Extraindo a lógica de um chute válido
      • 13.5 - Implementação: mostrando parte da palavra secreta
      • 13.6 - Resumindo
    • 14 - Entrada e saída de arquivo: palavras aleatórias e o top player
      • 14.1 - Lendo um arquivo de palavras, nosso dicionário
      • 14.2 - Limpando a entrada de dados
      • 14.3 - Processamento e memória devem ser otimizadas?
      • 14.4 - Escrita para arquivo: o melhor jogador
      • 14.5 - Lendo o melhor jogador
      • 14.6 - Refatoração: extrair arquivo
      • 14.7 - A pilha de execução
      • 14.8 - Resumindo
    • 15 - Arte ASCII: jogo da forca
      • 15.1 - Melhorando nossa interface com o usuário
    • 16 - Exercícios extras: jogo da forca
      • 16.1 - Melhorando o jogo da forca
      • 16.2 - Outros desafios
    • 17 - Foge-foge, um jogo baseado no Pacman
      • 17.1 - Definindo a base do jogo e o mapa
      • 17.2 - Array de array: matriz
      • 17.3 - Movimento
      • 17.4 - Refatorando
      • 17.5 - O vazio, o nulo
      • 17.6 - Laço funcional básico
      • 17.7 - Extraindo a posição
      • 17.8 - Refatorando
      • 17.9 - Passagem por referência ou valor?
      • 17.10 - Detecção de colisão com o muro e o fim do mapa
      • 17.11 - Refatorando com || e &&
      • 17.12 - Duck typing na prática
      • 17.13 - for i x for linha
      • 17.14 - Resumindo
    • 18 - Botando os fantasmas para correr: arrays associativos, duck typing e outros
      • 18.1 - Array associativo: case e +1, -1
      • 18.2 - Movimento dos fantasmas: o desafio no duck typing
      • 18.3 - Movimento dos fantasmas: reutilização de função
      • 18.4 - Fantasma contra fantasma?
      • 18.5 - Resumindo
    • 19 - Matrizes e memória
      • 19.1 - Teletransportando fantasmas: cuidados a tomar com a memória
      • 19.2 - Corrigindo o teletransporte
      • 19.3 - Copiando nosso mapa
      • 19.4 - Movendo os fantasmas na matriz copiada
      • 19.5 - Refatorando o movimento do fantasma
      • 19.6 - O fantasma cavaleiro
      • 19.7 - Movimento aleatório dos fantasmas
      • 19.8 - Quando o herói perde
      • 19.9 - Retorno nulo ou opcional?
      • 19.10 - Resumindo
    • 20 - Estruturas e classes: uma introdução a Orientação a Objetos
      • 20.1 - A bagunça dos defs
      • 20.2 - Extraindo uma primeira estrutura
      • 20.3 - Usando uma estrutura
      • 20.4 - Code smell: feature envy
      • 20.5 - Boa prática: buscar quem invoca antes de refatorar
      • 20.6 - Boa prática: Tell, don't ask
      • 20.7 - Atributos e attr_accessor
      • 20.8 - Estrutura ou Classe?
      • 20.9 - A verdade por trás de métodos, funções e lambdas
      • 20.10 - Resumindo
    • 21 - Destruindo os fantasmas: o mundo da recursão
      • 21.1 - Destruindo os fantasmas
      • 21.2 - Andando para a direita
      • 21.3 - Recursão infinita
      • 21.4 - A base da recursão
      • 21.5 - Base da recursão: distância quatro ou muro
      • 21.6 - Recursão para todos os lados: busca em profundidade
      • 21.7 - Resumindo
    • 22 - Exercícios extras: jogo do foge-foge
      • 22.1 - Melhorando o Jogo do foge-foge
      • 22.2 - Outros desafios
    • 23 - Como continuar
      • 23.1 - Praticar
      • 23.2 - Estrutura de dados e algoritmos
      • 23.3 - Orientação a Objetos?
      • 23.4 - Competições de programação da ACM
      • 23.5 - Outra linguagem?
      • 23.6 - Compartilhe e boa jornada
    • 24 - Apêndice — Instalando o Ruby
      • 24.1 - Instalação no Windows
      • 24.2 - Instalação no Linux
      • 24.3 - Instalação no Mac OS X
      • 24.4 - O editor de texto

    Dados do produto

    Número de páginas:
    293
    ISBN:
    978-85-5519-016-2
    Data publicação:
    05/2015

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter