cap8.t2t

Capítulo 8
Fluxogramas


%!encoding: utf-8
%!preproc: 'ASCIIART' 'Arte com ASCII'



%TODO: durante todo o texto, o autor fala em player e ao se referir, usa they ou
%them. Para não soar estranho, traduzi "they" como "ele". Trecho:

% Then the second player tries to guess letters that might be in the word. If 
% they guess correctly, the first player writes the letter in the proper blank.


%Topics Covered In This Chapter:
==Tópicos Cobertos Neste Capítulo:==

%    How to play Hangman.
%    ASCII art
%    Designing our game by drawing a flow chart before programming.
- Como jogar o Jogo da Forca.
- ASCIIART
- Projetando nosso jogo através de fluxogramas antes de programar.


%In this chapter, we will make the design for a Hangman game. This game is more
%complicated than our previous game, but it is also much more fun. Because the
%game is advanced, we should first carefully plan it out by creating a diagram
%called a flow chart (explained later). In the next chapter, we will actually
%write out the code for Hangman.
Neste capítulo, iremos projetar o Jogo da Forca. Esse jogo é mais complicado que
nosso primeiro jogo, mas é também muito mais divertido. Como esse é um jogo
avançado, nós devemos primeiramente planejá-lo criando um diagrama chamado
fluxograma (a ser explicado mais tarde). No próximo capítulo, iremos escrever
de verdade o código do Jogo da Forca.


%In case you've never played Hangman before, let's first learn the rules for
%Hangman.
Caso você nunca tenha jogado o Jogo da Forca antes, vamos primeiro aprender suas
regras.


%How to Play "Hangman"
=Como jogar o "Jogo da Forca"=

%In case you don't know, Hangman is a game for two people that's usually played
%using paper and pencil. One player thinks of a word, and then draws a blank on
%the page for each letter in the word. Then the second player tries to guess
%letters that might be in the word. If they guess correctly, the first player
%writes the letter in the proper blank. If they guess incorrectly, the first
%player draws a single body part of the hanging man. If the second player can
%guess all the letters in the word before the hangman has been completely
%drawn, they win. But if they can't figure it out in time, the man is hanged
%and they lose the game!
Caso você não saiba, o Jogo da Forca é um jogo para duas pessoas que é
normalmente jogado com papel e caneta. Um jogador pensa em uma palavra, e então
desenha um espaço em branco na página para cada letra da palavra. Então, o
segundo jogador tenta adivinhar as letras que podem compor a palavra. Se ele
errar, o primeiro jogador desenha uma única parte do corpo do homem da forca.
Se o segundo jogador conseguir adivinhar todas as letras na palavra antes que o
//homem da forca// tenha sido completamente desenhado, ele ganha. Mas se ele
não conseguir descobrir a tempo, o homem é enforcado e ele perde o jogo.


%Sample Run of "Hangman"
=Exemplo de Execução do Jogo da Forca=

%Here is an example of what the player might see when they run the Hangman
%program we will write later. The text that the player enters in shown in bold.
Aqui temos um exemplo de o que o jogador deve ver quando executa o programa do
Jogo da Forca que iremos escrever mais tarde. O texto que o usuário digita
aparece em negrito.

%H A N G M A N

%  +---+
%  |   |
%      |
%      |
%      |
%      |
%=========
%Missed letters:
%_ _ _
%Guess a letter.
%a
%
%  +---+
%  |   |
%      |
%      |
%      |
%      |
%=========
%Missed letters:
%_ a _
%Guess a letter.
%o
%
%  +---+
%  |   |
%  O   |
%      |
%      |
%      |
%=========
%
%Missed letters: o
%_ a _
%Guess a letter.
%r
%
%  +---+
%  |   |
%  O   |
%  |   |
%      |
%      |
%=========
%
%Missed letters: or
%_ a _
%Guess a letter.
%t
%
%  +---+
%  |   |
%  O   |
%  |   |
%      |
%      |
%=========
%Missed letters: or
%_ a t
%Guess a letter.
%a
%You have already guessed that letter. Choose again.
%Guess a letter.
%c
%Yes! The secret word is "cat"! You have won!
%Do you want to play again? (yes or no)
%no

```
JOGO DA FORCA

  +---+
  |   |
      |
      |
      |
      |
=========
Letras perdidas:
_ _ _ _
Adivinhe uma letra:
```

**a**

```
  +---+
  |   |
      |
      |
      |
      |
=========
Letras perdidas:
_ a _ _
Adivinhe uma letra:
```

**x**

```
  +---+
  |   |
  O   |
      |
      |
      |
=========

Letras perdidas: x
_ a _ _
Adivinhe uma letra:
```

**r**

```
  +---+
  |   |
  O   |
  |   |
      |
      |
=========

Letras perdidas: xr
_ a _ _
Adivinhe uma letra:
```

**t**

```
  +---+
  |   |
  O   |
  |   |
      |
      |
=========

Letras perdidas: xr
_ a t _
Adivinhe uma letra:
```

**a**

```
Você já adivinhou essa letra. Escolha novamente.
Adivinhe uma letra:
```

**g**

```
  +---+
  |   |
  O   |
  |   |
      |
      |
=========

Letras perdidas: xr
g a t _
Adivinhe uma letra:
```

**o**

```
Isso! A palavra secreta é "gato"! Você venceu!
Você deseja jogar novamente? (sim ou não)
```

**não**



%ASCII Art
=ASCIIART=

%The graphics for hangman are all made out of keyboard characters printed on
%the screen. This type of graphics is called ASCII art (pronounced "ask-ee"),
%because keyboard characters (such as letters, numbers, and also all the other
%signs on the keyboard) are called ASCII characters. ASCII stands for American
%Standard Code for Information Interchange (we'll learn more about it in the
%Caesar Cipher chapter). Here are a couple cats done in ASCII art:
Os gráficos para o Jogo da Forca foram todos compostos por caracteres do
teclado impressos na tela. Esse tipo de gráfico é chamado de ASCIIART
(pronunciado "asqui"), porque os caracteres do teclado (tais como letras,
números, e todos os outros símbolos no teclado) são chamados de caracteres
ASCII. ASCII significa //American Standard Code for Information Interchange//
(nós iremos aprender mais sobre ele no capítulo sobre a Cifra de Caesar).
Abaixo, temos alguns gatos feitos com ASCIIART:

```
                                     __________________
                               _____/   xx      xxx    \_____
                             _/xxx       xx      xxx   xxx   \__
                          __/     xxx     xxx     xx    xxx     \__
                         /xxxxxxxxx   xx     xx      xx    xx    xxx\
 ^___^                  /          xx  /\                    xx     xx\
 |    )                /              /  \                   x      xx \
 |. .  )               |    /\       |    \                        xx  x\
(  v    )              |   |  \      |     \____        Z            x   \
 \____  |              |   |   \____/           \     z            xxx   |
  |      \             |   |                     \  z                    |
  |       |             \/                        \                       \
  |        \            /                 ____/    |                      |
  | |       |        __|        \____              |                   xxx|
  | | |      \      /  |               ___   ___-------          __/     x|
  | | |      |-.   /   |              |   |   _______       ____/         |
  | | | ____/  |   |  o\    --------   \_/       _/     ___/          xx /
 ((((()(______/    |oo  \      _____/          _/______/              xx/
                   \     \__                __/                    xx  /
                    \       \______________/                        x_/
                      \____                                 _______/
                           \_______________________________/

```


%Designing a Program with a Flowchart
=Projetando um Programa com Fluxogramas=

%This game is a bit more complicated than the ones we've seen so far, so let's
%take a moment to think about how it's put together. First we'll create a flow
%chart (like the one at the end of the Dragon Realm chapter) to help us
%visualize what this program will do. This chapter will go over what flow
%charts are and why they are useful. The next chapter will go over the source
%code to the Hangman game. A flow chart is a diagram that shows a series of
%steps as a number of boxes connected with arrows. Each box represents a step,
%and the arrows show how one step leads to other steps. You can trace through
%the flow chart by putting your finger on the "Start" box of the flow chart and
%following the arrows to other boxes until you get to the "End" box. You can
%only move from one box to another in the direction of the arrow. You can never
%go backwards (unless there is a second arrow going back, like in the "Player
%already guessed this letter" box below.) Here is the complete flow chart for
%the Hangman game (Figure 8-1).
Este jogo é um pouco mais complicado do que aqueles que vimos até agora, então
vamos parar um pouco para pensar em como juntar tudo isso. Primeiramente,
iremos criar um fluxograma (como aquele feito ao final do capítulo do Reino do
Dragão) para nos ajudar a visualizar o que o programa irá fazer. Este capítulo
irá mostrar o que são fluxogramas e porque eles são úteis. O próximo capítulo
irá apresentar o código-fonte para o Jogo da Forca. Um fluxograma é um diagrama
que mostra uma série de passos como um conjunto de "caixas" conectadas por
setas. Cada caixa representa um passo, e as setas mostram como um passo leva a
outros passos. Você pode seguir pelo fluxograma colocando o seu dedo na caixa
"Início" do fluxograma e seguindo as setas para outras caixas até você chegar à
caixa "Fim". Você só pode passar de uma caixa para a outra na direção da seta.
Você nunca pode andar para trás (a menos que haja uma segunda seta levando para
trás, como na caixa "Jogador já adivinhou essa letra" abaixo.) Aqui está um
fluxograma completo para o Jogo da Forca (Figura 8-1).

[chapter8/8-1.png]

%Figure 8-1: The complete flow chart for what happens in the Hangman game.
Figura 8-1: O fluxograma completo para o que acontece no Jogo da Forca.

%Of course, we don't have to make a flow chart. We could just start writing
%code. But often, once we start programming, we will think of things that need
%to be added or changed that we hadn't considered before. We may end up having
%to change or delete a lot of code that we had already written, which would be a
%waste of effort. To avoid this, it's always best to think carefully, and plan
%how the program will work before we start writing it.
É claro que nós não precisamos fazer o fluxograma. Poderíamos começar já
escrevendo código. Porém, frequentemente, quando iniciamos a programar, nós
iremos lembrar de coisas que precisam ser adicionadas ou modificadas, que não
haviam sido consideradas antes. Podemos acabar tendo que modificar ou apagar um
monte de código que escrevemos, o que seria um desperdício de esforço. Para
evitar isso, é sempre melhor pensar cuidadosamente, e planejar como o programa
irá funcionar antes de começar a escrevê-lo.

%The following flow chart is provided as an example of what flow charts look
%like and how to make them. For now, since you're just using the source code
%from this book, you don't need to draw a flow chart before writing code. The
%program is already written, so you don't have to plan anything out. But when
%you make your own games, a flow chart can be very handy.
O fluxograma a seguir é fornecido como um exemplo de como os fluxogramas se
parecem e como fazê-los. Por enquanto, como você está apenas utilizando o
código-fonte deste livro, você não precisa desenhar um fluxograma antes de
escrever código. O programa já está previamente escrito, assim você não precisa
planejar nada. Mas, quando você escrever seus próprios jogos, um fluxograma será
muito útil.


%Creating the Flow Chart
=Criando o Fluxograma=

%Keep in mind, your flow charts don't always have to look exactly like this one.
%As long as you understand the flow chart you made, it will be helpful when you
%start coding. We'll begin with a flow chart that only has a "Start" and an
%"End" box, as shown in Figure 8-2:
Tenha em mente, seus fluxogramas não precisam se parecer exatamente como este.
Contanto que você entenda o fluxograma que você fez, ele será muito útil quando
você começar a codificar. Nós iremos iniciar com um fluxograma que tem somente
uma caixa "Início" e uma caixa "Fim", como mostra a Figura 8-2:

[chapter8/8-2.png]

%Figure 8-2: Begin your flow chart with a Start and End box.
Figura 8-2: Comece seu fluxograma com uma caixa Início e uma caixa Fim.

%Now let's think about what happens when we play Hangman. First, one player (the
%computer in this case) thinks of a secret word. Then the second player (the
%person running the program) will guess letters. Let's add boxes for these
%events, as shown in Figure 8-3. (The boxes that are new to each flow chart have
%a dashed outline around them.) The arrows show the order that the program
%should move. That is, first the program should come up with a secret word, and
%after that it should ask the player to guess a letter.
Agora vamos pensar sobre o que acontece quando jogamos o Jogo da Forca.
Primeiro, um jogador (o computador neste caso) pensa em uma palavra secreta.
Então, o segundo jogador (a pessoa executando o programa) irá adivinhar letras.
Vamos adicionar caixas para esses eventos, como mostrado na Figura 8-3. (As
caixas que são novas para cada fluxograma possuem uma linha tracejada ao redor
delas.) As setas mostram a ordem em que o programa deveria andar. Isto é,
primeiro o programa deveria trazer uma palavra secreta, e depois deveria pedir
ao usuário para adivinhar uma letra.

[chapter8/8-3.png]

%Figure 8-3: Draw out the first two steps of Hangman as boxes with descriptions.
Figura 8-3: Desenho dos dois primeiros passos do Jogo da Forca como caixas com
descrições.

%But the game doesn't end after the player guesses one letter. It needs to check
%to see if that letter is in the secret word or not.
Mas o jogo não termina depois que o jogador adivinha uma letra. Ele precisa
verificar se aquela letra está ou não contida na palavra secreta.


%Branching from a Flowchart Box
=Criando Ramificações de uma Caixa de Fluxograma=

%There are two possibilities: the letter will either be in the word or it won't
%be. This means we need to add two new boxes to our flowchart. From the "Ask
%player to guess a letter" box, we can only move to the "Letter is in secret
%word" box or the "Letter is not in secret word" box. This will create a branch
%(that is, a split) in the flow chart, as show in Figure 8-4:
Existem duas possibilidades: a letra estará na palavra ou não. Isso significa
que nós precisamos duas novas caixas em nosso fluxograma. Da caixa "Peça ao
jogador para adivinhar uma letra", nós somente podemos nos mover para a caixa
"Letra pertence à palavra secreta" ou para a caixa "Letra não pertence à palavra
secreta". Isto irá criar uma ramificação (isto é, uma divisão) no fluxograma,
como mostra a Figura 8-4:

[chapter8/8-4.png]

%Figure 8-4: There are two different things that could happen after the player 
%guesses, so have two arrows going to separate boxes.
Figura 8-4: Existem duas coisas diferentes que poderiam acontecer depois que o
jogador adivinha, então temos duas setas indo para diferentes caixas.

%If the letter is in the secret word, we need to check to see if the player has
%guessed all the letters, which would mean they've won the game. But, if the
%letter is not in the secret word, another body part is added to the hanging
%man.
Se a letra pertence à palavra secreta, nós precisamos verificar se o jogador já
adivinhou todas as letras, o que significaria que o jogador ganhou o jogo. Mas,
se a letra não pertence à palavra secreta, outra parte do corpo é adicionada ao
homem que está sendo enforcado.

%We can add boxes for those cases too. We don't need an arrow from the "Letter
%is in secret word" box to the "Player has run out of body parts and loses" box,
%because it's impossible to lose as long as you are only guessing correct
%letters. Also, it's impossible to win as long as you are guessing only
%incorrect letters, so we don't need to draw that arrow either. Our flow chart
%now looks like Figure 8-5.
Nós podemos adicionar caixas para aqueles casos também. Nós não precisamos de
uma seta da caixa "Letra pertence à palavra secreta" para a caixa "Jogador
esgotou as partes do corpo para colocar e perdeu", porque é impossível perder
enquanto você está escolhendo letras corretas. Também, é impossível vencer
quando você está escolhendo somente letras incorretas. Assim nós não precisamos
desenhar aquela seta também. Nosso fluxograma agora se parece com a Figura 8-5.

[chapter8/8-5.png]

%Figure 8-5: After the branch, the steps continue on their separate paths.
Figura 8-5: Despois da ramificação, os passos continuam em seus caminhos
separados.


%Ending or Restarting the Game
=Terminando ou Reiniciando o Jogo=

%Once the player has won or lost, we'll ask them if they want to play again with
%a new secret word. If the player doesn't want to play again, the program will
%end. If the program doesn't end, we think of a new secret word, as shown in
%Figure 8-6:
Uma vez que o jogador venceu ou perdeu, nós iremos perguntá-lo se ele deseja
jogar novamente com uma nova palavra secreta. Se ele não deseja jogar novamente,
o programa irá terminar. Se o programa não terminar, nós pensamos em uma nova
palavra secreta, como mostrado na Figura 8-6:

[chapter8/8-6.png]

%Figure 8-6: The game ends if the player doesn't want to play again, or the game
%goes back to the beginning.
Figura 8-6: O jogo termina se o jogador não quiser jogar novamente, ou o jogo
volta ao início.


%Guessing Again
=Adivinhando Novamente=
%This flow chart might look like it is finished, but there's something we're
%forgetting: the player doesn't guess a letter just once. They have to keep
%guessing letters over and over until they either win or lose. We need to draw
%two new arrows so the flow chart shows this, as shown in Figure 8-7.
Este fluxograma pode parecer que está terminado, mas há algo que nós estamos
esquecendo: o jogador não adivinha somente uma vez. Ele deve permanecer
adivinhando letras até que ganhe ou perca o jogo. Nós precisamos desenhar duas
novas setas de forma que o fluxograma represente isso, como mostrado na Figura
8-7:

[chapter8/8-7.png]

%Figure 8-7: The game does not always end after a guess. The new arrows
%(outlined) show that the player can guess again.
Figura 8-7: O jogo não termina sempre após uma adivinhação. As novas setas
(delineadas) mostram que o jogador pode adivinhar novamente.

%We are forgetting something else, as well. What if the player guesses a letter
%that they've guessed before? Rather than have them win or lose in this case,
%we'll allow them to guess a different letter instead, as shown in Figure 8-8.
Nós estamos esquecendo algo mais. E se o jogador adivinha uma letra que já
acertou anteriormente? Ao invés de fazê-lo vencer ou perder, nós iremos permitir
que ele adivinhe uma letra diferente, como mostrado na Figura 8-8.

[chapter8/8-8.png]

%Figure 8-8: Adding a step in case the player guesses a letter they already
%guessed.
Figura 8-8: Adicionando um passo caso o jogador adivinhar uma letra que já
adivinhou.


%Offering Feedback to the Player
=Dando Resposta ao Jogador=


%We also need some way to show the player how they're doing. In order to do
%this, we'll show them the hangman board, as well as the secret word (with
%blanks for the letters they haven't guessed yet). These visuals will let them
%see how close they are to winning or losing the game.
Nós também precisamos um forma para mostrar ao jogador como ele está indo. Para
isso, nós iremos mostrá-lo o tabuleiro do Jogo da Forca, assim como a palavra
secreta (com espaços em branco para as letras que ainda não adivinharam). Esses
indicativos visuais irão permitir ao jogador ver quão perto de ganhar ou de
perder ele está.

%We'll need to update this information every time the player guesses a letter.
%We can add a "Show the board and blanks to the player." box to the flow chart
%between the "Come up with a secret word" box and the "Ask player to guess a
%letter" box, as shown in Figure 8-9. This box will remind us that we need to
%show the player an updated hangman board so they can see which letters they
%have guessed correctly and which letters are not in the secret word.
Nós precisaremos atualizar essa informação a cada vez que o jogador adivinhar
uma letra. Nós podemos adicionar uma caixa "Mostre o tabuleiro e espaços em
branco ao usuário." entre as caixas "Escolha uma palavra secreta" e "Peça ao
jogador para adivinhar uma letra", como mostrado na Figura 8-9. Essa caixa irá
nos lembrar de que nós precisamos mostrar ao jogador um tabuleiro do Jogo da
Forca atualizado, de forma que ele possa ver quais letras ele adivinhou
corretamente e quais letras não estão na palavra secreta.

[chapter8/8-9.png]

%Figure 8-9: Adding "Show the board and blanks to the player." to give the
%player feedback.
Figura 8-9: Adicionando a caixa "Mostre o tabuleiro e espaços em branco ao
jogador." para dar uma resposta ao jogador.

%That looks good! This flow chart completely maps out everything that can
%possibly happen in Hangman, and in what order. Of course this flow chart is
%just an example-you won't really need to use it, because you're just using the
%source code that's given here. But when you design your own games, a flow chart
%can help you remember everything you need to code.
Parece bom! Este fluxograma mapeia completamente tudo o que pode acontecer no
Jogo da Forca, na ordem correta. É claro que esse fluxograma é apenas um exemplo
que você não irá realmente precisar utilizar, porque você está apenas utilizando
o código-fonte fornecido aqui. Mas quando você projetar seus próprios jogos, um
fluxograma pode ajudá-lo a lembrar tudo que precisa ser codificado.


%Summary: The Importance of Planning Out the Game
=Resumo: A Importância de Planejar o Jogo=

%It may seem like a lot of work to sketch out a flow chart about the program
%first. After all, people want to play games, not look at flowcharts! But it is
%much easier to make changes and notice problems by thinking about how the
%program works before writing the code for it.
Pode parecer um monte de trabalho rascunhar um fluxograma sobre o programa antes
de escrever o código. Afinal, as pessoas querem jogar jogos, não olhar para
fluxogramas! Mas é muito mais fácil alterar e perceber problemas pensando sobre
como o programa funciona antes de escrever o código para ele.

%If you jump in to write the code first, you may discover problems that require
%you to change the code you've already written. Every time you change your code,
%you are taking a chance that you create bugs by changing too little or too
%much. It is much better to know what you want to build before you build it.
Se você pular para a escrita do código antes, você poderá descobrir problemas
que exijam que você altere o código que você já escreveu. Cada vez que você
altera seu código, você tem chances de criar bugs por alterar muito pouco ou
demais. É muito melhor saber o que você quer construir antes de construir
efetivamente.