Merge pull request CryptozombiesHQ#29 from eduardonunesp/pt-translati…

…on-fixes

Many PT fixes

pt/1/00-overview.md

@@ -6,7 +6,7 @@ roadmap: roadmap.jpg
 
 Então, você acha que tem o que é preciso para se tornar um **CryptoZombie**, hein?
 
-Este curso irá ensiar você como **construir um jogo no Ethereum**
+Este curso irá ensinar você como **construir um jogo no Ethereum**
 
 É projetado para iniciantes em Solidity, mas presume que você tem alguma experiência
 em programação em outra linguagem (exemplo: Javascript)

pt/1/arrays.md

@@ -1,5 +1,5 @@
 ---
-title: Listas (Arrays)
+title: Listas
 actions: ['verificarResposta', 'dicas']
 material:
   editor:
@@ -39,14 +39,16 @@ material:
       }
 ---
 
-Quando você quer uma lista de algo, você pode usar um **_array_** (lista). Existem dois tipos de arrays (listas) em Solidity: **_fixed_** (fixo) array e **_dynamic_** (dinâmico) arrays:
+Quando você quer uma lista de algo, você pode usar um **_array_** (lista). Existem dois tipos de arrays (listas) em Solidity: **_fixed_** (fixo) arrays e **_dynamic_** (dinâmico) arrays:
 
 ```
 // Array com tamanho fixo de 2 elementos:
 uint[2] fixedArray;
-// outro Array fixo, pode conter 5 strings:
+
+// Outro array fixo, pode conter 5 strings:
 string[5] stringArray;
-// um Array dinâmico - não tem tamanho fixo, e pode continuar aumentando:
+
+// Um array dinâmico - não tem tamanho fixo, e pode continuar aumentando:
 uint[] dynamicArray;
 ```
 
@@ -71,9 +73,7 @@ Outros contracts poderão ler (mas não escrever) este array. Isso é um padrão
 
 # Vamos testar
 
-We're going to want to store an army of zombies in our app. And we're going to want to show off all our zombies to other apps, so we'll want it to be public.
-
-Nós queremos armazenar um exército de zumbis em nosso applicativo. E nós queremos mostrar todos os nossos zumbis para outros aplicativos, então nós queremos que seja público.
+Nós queremos armazenar um exército de zumbis em nosso aplicativo. E queremos mostrar todos os nossos zumbis para outros aplicativos, então queremos que seja público.
 
 
 1. Create a public array of `Zombie` **_structs_**, and name it `zombies`.

pt/1/arraysstructs2.md

@@ -1,5 +1,5 @@
 ---
-title: Trabalhando com Estruturas e Listas (Structs / Arrays)
+title: Trabalhando com Estruturas e Listas
 actions: ['verificarResposta', 'dicas']
 material:
   editor:
@@ -49,7 +49,7 @@ material:
 
 ### Criando novas Structs
 
-Você lembra da nossa `Person` struct no exemplo anterior?
+Você lembra da nossa estrutura `Person` no exemplo anterior?
 
 ```
 struct Person {
@@ -60,10 +60,10 @@ struct Person {
 Person[] public people;
 ```
 
-Agora nós vamos aprender como criar uma nova `Person` e adiciona-lá ao nosso `people` array.
+Agora nós vamos aprender como criar uma nova `Person` e adicioná-la ao nosso `people` array.
 
 ```
-// criar uma nova Person:
+// Criar uma nova Person:
 Person satoshi = Person(172, "Satoshi");
 
 // Adicionar a pessoa ao Array:
@@ -76,7 +76,7 @@ Nós também podemos combiná-los em uma única linha para ter um código limpo:
 people.push(Person(16, "Vitalik"));
 ```
 
-Perceba que o `array.push()` adiciona qualquer coisa no **fim** do array, então os elementos são adicionados em ordem conforme adicionamos. Veja o próximo exemplo:
+Perceba que o `array.push()` adiciona qualquer coisa no **fim** do array, então os elementos são adicionados em ordem conforme os adicionamos. Veja o próximo exemplo:
 
 ```
 uint[] numbers;
@@ -90,5 +90,5 @@ numbers.push(15);
 
 Vamos fazer a nossa função createZombie fazer algo!
 
-1. Preencha o corpo da função para cirar um novo `Zombie`, e adicione nossa array `zombies`. O `name` e `dna` para o Zombie deve vir nos argumentos da função.
+1. Preencha o corpo da função para criar um novo `Zombie`, e adicione nossa array `zombies`. O `name` e `dna` para o Zombie deve vir nos argumentos da função.
 2. Vamos fazer isso em uma linha para manter o código claro.

pt/1/contracts.md

@@ -1,13 +1,13 @@
 ---
-title: "Contratos (Contracts)"
+title: Contratos
 actions: ['verificarResposta', 'dicas']
 material: 
   editor:
     language: sol
     startingCode: |
       pragma solidity //1. Enter solidity version here
 
-      //2. Crie seu contract aqui
+      // 2. Crie seu contract aqui
     answer: > 
       pragma solidity ^0.4.19;
 
@@ -19,9 +19,9 @@ material:
 
 Começando pelo básico do básico:
 
-O código em Solidity é encapsulado em **contracts**. Um `contract` é um bloco de construção fundamental para aplicações em Ethereum — todas as variáveis e funções pertencem a um contract, e este será o ponto de início de todos os seus projetos.
+O código em Solidity é encapsulado em **contratos**. Um `contract` (contrato) é um bloco de construção fundamental para aplicações em Ethereum — todas as variáveis e funções pertencem a um `contract`, e este será o ponto inicial de todos os seus projetos.
 
-Um contract vazio com o nome `HelloWorld` seria assim:
+Um `contract` vazio com o nome `HelloWorld` seria assim:
 
 ```
 contract HelloWorld {
@@ -31,11 +31,11 @@ contract HelloWorld {
 
 ## Versão Pragma
 
-Todo código fonte em solidity deve começar com um "version pragma" - uma declaração da versão do compilador Solidity que deve ser usado. Isso é para evitar problemas com um futuras versões do compilador, potencialmente apresentando mudanças que quebrariam seu código.
+Todo código fonte em Solidity deve começar com um "version pragma" - uma declaração da versão do compilador Solidity que deve ser usado. Isto é para evitar problemas com futuras versões do compilador, potencialmente apresentando mudanças que possam quebrar o seu código.
 
-Irá ficar assim: `pragma solidity ^0.4.19;` (para a última versão do solidity no momento que foi escrito, 0.4.19).
+Irá ficar assim: `pragma solidity ^0.4.19;` (para a última versão do Solidity no momento que essa lição foi escrita, 0.4.19).
 
-Juntando tudo, a versão mais simples para começar um contract - a primeira coisa que você vai escrever toda vez que começar um novo projeto.
+Juntando tudo, a versão mais simples para começar um `contract` - aqui vai a primeira coisa que você vai escrever toda vez que começar um novo projeto.
 
 ```
 pragma solidity ^0.4.19;
@@ -47,10 +47,10 @@ contract HelloWorld {
 
 # Vamos testar
 
-Para começar nosso exército Zombie, vamos criar um contrato base chamado `ZombieFactory`.
+Para começar o nosso exército Zumbi, vamos criar um contrato base chamado `ZombieFactory`.
 
-1. Na caixa a direita, crie o nosso contract usando a versão de solidity `0.4.19`.
+1. Na caixa a direita, crie o nosso `contract` usando a versão do Solidity `0.4.19`.
 
-2. Crie um contrato vazio chamado `ZombieFactory`.
+2. Crie um `contract` vazio chamado `ZombieFactory`.
 
-Quando você terminar, clique em "verificar resposta" abaixo. Se você ficar "bloqueado", você pode clicar em "dicas".
+Quando você terminar, clique em "Verificar Resposta" abaixo. Se você não souber como progredir, você pode clicar em "Dicas".

pt/1/datatypes.md

@@ -1,5 +1,5 @@
 ---
-title: Variáveis de Estado & Inteiros (State Variables & Integers)
+title: Variáveis de Estado & Inteiros
 actions: ['verificarResposta', 'dicas']
 material:
   editor:
@@ -9,7 +9,7 @@ material:
 
       contract ZombieFactory {
 
-          //comece aqui
+          // comece aqui
 
       }
     answer: >
@@ -23,9 +23,9 @@ material:
       }
 ---
 
-Bom trabalho! Agora que nós temos a casca para os nossos contratos, vamos aprender sobre como trabalhar com variáveis em Solidity.
+Bom trabalho! Agora que temos a casca para os nossos contratos, vamos aprender sobre como trabalhar com variáveis em Solidity.
 
-**_State variables_** (Variáveis de estado) são permanentemente gravadas no storage do contrato. Isso signífica que são escritas na blockchain do Ethereum. Pense nelas como escrever em um banco de dados.
+**_Variáveis de Estado_** são permanentemente gravadas no armazenamento do contrato. Isso quer dizer que são escritas na blockchain do Ethereum. Pense nelas como escrever em um banco de dados.
 
 ##### Exemplo:
 ```
@@ -35,16 +35,16 @@ contract Example {
 }
 ```
 
-Neste exemplo de contract, nos criamos uma variável `uint` chamada `myUnsignedInteger` e determinamos o valor igual a 100.
+Neste exemplo de contrato, nós criamos uma variável `uint` chamada `myUnsignedInteger` e determinamos o valor igual a 100.
 
-## Inteiros sem sinal: `uint`
+## Inteiros Sem Sinal: `uint`
 
-O tipo de dado `uint` é um inteiro sem sinal, isso significa que **que este valor não pode ser negativo**. Também há um tipo de dado `int` para inteiros com sinal de negativo.
+O tipo de dado `uint` é um número inteiro sem sinal, isso significa que **este valor não pode ser negativo**. Também há um tipo de dado `int` para números inteiros com sinal de negativo.
 
-> Nota: Em Solidity, `uint` é na verdade um apelido para o tipo `uint256`, um inteiro sem sinal de 256-bits. Você pode declarar uints com menos bits - `uint8`, `uint16`, `uint32`, etc.. Mas em geral você pode simplesmente usar `uint` exeto em casos específicos, algo que vamos falar mais tarde.
+> Nota: Em Solidity, `uint` é na verdade um apelido para o tipo `uint256`, um número inteiro sem sinal de 256-bits. Você pode declarar uints com menos bits - `uint8`, `uint16`, `uint32`, etc.. Mas em geral você quer simplesmente usar `uint` exceto em casos específicos, algo de que iremos falar mais tarde.
 
 # Vamos testar
 
-Nosso DNA Zumbi vai ser deteterminado por um número 16-dígitos.
+Nosso DNA Zumbi vai ser determinado por um número de 16-dígitos.
 
-Declare um `uint` chamado `dnaDigits`, e defina-o igual a `16`.
+Declare um `uint` chamado `dnaDigits`, e atribua-lhe o valor `16`.

pt/1/events.md

@@ -1,5 +1,5 @@
 ---
-title: Eventos (Events)
+title: Eventos
 actions: ['verificarResposta', 'dicas']
 material:
   editor:
@@ -9,7 +9,7 @@ material:
 
       contract ZombieFactory {
 
-          // declare nosso evento aqui
+          // declare o nosso evento aqui
 
           uint dnaDigits = 16;
           uint dnaModulus = 10 ** dnaDigits;
@@ -73,38 +73,38 @@ material:
       }
 ---
 
-Nosso contract esta quase terminado! Agora vamos adicionar um **_event_** (evento)
+Nosso contrato esta quase terminado! Agora vamos adicionar um **_evento_**.
 
-**_Events_** (Eventos) são as maneiras dos seus contratos comunicarem que algo aconteceu na blockchain para o seu aplicativo em um front-end, que pode `ouvir` por certos tipos de eventos e tomar ações quando algo acontecer.
+**_Eventos_** são as maneiras dos seus contratos comunicarem que algo aconteceu na blockchain para o seu aplicativo em um frontend, que pode `ouvir` por certos tipos de eventos e tomar ações quando algo acontecer.
 
 Exemplo:
 
 ```
-// declarando o evento
+// Declarando o evento
 event IntegersAdded(uint x, uint y, uint result);
 
 function add(uint _x, uint _y) public {
   uint result = _x + _y;
-  // dispare um evento e deixe o aplicativo saber que a função foi chamada:
+  // Dispare um evento e deixe o aplicativo saber que a função foi chamada:
   IntegersAdded(_x, _y, result);
   return result;
 }
 ```
 
-O seu aplicativo front-end poderá então ouvir o evento. Uma implementação em Javascript firaria assim:
+O seu aplicativo frontend poderá então ouvir o evento. Uma implementação em Javascript ficaria assim:
 
 ```
 YourContract.IntegersAdded(function(error, result) {
-  // faça algo com o resultado
+  // Faça algo com o resultado
 }
 ```
 
 # Vamos testar
 
-Nos queremos um evento que avise o front-end toda vez que um novo zumbi for criado, então o aplicativo pode mostrá-lo.
+Queremos um evento que avise o frontend toda vez que um novo zumbi for criado, então o aplicativo pode mostrá-lo.
 
-1. Declare um `event` chamado `NewZombie`. Deve passar os parâmetros `zombieID` (um `uint`), `name` (uma `string`), e `dna` (um `uint`).
+1. Declare um `event` chamado `NewZombie`. Este deve passar os parâmetros `zombieID` (um `uint`), `name` (uma `string`), e `dna` (um `uint`).
 
-2. Modifique a função `_createZombie` para disparar o evento `NewZombie` após adicionar o novo Zombie em nosso array `zombies`
+2. Modifique a função `_createZombie` para disparar o evento `NewZombie` após adicionar o novo Zumbi em nosso array `zombies`
 
 3. Você vai precisar do `id` do zumbi. O `array.push()` retorna um `uint` com o novo tamanho do array - e desde que o primeiro item no array tem o index 0, `array.push() - 1` vai ser o index do zumbi que acabamos de adicionar. Guarde o resultado do `zombies.push() -1` em um `uint` chamado `id`, então você pode usá-lo no evento `NewZombie` na próxima linha.

pt/1/functions.md

@@ -45,7 +45,7 @@ material:
       }
 ---
 
-Uma declaração de função em solidity parece o seguinte:
+Uma declaração de função em Solidity parece o seguinte:
 
 ```
 function eatHamburgers(string _name, uint _amount) {
@@ -67,6 +67,6 @@ eatHamburgers("vitalik", 100);
 
 Em nossa aplicação, nós vamos precisar criar alguns zumbis. Vamos criar a função para isso:
 
-1. Crie uma função chamada `createZombie`. Tal deve receber dois argumentos: **__name_** (uma `string`), e **__data_** (uma `uint`).
+1. Crie uma função chamada `createZombie`. Esta deve receber dois argumentos: **__name_** (uma `string`), e **__data_** (uma `uint`).
 
 Deixe o corpo da função vazia por enquanto - nós vamos preenchê-lo mais tarde.

pt/1/functions2.md

@@ -1,5 +1,5 @@
 ---
-title: Funções Privadas / Públicas (Private / Public)
+title: Funções Privadas / Públicas
 actions: ['verificarResposta', 'dicas']
 material:
   editor:
@@ -47,9 +47,9 @@ material:
       }
 ---
 
-Em Solidity, funções são `public` (públicas) por padrão. Isso significa que qualquer um (ou qualquer outro contrato) pode chamar a função em seu contrato e executar seu código.
+Em Solidity, funções são públicas por padrão. Isso significa que qualquer um (ou qualquer outro contrato) pode chamar a função em seu contrato e executar seu código.
 
-Obviamente que isso nem sempre é o desejado, e pode tornar o seu contrato vulnerável a ataques. Sendo assim é uma boa prática marcar as suas funções como `private` (privada) por padrão, e somente marcar como `public` (pública) as funções que você quer expor para o mundo.
+Obviamente que isso nem sempre é o desejado, e pode tornar o seu contrato vulnerável a ataques. Sendo assim é uma boa prática marcar as suas funções com a palavra reservada `private` (privada) por padrão, e somente marcar com a palavra reservada `public` (pública) as funções que você quer expor para o mundo.
 
 Vejamos como declarar uma função privada:
 
@@ -61,9 +61,9 @@ function _addToArray(uint _number) private {
 }
 ```
 
-Isso singnifica que somente as funções em nosso próprio contrato podem chamar a função e adicionar ao array `numbers`.
+Isso quer dizer que somente as funções em nosso próprio contrato podem chamar a função e adicionar ao array `numbers`.
 
-Como você pode ver, nós usarmos a palavra reservada `private` após o nome da função. E assim como os parâmetros da função, a convenção é começar os nomes das funções privadas com sublinhando (`_`).
+Como você pode ver, usarmos a palavra reservada `private` após o nome da função. E assim como os parâmetros da função, a convenção é começar os nomes das funções privadas com sublinhado (`_`).
 
 # Vamos testar
 

pt/1/functions3.md

@@ -53,11 +53,11 @@ material:
       }
 ---
 
-Neste capítulo nós vamos aprender sobre funções que **_retornam valores_**, e sobre modificadores de funções.
+Neste capítulo vamos aprender sobre funções que **_retornam valores_**, e sobre modificadores de funções.
 
-## Retornar valores
+## Retornando Valores
 
-Para retornar um valor de uma função, a declaração deve ser assim:
+Para retornar o valor de uma função, a declaração deve ser assim:
 
 ```
 string greeting = "Olá cachorro!";
@@ -69,27 +69,27 @@ function sayHello() public returns (string) {
 
 Em Solidity, a declaração da função contém o tipo do valor de retorno (neste caso uma `string`).
 
-## Modificadores de funções
+## Modificadores das Funções
 
-Na verdade a função acima não altera algum estado em Solidity - em outras palavras não altera qualquer valor ou escrever qualquer coisa.
+Na verdade a função acima não altera estado algum em Solidity - em outras palavras não altera qualquer valor ou escreve qualquer coisa.
 
-Neste caso nós podemos declará-la como uma função **_view_** (observa), que significa: somente uma observação do dado, mas nenhuma alteração de fato.
+Neste caso nós podemos declará-la como uma função com palavra reservada `view` (observa), que significa: somente uma observação do dado, mas nenhuma alteração de fato.
 
 ```
 function sayHello() public view returns (string) {
 ```
 
-Em Solidity também existem funções **_pure_** (pura), que significa que nenhum dado será acessado na aplicação. Pense na seguinte situação:
+Em Solidity também existem funções **puras** usando a palavra reservada `pure`, que significa que nenhum dado será acessado na aplicação. Pense na seguinte situação:
 
 ```
 function _multiply(uint a, uint b) private pure returns (uint) {
   return a * b;
 }
 ```
 
-Esta função nem mesmo lê um estado da aplicação - os seus valores retornados dependem somente dos parâmetros da função. Então neste caso nós podemos declarar a função como **_pure_** (pura).
+Esta função nem mesmo lê um estado da aplicação - os seus valores retornados dependem somente dos parâmetros da função. Então neste caso nós podemos declarar a função como **_pura_** usando a palavra reservada `pure`.
 
-> Nota: Pode ser complicado de lembrar quando marcar a função como pure/view (pura/observação). Para nossa sorte o compilador de Solidity faz um bom trabalho em nos avisar quando devemos usar algum desses modificadores.
+> Nota: Pode ser um tanto quanto complicado lembrar quando marcar a função como pura/observação (pure/view). Para a nossa sorte o compilador de Solidity faz um bom trabalho em avisar-nos quando devemos usar algum desses modificadores.
 
 # Vamos testar
 
@@ -99,4 +99,4 @@ Nós vamos precisar de uma função de ajuda para gerar números de DNA aleatór
 
 2. Esta função irá observar algumas das nossas variáveis no contrato, mas não irá modificá-las, então marque as mesmas como `view`.
 
-3. O corpo da função deve ficar vázio por enquanto - nós vamos trabalhar em isto mais tarde.
+3. O corpo da função deve ficar vazio por enquanto - iremos trabalhar nisto mais tarde.