INPUTS

Inputs Versão 436 – Página 2 de 34

RESUMO

A diferença dos jogos digitais para outros conteúdos que consumimos por uma tela é
capacidade de interação entre o espectador no caso o jogador e o conteúdo exibido.
Neste capitulo estudaremos como é possível controlar os transformadores de um
objeto do jogo e posteriormente iremos fazer isso através de dispositivos de entrada
como teclado, mouse e joystick.

Palavras-chave: Inputs. Transformadores. Interação.

Inputs Versão 436 – Página 3 de 34

LISTA DE FIGURAS

Figura 8. 1 - Localização de pontos no plano cartesiano .......................................... 6

Figura 8. 2 - Perspectiva no Unity ............................................................................. 7
Figura 8. 3 - Eixos e direções .................................................................................... 8
Figura 8. 4 - Nome dos eixos e direções usados no Unity ........................................ 8
Figura 8. 5 - Valores retornados pelas direções ........................................................ 9
Figura 8. 6 - Translação através de rotação .............................................................. 10
Figura 8. 7 - Criando um novo projeto 2D ................................................................. 10
Figura 8. 8 - Importando sprite para uso nos exemplos ............................................ 11
Figura 8. 9 - Navegue e acha o sprite para importação ............................................ 11
Figura 8. 10 - Clique e arraste o sprite para inseri-lo na cena ................................... 12
Figura 8. 11 - Sprite presente no centro da cena ...................................................... 12
Figura 8. 12 - Adicionando componente script .......................................................... 13
Figura 8. 13 - Nomeando e adicionando o componente script .................................. 13
Figura 8. 14 - Script como componente do sprite ...................................................... 14
Figura 8. 15 - Abrindo o editor de código .................................................................. 14
Figura 8. 16 - Abrindo o script ................................................................................... 15
Figura 8. 17 - PLAY para executar o código no editor do Unity................................. 16
Figura 8. 18 - Acesso ao Input Manager ................................................................... 23
Figura 8. 19 - Input Manager ..................................................................................... 24
Figura 8. 20 - Retorno dos Inputs Horizontal e Vertical ............................................. 26
Figura 8. 21 - Inserindo novo sprite na cena ............................................................. 29
Figura 8. 22 - Adicionando componente script .......................................................... 30
Figura 8. 23 - Criar script ao objeto ........................................................................... 30
 LISTA DE CÓDIGOS-FONTE

Código 8. 1 - Posiciona o objeto na coordenada especificada .................................. 16

Código 8. 2 - Move o objeto para esquerda .............................................................. 17
Código 8. 3 - Removendo a multiplicação pelo DeltaTime ........................................ 18
Código 8. 4 - Movendo em múltiplas direções........................................................... 19
Código 8. 5 - Gira o sprite no eixo Z.......................................................................... 20
Código 8. 6 - Gira o sprite nos eixos X e Y ............................................................... 20
Código 8. 7 - Rotação do sprite 45 graus em Z ......................................................... 21
Código 8. 8 - Rotação do sprite 45 graus em Z ......................................................... 22
Código 8. 9 - Input para mover um sprite .................................................................. 31
Código 8. 10 - Input com botões ............................................................................... 32
 SUMÁRIO

8 PLANO CARTESIANO ........................................................................................... 6

8.1 Sistema 2D vs 3D ................................................................................................ 7
8.2 Orientação no plano 2D....................................................................................... 8
8.3 Transformações .................................................................................................. 9
8.3.1 Posicionar – [Link] ........................................................................ 16
8.3.2 Mover (translação) – [Link]......................................................... 17
8.3.2 Girar – [Link] ................................................................................... 20
8.3.3 Rotacionar – [Link] ................................................................. 21
8.3.5 Escala – [Link] ......................................................................... 22
8.4 Inputs................................................................................................................... 23
8.4.1 Input por eixos .................................................................................................. 26
8.4.2 Input por botões ............................................................................................... 28
8.4.3 Inputs na prática ............................................................................................... 29
CONCLUSÃO............................................................................................................ 33
REFERÊNCIAS ......................................................................................................... 34
Inputs Versão 436 – Página 6 de 34

8 PLANO CARTESIANO

Antes de começar a escrever código que permitirão o controle dos elementos

do jogo via dispositivos de entrada é importante rever alguns conceitos elementares
de geometria.

Todo elemento de um jogo esta presente em um espaço virtual podendo este

espaço ser um espaço 2D contendo coordenadas (X,Y) ou espaço 3D contendo
coordenadas (X,Y,Z).

Plano cartesiano é um método criado pelo filósofo e matemático francês, René

Descartes. Trata-se de dois eixos perpendiculares que pertencem a um plano em
comum. Descartes criou esse sistema de coordenadas para demostrar a localização
de alguns pontos no espaço.

Figura 8. 1 - Localização de pontos no plano cartesiano

Fonte: Wikipédia (2018)

Quando iniciamos um projeto no Unity podemos optar no desenvolvimento 2D

ou 3D. Essa escolha afetará como o engine priorizara seus ASSETS e como
configurará inicialmente a estrutura do projeto. Trabalhando em 2D por exemplo, as
imagens contidas no projeto não irão possuir compressão e serão interpretadas como
SPRITES, além disso a câmera não apresentará ponto de fuga uma característica
presente apenas em representações 3D, neste caso a câmera será ortogonal. Mas
apesar disso tudo o projeto poderá contar elementos 2D e 3D, pois no fundo tudo
Inputs Versão 436 – Página 7 de 34

sempre será 3D no Untiy. Em projetos 2D o engine apenas se adapta para trabalhar

sem o eixo Z, ou seja, a profundidade. Neste momento ainda trabalharemos em 2D,
mas projetos futuros serão feitos em 3D.

ASSETS – Qualquer elemento usado para compor o jogo, podendo ser um modelo
3D, sprite, áudio e etc.

SPRITES – Nome dado as imagens usados em jogos 2D.

8.1 Sistema 2D vs 3D

Seja qual for a opção do sistema de coordenadas adotadas para seu projeto
o centro do mundo onde estará contido o mapa do seu jogo sempre terá uma origem,
a partir desta origem teremos os eixos XY ou XYZ para projetos 2D ou 3D
respectivamente. Essas serão as variáveis que conterão os valores dos eixos suas
combinações representarão um ponto no espaço. Neste espaço teremos o eixo X que
representará a largura, Y a altura e Z a profundidade. Seja qual for o plano escolhido
para o projeto teremos ainda a leitura dos valores das coordenadas que partirão da
origem, sendo o marco zero deste mundo.

Figura 8. 2 - Perspectiva no Unity

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 8 de 34

No sentido para cima ou para direita teremos os valores positivos e para baixo
ou esquerda os valores negativos.

Figura 8. 3 - Eixos e direções

Fonte: elaborado pelo autor (2018)

8.2 Orientação no plano 2D

Apesar do plano cartesiano indicar suas direções fazendo uso dos valores nos
eixos XY, o Unity apresenta uma forma mais prática para isso, substituindo os valores
pelo nome das direções.

Figura 8. 4 - Nome dos eixos e direções usados no Unity

Fonte: elaborado pelo autor (2018)

Mesmo utilizando nomes para indicar os eixos e suas direções os mesmos

retornarão um valor numérico, sendo:
Inputs Versão 436 – Página 9 de 34

Vector2.[nome do eixo]

[Link]
[Link]
[Link]
[Link]

Figura 8. 5 - Valores retornados pelas direções

Fonte: elaborado pelo autor (2018)

8.3 Transformações

Quando um objeto é selecionado no Unity o painel INSPECTOR exibe suas

propriedades e componentes que fazem parte deste objeto. Todo objeto tem um
componente TRANSFORM que é responsável pelas alterações de posição, rotação e
escala. Essas alterações podem ser feitas através do painel INSPECTOR de forma
paramétrica ou em tempo de execução, quando o jogo está sendo executado e o
código faz essas alterações.

Dizemos que um conjunto de valor direcionados aos eixos XY são um

VECTOR2 e consequentemente os valores direcionados aos eixos XYZ são um
VECTOR3, não importando em qual transformador está sendo aplicado. Lembre-se
transformações são alterações feitas na posição, rotação ou escala de um objeto.

Todo eixo possui as propriedades de transformações de posição, rotação e

escala. Dando ao objeto a propriedade de mover, reposicionar, rotacionar, girar e
escalonar. Essas propriedades são a base para todo e qualquer movimento.
Inputs Versão 436 – Página 10 de 34

Pense em seu corpo ele é formado por articulações, ao girar suas articulações
seu corpo entra em movimento, fazendo com que você que é um ponto no espaço
execute uma translação fazendo com que seu corpo saia do ponto A e siga para o
ponto B.

Figura 8. 6 - Translação através de rotação

Fonte: elaborado pelo autor (2018)

Para ficar mais clara as explicações a seguir, vamos criar um novo projeto 2D
no Unity e aplicar os conceitos na prática.

Figura 8. 7 - Criando um novo projeto 2D

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 11 de 34

Com o projeto novo aberto, importe a imagem disponibilizada para a execução

dos exemplos a seguir. Para fazer a importação clique com o botão direito sobre o
painel PROJECT, em seguida selecione a opção IMPORT NEW ASSET.

Figura 8. 8 - Importando sprite para uso nos exemplos

Fonte: elaborado pelo autor (2018)

Navegue até a pasta onde foi salva a imagem que usaremos como exemplo
e conclua a importação clicando no botão IMPORT. Dica! Salve a imagem que será
utilizada no desktop ficará mais fácil de acha-la.

Figura 8. 9 - Navegue e acha o sprite para importação

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 12 de 34

Observe que o sprite encontra-se no painel PROJECT, clique sobre ele e

arraste para janela HIERARCHY.

Figura 8. 10 - Clique e arraste o sprite para inseri-lo na cena

Fonte: elaborado pelo autor (2018)

. Essa operação fará com que o sprite seja inserido na origem da cena xy(0,0).
Lembrando que há também a possibilidade de arrastar o sprite diretamente para cena
e solta-lo no local desejado. Seja qual for a opção escolhida ambas servirão para
inserir elementos na cena para compor seu jogo.

Figura 8. 11 - Sprite presente no centro da cena

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 13 de 34

Para controlar as transformações do objeto iremos agora adicionar um script

como componente do objeto. (1) Selecione o objeto no painel HIERARCHY, (2) clique
no botão ADD COMPONENT, (3) no campo de busca filtre com a palavra script para
exibir o componente do mesmo nome, (4) clique sobre o componente.

Figura 8. 12 - Adicionando componente script

Fonte: elaborado pelo autor (2018)

Para finalizar a operação, nomeie o script para TRANSFORMAR e clique no

botão CREATE AND ADD.

Figura 8. 13 - Nomeando e adicionando o componente script

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 14 de 34

Selecione (1) o sprite no painel HIERARCHY e (2) observe no painel

INSPECTOR que agora o script está como um componente do sprite.

Figura 8. 14 - Script como componente do sprite

Fonte: elaborado pelo autor (2018)

Abra o editor de código para que possamos iniciar o estudo da programação

que irá alterar os transformadores do objeto via script. Para isso acesse os menus
ASSETS>OPEN C# PROJECT.

Figura 8. 15 - Abrindo o editor de código

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 15 de 34

No editor de código encontra o painel de GERENCIADOR DE SOLUÇÕES e

de um clique duplo sobre o script para abri-lo.

Figura 8. 16 - Abrindo o script

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 16 de 34

8.3.1 Posicionar – [Link]

Sintaxe:

[Link] = new Vector2(coordenada X, coordenada Y);

Posicionar o sprite em uma coordenada específica: Há diferença entre

posicionar um sprite e move-lo, não confunda isso. Apesar da linha de comando a
seguir sugestionar o movimento do objeto entenda que ela irá posicionar o sprite na
coordenada especificada.

using [Link];
using [Link];
using UnityEngine;

public class Transformar : MonoBehaviour {

void Start () {
// Posiciona o objeto na coordanda especificada
[Link] = new Vector2(3.0f, 0.0f);
}
}
Código 8. 1 - Posiciona o objeto na coordenada especificada
Fonte: elaborado pelo autor (2018)

Note que o código foi escrito na função START, ou seja, este código irá
executar uma única vez quando o script iniciar sua execução. Posicionando o sprite
nas coordenadas X=3, Y=0.

Digite o código e salve utilizando as teclas CTRL+S. Para executar clique no

botão PLAY no editor do Unity. Experimente novos valores nas coordenadas, lembre-
se coordenadas são valor numéricos do tipo FLOAT, por este motivo há a presença
do F na descrição dos valores.

Figura 8. 17 - PLAY para executar o código no editor do Unity

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 17 de 34

8.3.2 Mover (translação) – [Link]

Sintaxe:

[Link](velocidade X, velocidade Y, velocidade Z);

Exemplo 1: [Link](0.1f, 0.0f, 0.0f);

[Link]([Link]ção);

Exemplo 2: [Link]([Link]);

Mover o sprite: Para mover o sprite usaremos a instrução TRANSLATE da

classe transform. Essa instrução incrementa na coordenada atual o valor
especificado.

Exemplo 1: Considerando o sprite na origem da cena XY(0,0), ao usar a

instrução [Link](0.1f, 0.0f, 0.0f), entendemos que o sprite terá sua
posição em X incrementada 0.1f a cada execução da função UPDATE, fazendo com
que o mesmo tenha um deslocamento para direita. Caso o valor seja negativo o objeto
inverterá sua direção. Onde há o valor 0.0f diz que não haverá incremento nesta
direção.

Exemplo 2: Considerando o sprite na origem da cena XY(0,0). Ao fazer uso da

instrução [Link]([Link]), fará com que o objeto tenha um
deslocamento de -1.0f no eixo X, levando o objeto para esquerda. Sempre que atribuir
uma direção entenda que haverá um valor numérico do tipo float sendo 1.0f para
direção positiva (right e top) e -1.0f para direção negativa (left, down).

using [Link];
using [Link];
using UnityEngine;

public class Transformar : MonoBehaviour {

void Update () {
// Move o objeto 1 unidade para esquerda
[Link]([Link] * [Link]);
}
}
Código 8. 2 - Move o objeto para esquerda
Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 18 de 34

Observe o código 8.2, a instrução esta escrita na função UPDATE, que

executará em looping enquanto o script estiver presente na cena, fazendo com que o
objeto a cada ciclo de execução tenha sua posição em X decrementada, levando o
objeto para esquerda. Lembre-se a direção LEFT equivale ao valor de -1. Observe
também que o valor de [Link] que é -1 esta sendo multiplicado por
[Link], essa multiplicação garante que o objeto irá ter seu movimento
atualizado pelo FRAME RATE do jogo e não pelo ciclo da função UPDATE.

using [Link];
using [Link];
using UnityEngine;

public class Transformar : MonoBehaviour {

void Update () {
// Move o objeto 1 unidade para esquerda
[Link]([Link]);
}
}
Código 8. 3 - Removendo a multiplicação pelo DeltaTime
Fonte: elaborado pelo autor (2018)

Experimente remover a multiplicação por DELTATIME e note que o objeto irá

ter a atualização do seu movimento muito mais rápido do que deveria pois está sendo
atualizado sem levar em consideração o FRAMERATE do jogo.

FRAME RATE [Link]

É a velocidade em frames que um jogo [Link] é um valor do tipo float,

é renderizado, trazendo a sensação e que não possui uma grandeza fixa, em
fluidez de suas animações e geral equivale a um valor decimal muito
movimentos. Um jogo em média tem pequeno que ao ser multiplicado por
entre 30 e 60 frames de atualização por velocidades no jogo garante que a
segundo. atualização dos objetos movidos por
esta velocidade esteja de acordo com o
frame rate do jogo.
Inputs Versão 436 – Página 19 de 34

Movendo um objeto em múltiplas direções ao mesmo tempo. Exemplo a

seguir move o objeto na diagonal superior direita.

using [Link];
using [Link];
using UnityEngine;

public class Transformar : MonoBehaviour {

void Update () {
// Move o objeto na diagonal direita superior
[Link](1.0f * [Link], 1.0f * [Link], 0.0f);
}
}
Código 8. 4 - Movendo em múltiplas direções
Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 20 de 34

8.3.2 Girar – [Link]

Sintaxe:

[Link](Direção/Eixo * velocidade);

[Link]([Link] * 10.0f * [Link]);

[Link](velocidade X, velocidade Y, velocidade Z);

[Link](1.0f * [Link], 1.0f * [Link], 0.0f);

Girar o sprite: Para girar o sprite será usada a instrução Rotate da classe
transform. Entenda gira, como a rotação do objeto saindo do ponto A e rotacionando
até o ponto B na velocidade especificada, gerando o movimento de rotação e não
apenas o posicionamento do em um ângulo qualquer.

Girar o sprite no eixo Z, apesar do projeto ser 2D o eixo Z pode ser utilizado,
lembre-se que mesmo o projeto sendo 2D o eixo Z está somente omitido não ausente
do projeto.

using [Link];
using [Link];
using UnityEngine;

public class Transformar : MonoBehaviour {

void Update () {
// Gira o objeto no eixo Z
[Link]([Link] * 10.0f * [Link]);
}
}
Código 8. 5 - Gira o sprite no eixo Z
Fonte: elaborado pelo autor (2018)

using [Link];
using [Link];
using UnityEngine;

public class Transformar : MonoBehaviour {

void Update () {
// Gira o objeto nos eixos X e Y
[Link](50.0f * [Link], 50.0f * [Link], 0.0f);
}
}
Código 8. 6 - Gira o sprite nos eixos X e Y
Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 21 de 34

8.3.3 Rotacionar – [Link]

Sintaxe:

[Link] = new Vector3(ângulo X, ângulo Y, ângulo Z);

[Link] = new Vector3(0.0f, 0.0f, 45.0f);

Rotacionar o sprite: Diferente da instrução ROTATE a EULERANGLES

posiciona o objeto em um ângulo especificado sem aplicar movimentação do ângulo
A para o ângulo B.

using [Link];
using [Link];
using UnityEngine;

public class Transformar : MonoBehaviour {

void Update () {
// Rotacao do objeto em 45 graus em Z
[Link] = new Vector3(0.0f, 0.0f, 45.0f);
}
}
Código 8. 7 - Rotação do sprite 45 graus em Z
Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 22 de 34

8.3.5 Escala – [Link]

Sintaxe:

[Link] = new Vector2(escala X, escala Y);

[Link] = new Vector3(3.0f, 3.0f);

Escalonar o sprite: LOCALSCALE altera a escala do objeto de acordo com o

valor especificado.

using [Link];
using [Link];
using UnityEngine;

public class Transformar : MonoBehaviour {

void Update () {
// Escala o objeto 3X o seu tamanho atual
[Link] = new Vector2(3.0f, 3.0f);
}
}
Código 8. 8 - Rotação do sprite 45 graus em Z
Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 23 de 34

8.4 Inputs

Agora que você já conhece e sabe com manipular os transformadores de um

objeto em tempo execução, faremos isso de forma interativa usando dispositivos de
entrada como teclado, mouse e até mesmo joystick.

O Unity possui um sistema muito prático de input principalmente quando o jogo

em desenvolvimento terá como alvo múltiplas plataformas. No engine há um
gerenciador de inputs onde programador pode criar um ALIAS (nome do input) e neste
nome direcionar vários inputs, podendo ser um input respectivo a cada plataforma de
publicação. Quando o nome deste input for chamado ele checará todos os inputs que
estão direcionadas para ele.

Para melhor entendimento siga as instruções:

1 – Considerando que o projeto do inicio do capitulo esta aberto, acesse os

menus EDIT>PROJECT SETTINGS>INPUT MANAGER, para acessar as opções de
inputs.

Figura 8. 18 - Acesso ao Input Manager

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 24 de 34

2 – Observe no painel INSPECTOR a presença de uma propriedade AXES,

clique sobre ela para expandir suas opções.

Figura 8. 19 - Input Manager

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 25 de 34

Observe os nomes apresentados dos inputs presentes no gerenciador, observe

a tabela e entenda as associações:

ALIAS INPUT FÍSICO

Horizontal Teclas A e D
Setas para esquerda e direita
Direcional analógico esquerda e direita (Joystick XBOX)

Vertical Teclas W e S
Setas para cima e para baixo
Direcional analógico cima e baixo (Joystick XBOX)

Mouse X ou Mouse Y Movimento do mouse para os lados ou para frente e para trás

Fire 1 CTRL do lado esquerdo do teclado

Clique esquerdo do mouse
Botão A do joystick do XBOX
Toque simples em dispositivos com TOUCH SCREEN

Fire 2 ALT do lado esquerdo do teclado

Clique direito do mouse

Botão B do joystick do XBOX

Fire 3 SWIFT do lado esquerdo do teclado

Clique no scroll do mouse (meio)

Botão X do joystick do XBOX

Jump Barra de espaço

Botão Y do joystick do XBOX

Note que sempre que há uma referência ao uso de joystick é citado o controle
do XBOX, isso porque este controle é nativo da plataforma WINDOWS e XBOX.
Plataforma mais usual para desenvolvimento de jogos devido a sua capacidade de
receber placas gráficas similares as dos consoles. Há meios não oficiais de ligar este
controle em outras plataformas, mas é necessária uma busca no Google. Para mais
informações sobre uso do controle do XBOX acesse a WIKI do Unity
[Link]
Inputs Versão 436 – Página 26 de 34

8.4.1 Input por eixos

Os principais dispositivos de entrada que temos quando estamos

desenvolvendo são o teclado e mouse, ambos são composto de botões que por uma
análise rápida pode se deduzir que possuem dois estados, pressionados e não
pressionados, estados que podem ser associados aos valores booleanos verdadeiro
e falso, mas no caso dos inputs vertical e horizontal apesar de serem teclas na
plataforma PC, são também acionados através da alavanca analógica do joystick do
XBOX. Quando falamos valores analógico já pensamos em valores que são
numéricos e decimais. Então podemos concluir que tanto o input Horizontal, quanto o
Vertical retornam para o jogo valores numéricos decimais, neste caso valores que
iniciam em 0 quando não há interação alguma do jogador e 1 para direção positivo do
eixo e -1 para direção negativa do eixo, passando pelos seus respectivos intervalos.

Figura 8. 20 - Retorno dos Inputs Horizontal e Vertical

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 27 de 34

Sintaxe:

[Link]( “[NOME DO EIXO]” );

Retornará um valor do tipo FLOAT entre 0 e 1 para eixos positivos e 0 e -1 para

eixos negativos, passando pelos seus valores intermediários.

[Link](“[NOME DO EIXO]”);

Retornará um valor do tipo FLOAT entre 0 e 1 para os eixos positivos e 0 e -1

para eixos negativos, neste caso os valores intermediários são ignorados
fazendo com que o input funcione como se fosse um input digital respondendo
instantaneamente ao controle.

Exemplos:

[Link](“Horizontal”);

[Link](“Vertical”);

[Link](“Horizontal”);

[Link](“Vertical”);

Atenção!

A função GetAxis pede como parâmetro o nome do input, fique atente pois este
parâmetro é uma string e difere letras maiúsculas de minúsculas.
Inputs Versão 436 – Página 28 de 34

8.4.2 Input por botões

Os inputs por botões, (Fire1, Fire2, Fire2 e Jump) retornarão um valor booleano
verdadeiro ou falso de acordo com o seu estado.

Um botão possui 3 estados:

• Quando o jogador pressiona o botão;

• Quando o jogador mantém o botão pressionado;

• Quando o jogador solta o botão pressionado;

Para esses estados o Unity possui funções diferentes para leitura dos inputs,
como no exemplo a seguir:

Sintaxe: GetButton(“[nome do input]”);

GetButton(“Fire1”);

Retornará TRUE (verdadeiro) enquanto o botão estiver sendo pressionado,

retornando falso quando o mesmo não estiver sendo pressionado.

Sintaxe: GetButtonDown(“[nome do input]”);

GetButtonDown(“Fire1”);

Retornará TRUE (verdadeiro) quando o botão for pressionado e mesmo que

continuar pressionado retornará FALSE em seguida. Entenda que esse modo de input
considera apenas o primeiro pressionar do botão.

Sintaxe: GetButtonUp(“[nome do input]”);

GetButtonUp(“Fire1”);

Retornará TRUE (verdadeiro) quando o botão pressionado for solto.

Inputs Versão 436 – Página 29 de 34

8.4.3 Inputs na prática

Para melhor entendimento dos conceitos apresentando vamos agora testa-los

na prática. Utilizaremos o projeto já em uso. Para que não haja conflito com os testes
efetuados anteriormente exclua o sprite presente na cena, selecione o objeto clicando
sobre ele e pressione a tecla DELETE do teclado.

Insira novamente um novo a partir do painel PROJECT, arrastando a imagem

para o painel HIERARCHY.

Figura 8. 21 - Inserindo novo sprite na cena

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 30 de 34

Para aplicar na prática o uso dos INPUTS iremos agora adicionar um script
como componente do objeto. (1) Selecione o objeto no painel HIERARCHY, (2) clique
no botão ADD COMPONENT, (3) no campo de busca filtre com a palavra script para
exibir o componente do mesmo nome, (4) clique sobre o componente.

Figura 8. 22 - Adicionando componente script

Fonte: elaborado pelo autor (2018)

Observe que haverá uma rolagem nesta janela, insira o nome do script e clique
no botão CREATE AND ADD.

Figura 8. 23 - Criar script ao objeto

Fonte: elaborado pelo autor (2018)
Inputs Versão 436 – Página 31 de 34

Vá até o editor de código em uso e abra o script criado. Caso não esteja com
o editor aberto lembre você pode abrir pelo menu ASSETS>OPEN C# PROJECT.

Vamos agora criar instruções para mover o sprite na tela através dos inputs
Vertical e Horizontal.

using [Link];
using [Link];
using UnityEngine;

public class ExemploInput : MonoBehaviour {

// Variavel que recebe o valor da velocidade

public float velocidade = 5.0f;

void Update () {

/*
* Variaveis declaradas dentro do escopo da
* funcao para receber os valores gerados pelo input.
* Lembre-se esse valores são 0 parado -1 para eixo
* negativo e 1 para positivo
*/
float px = [Link]("Horizontal") * velocidade * [Link];
float py = [Link]("Vertical") * velocidade * [Link];

/*
* Translate ira atualizar a posicao do objeto
* incrementando ou decrementando
* sua posicao a cada frame de processamento
*/
[Link](px, py, 0.0f);

}
}

Código 8. 9 - Input para mover um sprite

Fonte: elaborado pelo autor (2018)

Digite o código e salve utilizando as teclas CTRL+S. Para executar clique no

botão PLAY no editor do Unity.
Inputs Versão 436 – Página 32 de 34

Vamos agora incluir duas instruções por botão, uma que rotacionará o objeto
enquanto estiver sendo pressionado e outro que irá retornará o objeto ao centro da
cena zerando seus transformadores.

using [Link];
using [Link];
using UnityEngine;

public class ExemploInput : MonoBehaviour {

// Variavel que recebe o valor da velocidade

public float velocidade = 5.0f;

void Update () {

/*
* Variaveis declaradas dentro do escopo da
* funcao para receber os valores gerados pelo input.
* Lembre-se esse valores são 0 parado -1 para eixo
* negativo e 1 para positivo
*/
float px = [Link]("Horizontal") * velocidade * [Link];
float py = [Link]("Vertical") * velocidade * [Link];

/*
* Translate ira atualizar a posicao do objeto
* incrementando ou decrementando
* sua posicao a cada frame de processamento
*/
[Link](px, py, 0.0f);

// Rotaciona o objeto Fire1 (CTRL Esquerdo/Clique esquerdo)

if ([Link]("Fire1"))
{
[Link](0.0f, 0.0f, velocidade);
}

// Reseta os transformadores do objeto (ALT esquerdo)

if ([Link]("Fire2"))
{
[Link] = [Link];
[Link] = new Vector2(0.0f, 0.0f);
}

}
}

Código 8. 10 - Input com botões

Fonte: elaborado pelo autor (2018)

Digite o código e salve utilizando as teclas CTRL+S. Para executar clique no

botão PLAY no editor do Unity.
Inputs Versão 436 – Página 33 de 34

CONCLUSÃO

Estamos bem perto de começa a produzir nosso primeiro jogo, mas antes
temos que estudar alguns assuntos e o assunto abordado neste capitulo é essencial
para seguirmos em frente. Aqui aprendemos como manipular as transformações dos
objetos dos nossos futuros jogos em tempo de execução e utilizando inputs. É bom
lembrar que os inputs não são usados apenas para alterar as transformações de um
objeto, eles são usado a qualquer momento quando há a necessidade de fazer com
que o usuário faça interação com o jogo seja alterando valores em um menu e até
mesmo controlando o personagem.
Inputs Versão 436 – Página 34 de 34

REFERÊNCIAS

MSDN. Microsoft Developer Network. 2018. Disponível em:

< [Link] >. Acesso em: 03 maio. 2018.

WIKI Unity – Inputs através do joystick do XBOX.

[Link]