Módulo 02 LPG3

PROGRAMAÇÃO PARA GAMES II Módulo II
Prof. Marcio /
Menezes
LINGUAGEM DE
PROGRAMAÇÃO 2
VOLUME 2
2022
COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

CURSO TÉCNICO DE PROGRAMAÇÃO DE JOGOS DIGITAIS - FAETEC Maio-2023 1
Prof. Marcio /
Menezes
Sumário
INTRODUÇÃO .................................................................................................................................................. 4
CAPÍTULO 1 ..................................................................................................................................................... 4
1.1 Movimentando o fundo da tela. ........................................................................................................... 4
1.2 Passando de uma cena para outra. ..................................................................................................... 8
1.3 Passando parâmetros entre cenas usando PlayerPrefs. ................................................................ 10
1.4 Passando parâmetro entre cenas com variável Static. ................................................................... 12
1.4.1 Classes Estáticas – Static Class ................................................................................................ 13
1.4.2 Membros estáticos de uma classe C# (Static Members) ......................................................... 14
Capítulo 2 – Manipulação de arquivos para Windows. .............................................................................. 15
2.1 Arquivos do tipo texto para Windows ............................................................................................... 15
2.2 Inserindo registro de dados em arquivo padrão ASCII ................................................................... 17
2.2.1 Tela principal. ............................................................................................................................... 17
2.2.2 Script vinculado ao canvas......................................................................................................... 17
2.2.3 Comentários sobre alguns comandos do código. ................................................................... 18
2.2.4 Cálculo automático do valor pago. ............................................................................................ 19
2.2.5 Efetuando a leitura dos dados ................................................................................................... 19
Capítulo 3 – Compilação para Android. ...................................................................................................... 24
3.1 Instalando o SDK ................................................................................................................................. 24
3.2 Instalando o JDK ................................................................................................................................. 27
3.3 Configurando o Build Settings .......................................................................................................... 29
Capítulo 4 – Operações com Imagens......................................................................................................... 31
4.1 Fatiar uma imagem em partes iguais. ............................................................................................... 31
Capítulo 5 – Crazzy Ball ................................................................................................................................ 33
5.1 – Criando o cenário principal. ............................................................................................................ 34
CAPÍTULO 6 – Pirâmide Algébrica............................................................................................................... 35
6.1 – Montando o cenário ......................................................................................................................... 35
CAPÍTULO 7 – Vetores Unidimensionais .................................................................................................... 36
7.1 Algoritmo de ordenação crescente. .................................................................................................. 36
7.2 Ordenar nomes. ................................................................................................................................... 36
7.3 Script .................................................................................................................................................... 37
7.4 Criando um Hanking ........................................................................................................................... 39
7.4.1 Definindo o cenário. .................................................................................................................... 39
7.4.2 – Criando minha biblioteca de classes...................................................................................... 39
7.4.3 – Criando o script principal. ....................................................................................................... 40
Capitulo 8 – Passagem de parâmetro entre Scripts .................................................................................. 43
8.1 – Capturando o objeto da cena anterior ........................................................................................... 43
Prof. Marcio /
Menezes
8.2 – ArrayList dentro de uma class static ............................................................................................ 44

8.3 - Utilizando o Game Manager ............................................................................................................. 45
Capítulo 9 – Criando um jogo em 3D. .......................................................................................................... 47
9.1 Importando a imagem FBX. ................................................................................................................ 47
9.2 Iluminando e redimensionando o modelo. ............................................................................... 49
9.3 Criando o Player. ................................................................................................................................. 49
9.4 Criando a colisão. ............................................................................................................................... 50
9.5 Criando o personagem em primeira pessoa. ................................................................................... 50
9.6. Script do Player .................................................................................................................................. 50
9.7 Criando o script da câmera. ............................................................................................................... 52
9.8 Criando a malha de navegação. ........................................................................................................ 53
Capitulo 10 -Acertando um alvo com RayCasting ..................................................................................... 56
10.1 - Física .Raycast ................................................................................................................................ 56
Parâmetros ............................................................................................................................................. 56
Devoluções ............................................................................................................................................. 56
Descrição ................................................................................................................................................ 56
10.2 Perseguindo o inimigo...................................................................................................................... 58
MoveTowards ......................................................................................................................................... 58
MovePosition .......................................................................................................................................... 59
LookAt ..................................................................................................................................................... 60
IA – Arquivo Plataforma.cs....................................................................................................................... 61
IB – Arquivo Spaw.cs ................................................................................................................................ 61
IC – Arquivo Player.cs .............................................................................................................................. 62
ID – Arquivo Resultado.cs ........................................................................................................................ 64

Prof. Marcio /
Menezes
INTRODUÇÃO
Na apostila “Programação para Games I” nosso objetivo foi desenvolver um jogo e plataforma
atingindo aproximadamente 80% daquilo que poderíamos dizer o mínimo para o produto em condições de
comercialização, trazendo efeitos sonoros e visuais. Nesta segunda etapa apresentaremos no primeiro
capítulo algumas técnicas de programação para auxiliar em jogos de plataforma e de tabuleiro.
CAPÍTULO 1
Operações relacionadas ao cenário.
1.1 Movimentando o fundo da tela.

Acrescente um objeto 3d Quad na sua cena.
Coloque a resolução da sua tela para 16:9, em seguida ajuste “quad” para o tamanho total da mesma.
Resete as posições do quad em 0,0,0.

Prof. Marcio /
Menezes
Crie um material de nome background na pasta material.
Selecione o material criado e mova a textura para a propriedade Albedo.
Na propriedade Shader altere para Unlit e Texture.

Prof. Marcio /
Menezes
Agora arraste o material para a nossa cena.
Selecione a figura que está na pasta sprite e mude a propriedade Wrap Mode para Repeat.

Prof. Marcio /
Menezes
Agora crie um script de nome BackGroundScrooling e insira o seguinte código.
Arraste o script para o componente Quad.

Prof. Marcio /
Menezes
Arraste para dentro de MR o componente Quad e coloque Speed como 0.5.
1.2 Passando de uma cena para outra.

Crie as pastas tradicionais abaixo da Assets.
Na pasta Scene crie três cenário, conforme abaixo.
Em Edit / Building Setting mova os cenários na ordem desejada. Considere a posição 0 de cima para
baixo.

Prof. Marcio /
Menezes
Na pasta Script crie um código com as instruções abaixo:
Arraste esse código para o Canvas.

Prof. Marcio /
Menezes
O script deve ser adicionado a todas os canvas de todos os cenários.

Agora nos botões adicione ao evento OnClick o canvas e aponte a função desejada em todos eles .
1.3 Passando parâmetros entre cenas usando PlayerPrefs.

Vamos criar dois cenários conforme figura abaixo.
Cenário Principal
Prof. Marcio /
Menezes
Cenário Secundário
Crie um script para o cenário principal. Configure a chamada do projeto conforme o item 1.2. Altere a
propriedade Content type da senha para password
Inclua as bibliotecas das linhas 4

e 5.
Na Unity, mova os dois Text dos

Input Fields para estas variáveis.
Vincule ao evento OnClick do

botão.
O comando PlayerPrefs é uma classe que armazena as preferências do jogador entre as sessões
do jogo. Ele pode armazenar valores de string, float e integer no registro da plataforma do usuário.
O Unity armazena dados `PlayerPrefs` de forma diferente com base em qual sistema operacional
o aplicativo é executado. Nos caminhos de arquivo fornecidos nesta página, o nome da empresa e o
nome do produto são os nomes que você definiu nas Configurações do Player do Unity.
No cenário Secundário crie um script conforme abaixo.

Prof. Marcio /
Menezes
Linhas 5 e 6 são incluídas. Nas linhas 9 e 10 mova na Unity os Text’s de leitura.
1.4 Passando parâmetro entre cenas com variável Static.

É possível utilizar uma classe estática para a persistência dos dados ao longo das cenas. Você
pode declarar uma classe UserData, por exemplo, e utilizar propriedades estáticas para armazenar estes
dados, por exemplo:
Não é necessário herdar MonoBehaviour nesse caso, nem anexar o script a um objeto (aliás não
herdando MonoBehaviour nem será possível anexá-lo).
Desta forma, na Cena1 provavelmente você já tenha um script com um método que será
executado ao clicar do botão que realiza a troca para a Cena2. Antes de realizar o carregamento da
Cena2 você pode armazenar suas informações, por exemplo:
Neste caso o arquivo da classe UserData.cs deve estar na mesma pasta do arquivo que utiliza as
variáveis.

Prof. Marcio /
Menezes
Na figura abaixo apresentamos o fluxo de informações.
Cena 1 Cena 2
Script CenaSample Script Scene2
Class MyData
Na cena 1 temos um objeto Text, um InputField e um Button. O script CenaSample está vinculado
ao canvas. O InputField está vinculado a variável Usuario.
Na cena 2 temos um objeto Text e um Button. O script Scene2 está vinculado ao canvas. O Text
está vinculado a variável Usuario.
1.4.1 Classes Estáticas – Static Class

Uma classe estática é basicamente igual a uma classe não-estática. Porém uma classe estática não
pode ser instanciada. Isto quer dizer que não podemos utilizar a palavra-chave new para criá-la.
Prof. Marcio /
Menezes
Por este motivo, você pode acessar os membros de uma classe estática apenas usando o nome da
classe.
Por exemplo, vamos supor que criamos uma classe chamada Utilitarios. E ela possui um método
público chamado CalculaAlgo. Você pode chamar este método assim:
Utilitarios.CalculaAlgo();
Mas pra que serve isso? Pra que vou usar uma classe estática?
Podemos utilizar uma classe estática como um repositório de métodos que manipulam apenas
parâmetros de entrada e não precisa ler (get) ou escrever (set) nenhum campo interno.
1.4.2 Membros estáticos de uma classe C# (Static Members)

As variáveis estáticas são usadas para definir constantes porque seus valores
podem ser recuperados invocando a classe sem criar uma instância. As variáveis
estáticas podem ser inicializadas fora da função do membro ou da definição da classe.
https://celsokitamura.com.br/objetos-estaticos/
Foi a técnica usada no item 1.4 para passar o valor de uma variável de uma cena para outra.

Prof. Marcio /
Menezes
Capítulo 2 – Manipulação de arquivos para Windows.

Neste capítulo trabalharemos a inserção de registro em arquivos do tipo ASCII, também conhecido
como arquivos do tipo texto. Este tipo de arquivo será útil para armazenamento de informações para análise
posterior, ou ainda textos aleatórios.
O programa a ser desenvolvido apresenta um objeto do tipo InputField e três Button’s. A cada botão
temos um método em apenas um script.
2.1 Arquivos do tipo texto para Windows
O cenário e a estrutura de pastas obedece a figura abaixo:
O script é extremamente simples.
Crie um aquivo cs de CriarArquivo

Prof. Marcio /
Menezes
https://www.youtube.com/watch?v=rsvkkY3RXSQ

Prof. Marcio /
Menezes
2.2 Inserindo registro de dados em arquivo padrão ASCII
Neste programa iremos inserir um registro de dados em arquivo do tipo texto. O exemplo que iremos
utilizar tem um objetivo didático, para que o aluno perceba que a lógica aplicada em parte de programas
administrativos, também pode ser utilizado em game. Um bom exemplo de estatísticas mensais, melhores
resultados ou até mesmo hanking dos jogadores (item 7.4 Criando um Hanking).
O problema consiste em desenvolver um app que controle as despesas de um veículo e armazene
um arquivo do tipo texto. Dessa forma vamos imaginar que o dono do carro deseja apenas controlar quanto
gasta por mês de combustível, e que seu veículo não é híbrido.
Ao chegar no posto de gasolina, encontra as seguintes informações que ele deve registrar no
programa: Preço por unidade de medida do combustível (litro ou
m3); quantidade de unidades abastecidas (litro ou m3) e valor da
unidade monetária vigente. Para auxiliar nos registros de saída
ele precisa registrar também o valor do odômetro do veículo.
Para saída de informações o programa de apresentar
um relatório mensal que informe o total de km percorridos, o valor
gasto com o abastecimento a média km / unidade de medida do
combustível e a média do preço por unidade de medida do
combustível.
2.2.1 Tela principal.

Insira um Image e coloque um arquivo PNG com fundo e os seguintes componentes.
Todos os campos são objetos TextField. Aos botões foram adicionadas imagens.
2.2.2 Script vinculado ao canvas.

A classe GravandoRegistro possui dois métodos. O primeiro de gravação, retira os dados da
tela e grava em um arquivo de nome CarDiary.txt, conservando os dados que lá estão. O segundo apenas
limpa a tela.

Prof. Marcio /
Menezes
2.2.3 Comentários sobre alguns comandos do código.

File.Exists: Determina se o arquivo especificado existe. Pode ser incluído o caminho completo a partir
da pasta corrente. Os sub caminhos devem conter os caracteres “//” para identificar que não se trata de um
comando.
No exercício utilizamos uma variável do tipo string:
File.WriteAllText: Cria um novo arquivo, grava em arquivo do tipo texto no caminho especificado e
fecha o arquivo. Se o arquivo de destino já existir, ele será substituído.
File.ReadAllText: Abre um arquivo binário, lê o conteúdo do arquivo retornando um string e fecha o

arquivo.
Por isso o código criado para caso dele encontrar o arquivo “CarDiary.txt” primeiro lê o seu conteúdo,
depois acrescenta o registro atual, em seguida grava novamente.
Prof. Marcio /
Menezes
2.2.4 Cálculo automático do valor pago.

Vamos realizar o cálculo automático do valor total da nota quando saímos do campo de valor unitário.
Primeiro vamos criar o método entre a linha 31 e 32 da figura acima.
Para que este método seja executa precisamos ativar o evento On End Edit (ao terminar a edição) no campo
InputField de nome IF_PrecoUnitario conforme sequência abaixo.
2.2.5 Efetuando a leitura dos dados

Os cálculos solicitados são vários iniciaremos com a soma do valor pago mensalmente.

Prof. Marcio /
Menezes

Prof. Marcio /
Menezes

Prof. Marcio /
Menezes

Prof. Marcio /
Menezes

Prof. Marcio /
Menezes
Capítulo 3 – Compilação para Android.

Neste capítulo iremos configurar o Unity para compilar o seu projeto no Android.
3.1 Instalando o SDK

SDK é a sigla para Software Development Kit, ou kit de desenvolvimento de software. Um SDK são
ferramentas fornecidas pelo fabricante de uma plataforma de hardware, sistema operacional ou linguagem de
programação.
Para a instalação do SDK, utilize o Android Studio da Google. Vá na opção Edit > Preference e na
caixa de diálogo clicar em Download da opção
SDK. Ferramentas. Se a opção Android não
estiver ativa, faça o download através da opção
File / Building Setting opção Android, clicando
no botão Open Download Page. Vá na pasta de
downloads do seu computador e execute o
arquivo UnitySetup-Android-Support-for-
Editor-2017.4.15f1.exe Na instalação observe se
a pasta do Unity que ele detectou é a mesma que
foi instalado no seu equipamento.
Feche o Unity e abra novamente para
que ele possa reconhecer a opção acima.
Uma vez na página de download do
Android Studio, baixe a última versão e proceda
a instalação. Isso poderá demora um pouco,
dependendo da configuração do seu
equipamento.
No meu caso instalei o android-studio-
2021.1.1.23-windows.exe com 872 MB.
Após instalar o Android Studio abra um projeto novo e acione o ícone SDK Manager, conforme figura
abaixo.

Prof. Marcio /
Menezes
Na tela de instalação dos componentes do SDK, marque as opções acima do Android 6.0, no mínimo.
Nas aba SDK Tools marque as opções abaixo.
Mova a barra de rolagem e marque as opções a seguir.

Prof. Marcio /
Menezes
Na aba SDK Update sites deixe todas as opções marcadas.
Clicar em OK e aguardar toda a instalação. Depois de tudo instalada copie o endereço onde foi
instalado o SDK e coloque no Unity na opção Edit / Preferences

Prof. Marcio /
Menezes
3.2 Instalando o JDK

É um pacote de software que você pode usar para desenvolver aplicativos baseados em Java.
O Java Runtime Environment é um plug-in necessário para a execução de programas Java.
O Java Development Kit é necessário para desenvolver aplicativos java.
Vá em Edit / Preferences e clique no botão Download da opção JDK.

Prof. Marcio /
Menezes
Ela te conduzirá para a página da Oracle.
Baixe a versão similar a jdk_1.8.xxxx para trabalhar com Unity 2017.4.15f1. Durante o processo de
instalação copie o local de que está o JDK.

Prof. Marcio /
Menezes
Retorne ao Unity em Edit/ Preferences e cole o caminho do JDK.
3.3 Configurando o Build Settings

Se você executou corretamente os itens 3.1 e 3.2, acione o File / Build Settings.. para configurar o
Player Settings.
Na palheta Inspector defina o Company Name e o Product Name.

Prof. Marcio /
Menezes
Em Identification defina o Package name com “com.” seguido do nome da empresa mais “.” e nome
do produto. Esta será a identificação na play store da google. Segue abaixo um exemplo de acesso.
https://play.google.com/store/apps/details?id=com.companypersonal.companypersonal
Abra agora a opção Other Settings. Em Version coloque 1.0 ou atualize caso considere que houve
mudança significativa.
Para Bundle Version Code comece com 1. Mas a cada
atualização da mesma versão altere este valor para a google
aceitar a alteração.
Em Minimum API Level aponte para o Android 4.1 “Jelly
Been” (API level 16).
Para Target API Level configure como Automatic.
Em Pulblishing Setting, clicar em Browse Keystore e defina o arquivo de chave para sua aplicação.

Prof. Marcio /
Menezes
Digite a sua senha e confirma a mesma.
Clicar em Key / Alias e preencha o

quadro acima para identificação da sua chave.
Coloque a validade para 50 anos no mínimo.
Em Build System configure para
Internal.
Para encerrar, compile o seu projeto.
Capítulo 4 – Operações com Imagens.

Neste capítulo iremos tratar de operações com arquivos de imagem.
4.1 Fatiar uma imagem em partes iguais.

Selecione a imagem no palheta Projetct. Na palheta Inspector altere Sprite Mode para Multiple.

Prof. Marcio /
Menezes
Em seguida no Applye e depois no botão Sprite Editor.
Após definir X e Y, observar que as imagens ficaram corretamente divididas, clicar no botão Apply
conforme a tela a seguir.
Se as operações foram realizadas corretamente, ao clicar na seta para a direita da apulheta, dentro
da pasta Sprites, todas as imagens aparecerão fatiadas.

Prof. Marcio /
Menezes
Capítulo 5 – Crazzy Ball

Neste capítulo iremos desenvolver um game que consiste em manter a bola através dos cliques no
cenário como o mouse para a versão Windows, ou com os toques na tela para versão Android, conforme
figura abaixo.
A plataforma em formato de retângulo se movimenta da esquerda para direita. Outras plataformas

aparecem em intervalos de 2 segundos, em posições aleatórias na lateral esquerda da tela se deslocando
para direita.
A bola irá cair e através de toques na tela a mesma toma impulso se mantendo dentro dos limites do
cenário. Manter a bola em equilíbrio não consiste em dar infinitos toques, pois o impulso poderá ocorrer para
direita ou esquerda. A cada toque da bola na plataforma o jogador terá 20 pontos de crédito que ficará indicado
no placar no canto superior direito e a plataforma será destruída imediatamente.
Durante a partida teremos um efeito sonoro em background para harmonizar o evento.
O jogo se encerra quando o jogador não conseguir mantê-la em dentro dos limites do cenário e a
mesma cai, não sendo possível o seu resgate. Dessa forma será apresentada a cena da figura abaixo.
Um cenário simples com efeito sonoro de baixo impacto, mostrando a pontuação adquirida. Com um
toque na tela, o jogo será reinciado.

Prof. Marcio /
Menezes
5.1 – Criando o cenário principal.

Crie as pastas conforme figura ao lado abaixo de Assets. Selecione na palheta Project a pasta
Assets e com o botão direito do mouse use Create >> Folder. Salve o cenário com Ctrl+S na pasta Scenes
de nome Main.
Modelo para
Armazena
Arquivo de Scripts
Arquivo de som (wav)
Imagens utilizados
para confecção do
cenário.
5.2 Script

Prof. Marcio /
Menezes
CAPÍTULO 6 – Pirâmide Algébrica

Consite....
6.1 – Montando o cenário.

C

Prof. Marcio /
Menezes
CAPÍTULO 7 – Vetores Unidimensionais

Neste capítulo iremos trabalhar com vetores, também chamados de “array” ou matrizes. Assim
Vetores e Matrizes são estruturas de dados muito simples que podem nos ajudar quando temos muitas
variáveis do mesmo tipo em um algoritmo. Imagine o seguinte problema: Você precisa criar um algoritmo que
lê o nome e as 4 notas de 50 alunos, calcular a média de cada aluno e informar quais foram aprovados e
quais foram reprovados.
Para aproveitarmos a exemplificar vetor ou matriz, vamos apresentar o algoritmo de ordenação.
Algoritmo este que todo programador deve utilizar para suas aplicações ao longo de sua vida profissional
7.1 Algoritmo de ordenação crescente.

Há dois métodos de ordenação. Ambos com característica semelhantes, comparam cada elemento
com o restante da lista e o coloca na posição correta. Este utiliza dois laços de repetição Para, fazendo a
comparação iniciando do primeiro elemento até o penúltimo, comparando com o imediatamente seguinte até
o último elemento:
Algoritmo Bubble_Sort
Var numeros : matriz [1..50] de inteiros
aux, i, j: inteiro
Para i de 1 até 49 faça {
Para j de i + 1 até 50 faça I {
Se numeros[i] > numeros[j]
Então {
aux := numeros[i];
numeros[i] := numeros[j];
numeros[j] := aux;
}
}
}
Fim Algoritmo
7.2 Ordenar nomes.

Vamos criar uma aplicação que peça quatro nomes e os coloque em ordem crescente ou decrescente
conforme tela abaixo.

Prof. Marcio /
Menezes
7.3 Script

Prof. Marcio /
Menezes

Prof. Marcio /
Menezes
7.4 Criando um Hanking

Nesta seção iremos criar um hanking que poderá ser adaptado ao game Crazzy Ball do capítulo 5,
ou na seção 7.1, Bolha de Ordenação. Neste exemplo seguiremos a lógica a seguir:
7.4.1 Definindo o cenário.

Um cenário de nome SampleScene conforme figura abaixo.
Na tabela abaixo segue alguns atributos dos componentes de tela .

Name Tipo Atributo Obs.
Podium Image Redimensionar conforme desejar. Colocar na pasta Sprite
TX_EXPLAIN Text Text: 7.4 Criando.... Módulo 2; Size: 30
TX_TITLE Text Text: Digite um.... do ranking; Size: 30
TX_POSICAO1 Text Text: 1º Lugar ...; Size: 20 Vincular a variável PT1.
TX_NOME1 Text Text: -------------- ; Size: 20 Vincular a variável NM1.
IF_PONTO InputField PlaceHolder: Digite um novo valor....; Size 25 Vincular a variável PT5.
IF_NOME InputField PlaceHolder: Digite um novo valor....; Size 25 Vincular a variável NM5.
BT_ORDENAR Button Text: Classificar; Size 25
7.4.2 – Criando minha biblioteca de classes.

Na pasta Script, crie MyClass.cs. Retire o método Start e Update. Na assinatura da classe
retire a herança da : MonoBehaviour.
Este script contém apenas o método OrdenarVetor(int[] x, string[] nome), que recebe
como valor dois vetores, o primeiro do tipo inteiro contendo as pontuações, e o segundo do tipo string e de
mesmo tamanho que o primeiro, contendo os nomes dos participantes. Note que o tamanho não importa,
pois este valor será atribuído na linha11.
Prof. Marcio /
Menezes
Este algoritmo é um clássico da ordenação de estrutura de dados unidimensional, podendo

ser também utilizado na multidimensional, que iremos ver mais a frente. Observe o sinal de maior (>) na linha
14, troque-o para menor (<) para fazer uma ordenação decrescente, que é o nosso caso em questão.
7.4.3 – Criando o script principal.

Crie na pasta script o arquivo OrdenaRanking.cs e vincule a câmera do cenário.
Na figura abaixo temos a estrutura dos métodos criados para o funcionamento do programa.

Prof. Marcio /
Menezes
Vamos a explicação. Nas linhas 7 e 8 declaramos as variáveis do tipo Text que recebem os
componentes de tela conforme a tabela do item 7.4.1.
Na linha 9 declaramos as variáveis para receber os InputField’s digitados pelo usuário no “front end”.
Essa leitura pode ser considerada como uma pontuação que fica alterada após o término de uma etapa de
um jogo, por exemplo.
Nas linhas 10 e 11, declaramos os vetores que armazenarão os pontos e os nomes digitados pelo
usuário. Os tamanhos dos vetores são definidos no método Ordenar na linha 44.
Na linha 12, temos o método Start que, como sabemos, é executado apenas no momento em que o
cenário é chamado. Ele apenas executa dois métodos a saber:
1º CriarVariavelRegistro(), que caso a variável de registro PT1 não exista, ele cria as 10 variáveis,
conforme mostra a figura abaixo.
Dessa forma as variáveis só serão criadas a primeira vez que o programa for executado no
equipamento em questão.
2º LerRanking(); efetua a leitura do ranking, que consiste em ler as variáveis de registro que estão
no equipamento e leva-las para a tela. Note que apenas as quatro primeiras, logo ao ser ordenada de forma
decrescente a última não será apresentada.
Neste instante, após a execução do método Start, o programa está aguardando que o usuário digite
valores no campo da pontuação e um nome para ser vinculado ao mesmo, após pressionar o botão
Classificar. A este botão está vinculado no evento OnClick() o método Ordenar.

Prof. Marcio /
Menezes
Neste método temos nas linhas 46 e 47 a definição dos tamanhos dos vetores que armazenam a
pontuação e os nome. Note que o tamanho é 5, e que mostramos apenas 4 na tela.
Nas linhas 48 e 49 grava no registro do sistema os pontos na variável PT5 e o nome NM5. Esses
valores foram retirados da tela, pois conforme a tabela do item 7.4.1, eles estão vinculados aos InputField’s.
Feito isso, entre linhas 51 e 57, armazena nos vetores unidimensionais x e n os pontos e os nomes
respectivamente.
Na linha 59, executa o método MyClass.OrdenarVetor(x, n); que se encontra no arquivo
MyClass.cs. É importante dizer que o mesmo deve estar na pasta que o script OrdenaRanking.cs.
Este método, já mencionado no item 7.4.2, faz a ordenação dos vetores x e n de modo decrescente
baseado no vetor x, ou seja, da maior para menor pontuação trocando também o nome correspondente.
Uma vez o vetor ordenado, executa o método GravarVetor().
Consiste em armazenar nas variáveis de registro, os pontos e nomes dos vetores x e n. Dessa forma
o quinto valor que foi armazenado, oriundo da tela, agora está na posição correta. Caso ele seja o último, não
aparecerá, caso esteja entre os quatro, coloca alguém fora do ranking.

Prof. Marcio /
Menezes
Capitulo 8 – Passagem de parâmetro entre Scripts

Neste capítulo estudaremos algumas formas de passagem de valores de variáveis entre scripts,
consequentemente entre cenários.
“Toda a jogabilidade e interatividade desenvolvidas em Unity são
construídas com base em três blocos de construção fundamentais: GameObjects,
componentes e variáveis.
Qualquer objeto em um jogo é um GameObject: personagens, luzes, efeitos
especiais, adereço — tudo.
Componentes : GameObjects não conseguem fazer tudo sozinhos. Para que
realmente se torne algo, é necessário conceder propriedades a um GameObject, o
que é feito com a adição de componentes.
Componentes definem e controlam o comportamento dos GameObjects aos quais
estão anexados. Um exemplo simples seria a criação de uma luz, que envolve a
associação de um componente de luz a um GameObject (veja abaixo). Ou,
adicionar um componente de corpo rígido a um objeto para que ele caia. “
Fonte: https://unity.com/pt/how-to/programming-unity
8.1 – Capturando o objeto da cena anterior

Suponha dois cenários A e B, onde A possui:
- Um objeto Text que armazena variável n tipo Int.
- Um botão que chama o cenário B.
- Um script A vinculado a este cenário.
Cenário B possui:
- Um objeto Text que armazena variável a tipo Int com o valor de n que estava no cenário A.
- Um botão que retorna para A
- Um script B vinculado a este cenário.
Obs: Neste exemplo o cenário B ler a variável, apresenta, entretanto não a altera quando retorna
para o cenário A.

Prof. Marcio /
Menezes
8.2 – ArrayList dentro de uma class static

Neste exemplo vamos criar uma classe que possua os atributos como sendo uma lista. Lista em C#
são vetores (array) que podem ter adicionados elementos no final da mesma de maneira dinâmica, ou seja,
através de quem instanciou a classe.
Crie no cenário do Unity um objeto vazio (Empty Object) e anexe o Script Exemplo.cs.
Na linha 8 inicializamos um vetor de nome número de 7 posições.

Prof. Marcio /
Menezes
8.3 - Utilizando o Game Manager

Neste exemplo iremos aprender a criar um GameManager que ficará na memória durante a execução
do game.
Crie na pasta Scripts um arquivo GameManager.cs conforme figura abaixo.
Agora crie um cenário de conforme a estrutura que segue.
https://www.youtube.com/watch?v=jLncApAmBo8

Prof. Marcio /
Menezes

Prof. Marcio /
Menezes
Capítulo 9 – Criando um jogo em 3D.

Neste capítulo criaremos um jogo em 3D em primeira pessoa. Faremos a utilização de objetos em
3D, para tal podemos criar na Unity através de sólidos ou utilizarmos outro aplicativo de design gráfico.
Utilizaremos uma casa criada pelo Blender e exportado na padrão FBX.
Vamos criar o projeto de nome First 3D. Deixe a caixa de diálogo Template em 3D.
9.1 Importando a imagem FBX.

Nesse projeto iremos utilizar um arquivo criado pelo Blender. Siga os passos abaixo para realizar a
exportação do arquivo.
1º - Uma vez com o projeto Blender aberto, clique em File >> Export >> FBX (.fbx) e selecione a
pasta Assets ou uma subpasta da mesma para salvar o modelo. No meu exemplo, criei as subpastas
\Animation, \Scenes, \PreFabs, \Sound, \Scripts e \Sprites.

Prof. Marcio /
Menezes
Grave na pasta Sprites.

2º - Arraste a casa que está na pasta Sprites para o cenário
3º - Remova a câmera que veio com o objeto importado do Blender. Deixe apenas uma câmera no
cenário, por enquanto.
4º - Remova também o Directional Light

Prof. Marcio /
Menezes
9.2 Iluminando e redimensionando o modelo.

Vamos redimensionar o modelo. Selecione a Casa.
Observe que temos vários elementos ancorados a ela. Passe
o valor do atributo Transform >> Scale para 3.0.
Para iluminar, use o botão direito mouse com a cena
selecionada, na opção Light. Usaremos dos dois tipos Point
Light e Spotlght.
Vamos criar quatro Point Light’s (pontos de luz) em
cada hemisfério da casa, não ancorados a casa.
O Point Light possui a característica de iluminar em
todas as direções como sendo uma lâmpada no mundo real. O
Spotlight usa um foco direcionado.
Altere os atributos Color (cor) e Intensity (intensidade)
combinadas com a movimentação nos eixos tridimensionais.
9.3 Criando o Player.

Nosso personagem foi baixado do link https://free3d.com/pt/3d-models/personagens , e exportado
pelo Blender com extensão .FBX para pasta Sprites do projeto. Não esqueça de retirar a câmera do
personagem.

Prof. Marcio /
Menezes
Altere a propriedade Scale para 0.5 nos três eixos. Posicione o personagem um pouco
afastado do chão em uma das laterais da casa para dar um efeito de pulo ao iniciar o jogo.
9.4 Criando a colisão.

Agora vamos colocar em todos os elementos do cenário um Box Collider. Não inclua Rigidbox, pois
iremos controlar a física pelo script.
Selecione o personagem e depois todos os componentes da casa pressione o Ctrl e ao mesmo tempo.
9.5 Criando o personagem em primeira pessoa.

Para passarmos a ter a visão da câmera posicionada a cabeça do personagem, mova-a para dentro
do mesmo, ou seja, ancore a câmera no personagem dê reset a sua posição.
Teste a propriedade Rotation com -45º e +45º aplicando os ajustes finais para o momento em que
levantar e abaixar a cabeça.
9.6. Script do Player

Crie um script de nome Player e vincule ao personagem (linha 5 da figura anexa a esta seção).
Adicione um componente Character Controller (linha 6). Na Unity, acrescente este componente ao Player.
O componente Character Controller é utilizado em substituição ao Rigid Body. A diferença é que
controlamos a ações do corpo rígido em tempo execução. Descrição de algumas propriedades.
Propriedade: Função:
Limite de inclinação Limita o colisor a subir apenas encostas que são menos íngremes
(em graus) do que o valor indicado.

Prof. Marcio /
Menezes
Propriedade: Função:
Deslocamento do O personagem subirá uma escada apenas se estiver mais perto do

passo chão do que o valor indicado. Isso não deve ser maior que a altura
do Character Controller ou irá gerar um erro.
Largura da pele Dois colisores podem penetrar um no outro tão profundamente

quanto sua largura de pele. Uma boa configuração é fazer com que
esse valor seja 10% do Raio.
Distância Mínima de Se o personagem tentar se mover abaixo do valor indicado, ele não
Movimento se moverá. Isso pode ser usado para reduzir o jitter. Na maioria das
situações este valor deve ser deixado em 0.
Centro Isso compensará o Capsule Collider no espaço do mundo e não

afetará como o personagem gira.
Raio Comprimento do raio do Capsule Collider. Esta é essencialmente a

largura do colisor.
Altura Alterar isso dimensionará o colisor ao longo do eixo Y nas direções

positiva e negativa.
Vamos declarar três variáveis do tipo Vector3, forward (para frente e traz), strafe (para os lados) e
vertical (para cima ou para baixo caso queira). Linhas 7,8,9.
Nas linhas 11 e 12 declaramos as variáveis do tipo float que definem as velocidades de avanço e
andar para laterais, fowardSpeed e strafeSpeed.
Nas linhas 33 e 34, capturamos no método Update (), a cada frame o valor das teclas W e S para
vertical, e A e D para horizontal. Vale também os controles de setas.

Prof. Marcio /
Menezes
9.7 Criando o script da câmera.
Há duas maneiras de trabalharmos com a câmera e o personagem em primeira pessoa.

Prof. Marcio /
Menezes
9.8 Criando a malha de navegação.

A malha de navegação (Nav Mesh Agent) é utilizada em sua cena Unity, para especificar áreas
navegáveis em seu ambiente, incluindo áreas onde os personagens podem andar, bem como obstáculos.
Passo 1: Para incluir a malha, vamos iniciar selecionando os objetos que servirão de caminho.
Coloque o mesmo como estático.
Passo 2: Em seguida clique nos botões Bake. Ele cria uma malha de navegação bem visível.
Passo 3: Para que o nosso componente obedeça a malha precisamos incluir o componente Nav
Mesh Agent no Player.

Prof. Marcio /
Menezes
Passo 1
Passo 2

Prof. Marcio /
Menezes
Passo 3

Prof. Marcio /
Menezes
Capitulo 10 -Acertando um alvo com RayCasting

10.1 - Física .Raycast
Declaração
public static bool Raycast (Vector3 origem,
Vector3 direção,
float maxDistance = Mathf.Infinity,
int layerMask = DefaultRaycastLayers,
QueryTriggerInteraction queryTriggerInteraction =
QueryTriggerInteraction.UseGlobal);
Parâmetros
origem O ponto inicial do raio em coordenadas mundiais.
direção A direção do raio.
distância máxima A distância máxima que o raio deve verificar para colisões.
máscara de camada Uma máscara de camada que é usada para ignorar seletivamente Colliders ao
lançar um raio.
queryTriggerInteraction Especifica se esta consulta deve atingir Triggers.
Devoluções
bool Retorna true se o raio cruzar com um Collider, caso contrário, false.
Descrição
Lança um raio, do ponto origin, na direção direction, de comprimento maxDistance, contra todos os
colisores na Cena.
Você pode, opcionalmente, fornecer um LayerMask , para filtrar quaisquer Colliders com os quais não esteja
interessado em gerar colisões.
A especificação queryTriggerInteraction permite que você controle se os colisores de acionamento geram

ou não uma ocorrência ou se deve usar a configuração global Physics.queriesHitTriggers .
Notas: Raycasts não detectarão Colliders para os quais a origem do Raycast está dentro do Collider. Em
todos esses exemplos, FixedUpdate é usado em vez de Update . Consulte Ordem de execução para
funções de evento para entender a diferença entre Update e FixedUpdate e para ver como eles se
relacionam com consultas de física.

Prof. Marcio /
Menezes
usando UnityEngine;
// Exemplo C#.
classe pública ExampleClass : MonoBehaviour
// Consulte Ordem de execução para funções de evento para obter informações sobre FixedUpdate
() e Update () relacionadas a consultas de física
void FixedUpdate ()
// Desloca bit o índice da camada (8) para obter uma máscara de bit
int layerMask = 1 << 8;
// Isso lançaria raios apenas contra colisores na camada 8.
// Mas, em vez disso, queremos colidir contra tudo, exceto a camada 8. O operador ~ faz isso,
inverte uma máscara de bits.
layerMask = ~layerMask;
Golpe de Raycast Hit;
// O raio intercepta quaisquer objetos excluindo a camada do jogador
if ( Physics.Raycast (transform.position, transform.TransformDirection( Vector3.forward ), out hit,

Mathf.Infinity , layerMask))
Debug.DrawRay (transform.position, transform.TransformDirection( Vector3.forward ) *

hit.distance, Color.yellow );
Debug.Log ("Did Hit");
outro
Debug.DrawRay (transform.position, transform.TransformDirection( Vector3.forward ) * 1000,

Color.white );
Debug.Log ("Não acertou");

Prof. Marcio /
Menezes
10.2 Perseguindo o inimigo.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class EnemyExplication : MonoBehaviour

{
public Transform inimigo;
public float agil;
Rigidbody corpo;
// Start é chamado antes da primeira atualização de quadro (frame)
void Start()
{
corpo = GetComponent<Rigidbody>();
}
// A atualização é chamada 50 por segundo

void FixedUpdate()
{
MoveTowards
Declaração
public static Vector3 MoveTowards ( Vector3 atual ,
Vector3 destino , float maxDistanceDelta );
Parâmetros
atual: A posição a partir da qual se move.
alvo: A posição para a qual se mover.
maxDistanceDelta: Distância a percorrer por chamada current
Devoluções
Vector3 A nova posição.

Prof. Marcio /
Menezes
Calcule uma posição entre os pontos especificados por current e target, movendo-se não mais
do que a distância especificada por maxDistanceDelta.
Use o membro MoveTowards para mover um objeto na posição corrente em direção à posição
destino. Ao atualizar a posição de um objeto a cada quadro usando a posição calculada por esta função,
você pode movê-lo em direção ao alvo suavemente. Controle a velocidade do movimento com o
maxDistanceDeltaparâmetro.
Se a currentposição já estiver mais próxima de targetmaxDistanceDelta , o valor retornado será

igual a target; a nova posição não ultrapassa target.
Para garantir que a velocidade do objeto seja independente da taxa de quadros, multiplique o
maxDistanceDeltavalor por Time.deltaTime (ou Time.fixedDeltaTime em um loop FixedUpdate).
Observe que se você definir maxDistanceDelta para um valor negativo, esta função retorna uma
posição na direção oposta do target.
*/
Vector3 pos = Vector3.MoveTowards(transform.position,

inimigo.position, agil * Time.fixedDeltaTime);
MovePosition
Declaração
public void MovePosition ( posição Vector3 );
Parâmetros
posição Fornece a nova posição para o objeto Rigidbody .
Descrição
Move o Rigidbody cinemático em direção a position.
Rigidbody.MovePosition move um Rigidbody e obedece às configurações de interpolação.

Quando a interpolação Rigidbody está habilitada,
Rigidbody.MovePosition cria uma transição suave entre os quadros. Unity move um Rigidbody em
cada FixedUpdatechamada. O positionocorre no espaço do mundo. Teletransportar um Rigidbody de
uma posição para outra usa Rigidbody.position em vez de MovePosition .
*/
corpo.MovePosition(pos);

Prof. Marcio /
Menezes
LookAt
Declaração
public void LookAt ( Transform target , Vector3 worldUp = Vector3.up);
Parâmetros
target Objeto para o qual apontar.
worldUp Vetor especificando a direção ascendente.
Descrição
Gira a transformação para que o vetor de avanço aponte para a posição atual de /target/.
Em seguida, ele gira a transformação para apontar seu vetor de direção para cima na direção
sugerida pelo worldUpvetor. Se você deixar de fora o worldUpparâmetro, a função usará o eixo y do
mundo. O vetor para cima da rotação só corresponderá ao worldUp vetor se a direção para frente for
perpendicular a worldUp.
*/
transform.LookAt(inimigo);
}
}

Prof. Marcio /
Menezes
Anexo I Script Crazzy Ball.
IA – Arquivo Plataforma.cs
Arquivo vinculado ao objeto Square de nome Plataforma no cenário Main (principal).
IB – Arquivo Spaw.cs
Arquivo vinculado ao GameObject Empty de nome SpawManager no cenário Main (principal).

Prof. Marcio /
Menezes
IC – Arquivo Player.cs
Arquivo vinculado ao objeto Circle de nome Bola no cenário Main (principal).

Prof. Marcio /
Menezes

Prof. Marcio /
Menezes
ID – Arquivo Resultado.cs
Arquivo vinculado ao objeto Canvas de nome Canvas no cenário Secondary (secundário).


Módulo 02 LPG3

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Módulo 02 LPG3

Enviado por

Direitos autorais:

Formatos disponíveis

PROGRAMAÇÃO PARA GAMES II Módulo II

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

8.2 – ArrayList dentro de uma class static ............................................................................................ 44

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

1.1 Movimentando o fundo da tela.

Resete as posições do quad em 0,0,0.

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Crie um material de nome background na pasta material.

Selecione o material criado e mova a textura para a propriedade Albedo.

Na propriedade Shader altere para Unlit e Texture.

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Agora arraste o material para a nossa cena.

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Agora crie um script de nome BackGroundScrooling e insira o seguinte código.

Arraste o script para o componente Quad.

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Arraste para dentro de MR o componente Quad e coloque Speed como 0.5.

1.2 Passando de uma cena para outra.

Na pasta Scene crie três cenário, conforme abaixo.

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Na pasta Script crie um código com as instruções abaixo:

Arraste esse código para o Canvas.

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

O script deve ser adicionado a todas os canvas de todos os cenários.

1.3 Passando parâmetros entre cenas usando PlayerPrefs.

Inclua as bibliotecas das linhas 4

Na Unity, mova os dois Text dos

Vincule ao evento OnClick do

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Linhas 5 e 6 são incluídas. Nas linhas 9 e 10 mova na Unity os Text’s de leitura.

1.4 Passando parâmetro entre cenas com variável Static.

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Na figura abaixo apresentamos o fluxo de informações.

Script CenaSample Script Scene2

1.4.1 Classes Estáticas – Static Class

1.4.2 Membros estáticos de uma classe C# (Static Members)

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Capítulo 2 – Manipulação de arquivos para Windows.

2.1 Arquivos do tipo texto para Windows

O cenário e a estrutura de pastas obedece a figura abaixo:

O script é extremamente simples.

Crie um aquivo cs de CriarArquivo

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

2.2 Inserindo registro de dados em arquivo padrão ASCII

2.2.1 Tela principal.

2.2.2 Script vinculado ao canvas.

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

2.2.3 Comentários sobre alguns comandos do código.

File.ReadAllText: Abre um arquivo binário, lê o conteúdo do arquivo retornando um string e fecha o

2.2.4 Cálculo automático do valor pago.

2.2.5 Efetuando a leitura dos dados

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Capítulo 3 – Compilação para Android.

3.1 Instalando o SDK

COORDENAÇÃO TÉCNICA DE INFORMÁTICA - CTINFO

Nas aba SDK Tools marque as opções abaixo.

Mova a barra de rolagem e marque as opções a seguir.