int XX = 0;
••Número Inteiro
float XX = 0f;
••Número com virgula
string XX;
••Variavel de texto

print (XX);
••Exibe o que está dentro da varíavel em forma de texto
print ("YY");
••Exibe o texto dentro das aspas.

//XX
••Comentário
/*
XX
*/
••Comentário em várias linhas

XX++;
XX;
ou
++XX;
••Adiciona 1 valor
XX--;
XX;
ou
--XX;
••Remove 1 valor

XX += 0
••Substitui uso grande de variaveis Ex: XX = XX + 0; //funciona para qualquer operação matemática, - / *

••Retorna em true ou false o valor comparativo entre 2 variáveis
== igual
!= diferente
> maior que
< menor que
>= maior ou igual que
<= menor ou igual que

AND// XX && YY || XX && YY;
••Precisa de tudo verdadeiro ou retorna como falso
OR// XX == YY || XX == YY;
••Se houver pelo menos 1 verdadeiro retorna verdadeiro
NOT// !(XX == YY);
••Altera o valor verdadeiro e falso

••Condição Se e senão.
if(XX == YY)
{
  print("Primeira condição verdadeira");
}
else if (XX > YY)
{
  print("Segunda condição verdadeira se falhar a primeira");
}
else
{
  print("Caso todas as condições forem falsas");
}

••Ternarios, Se for verdadeiro ou falso, simplificado. Usa ? e :
ZZ = (XX >= YY)?"Afirmação Verdadeira":"Afirmação Falsa";
print (ZZ);

••Switches = Estados. Usa INT
USO EM IF
if (XX == 1){
  print("Switch 1")
}
else if (XX == 2){
  print("Switch 2")
}
else if (XX == 3){
  print("Switch 3")
}
else{
  print("Switch ?")
}
USO EM SWITCH
switch (XX){
case 1:
  print("Switch 1");
  break;
case 2:
  print("Switch 2");
  break;
case 3:
  print("Switch 3");
  break;
default :
  print("Switch ?");
  break;
}

••Lasso For, cria looping, (Variavel, quantidade, incremento)
for(int x = 0; x <= 10; x++){
  print (x);
}

••Lasso While,verifica condição, enquanto algo não chegar a condição, repete
while (x <= 10){
print (x);
x++;
}

••Lasso Do While, faz ação enquanto não chegar a condição, ação antes de repetição
do{print(x);
x++;
}while(x <= 10);

••Lasso Foreach, usa arrays, pega todos os elementos de uma variável
foreach(string nome in inimigos){print (nome);
}

••Break, abandona lasso
break;

••Continue, pula uma interação em lasso
continue;

••Vetor, variáveis array unidimensional, indice sempre começa em 0
int[] XX = {1,2,3,4};
print (XX[0]);
~~RESULTADO 1~~
int[] XX = new int[4]{1,2,3,4};
print (XX[0]);
~~RESULTADO 1~~
int[] XX = new int[4];
XX[0] = 1;
XX[1] = 2;
XX[2] = 3;
XX[3] = 4;
print (XX[0]);
~~RESULTADO 1~~

••Alimentando Vetores
int[] XX = new int[10];
for(int i = 0; i<= 9; i++){
XX[i] = i+1;
print (i +" : "+ XX[i]);
}

••Matriz, varíaveis array bidimensional, indice sempre começa em 0
int[,] XX = new int[2,2];
XX[0, 0] = 1;
XX[0, 1] = 2;
XX[1, 0] = 3;
XX[1, 1] = 4;
print (XX[0,1]);
~~RESULTADO 2~~

••Alimentando Matrizes
int[,] XX = new int[2,2];
int valor = 1;
for(int linhas = 0; linhas <= 1; linhas++){
for(int colunas = 0; colunas <=1; Colunas++{
XX[linhas,colunas] = valor;
valor++}
}
for(int linhas = 0; linhas <= 1; linhas++){
for(int colunas = 0; colunas <=1; Colunas++{
print (linhas+" : " +colunas+ " = "+ XX[linhas,colunas]}
}

••Coleção list, quando não se sabe quantos valores vai utilizar, quando remove um valor altera a posição (0,1,2,3, etc)
List<int> XX = new List<int> ();
XX.Add (100); //0
XX.Add (300); //1 vira 0
XX.Add (500); //2 vira 1
XX.Remove (100); //0
print (XX[1]); //500
print (XX.IndexOf(300)); //0

••Alimentar list
for (int i = 0; i <= 9; i++){
XX.Add (i);
}
foreach(int valores in XX){
print (valores);
}

••Dictionary, cria informações
Dictionary<string,string> XX = new Dictionary<string, string> ();
XX.Add("Nome","Info");
XX.Add("Nome2","Info2");
foreach(string chave in XX.Keys){
if (chave == Nome2){
print (XX[chave]);
}}
XX.Remove("Nome");

••Enumeradores, estados, trabalhando com informações ao invés de valores
enum AI {Atacar,Correr,Patrulhar} //0,1,2
~~
AI vilaoFase1 = AI.Patrulhar;
AI vilaoFase2 = AI.Atacar;
~~
print (vilaoFase1); // Patrulhar
~~
int v1 = (int)vilaoFase1;
print (v1); // 2
~~ Pode colocar o valor alternativo com {Atacar=1,Correr,Patrulhar}

••Scopo {}, corpo de classe{}, corpo de método {}, variáveis criadas dentro de um método só pode ser utilizada dentro do método. Se criada variável dentro da classe, pode ser utilizada dentro dos métodos.

••Classes, molde para criar personagens ou vilões, receita
class Felino{
//Características = atributos
string nome;
string corPelo;
int forca;
//Ações = métodos
void.atacar(){
}
}

••Objetos, instancia da classe, utiliza a classe
felino gatoFase1;
felino gatoFase2;
~
gatoFase1 = new Felino();
gatoFase2 = new Felino();

••Modificadores de acesso, Private(restringe a utilização dentro da classe), Public(abre acesso para fora da classe), Protected (Funciona dentro da classe ou em classe filha, herança, não acessado por fora)é utilizado antes do atributo na classe.
Felino gatoFase1;
Felino gatoFase2;
gatoFase1 = new Felino();
gatoFase2 = new Felino();
~~
class Felino{
public string nome;
public string corPelo;
public int forca;
public void atacar(){}
}
gatoFase1.nome = "Mark"; //acessando
gatoFase1.atacar ();
gatoFase1.corPelo = "preto";
gatoFase1.forca = 100;
~~
gatoFase2.nome = "Zuck";
gatoFase2.corPelo = "marrom";
gatoFase2.atacar ();
~~
class filha : Felino{
public void acessa(){
nome = "Gato";}
}
filha fi;
fi = new filha ();
fi.acessa ();

••Métodos, realizar tarefas (void não retorna nada, nenhum valor)
metodos somar;
int val;
somar = new metodos ();
val = somar.soma();
print(val);
class metodos{
public int soma(){
int Valor1 = 10;
int Valor2 = 5;
int resultado = Valor1 + Valor2;
return resultado;}
}
~~Ou~~
metodos somar;
somar = new metodos ();
val = somar.soma(10,5);
print(val);
class metodos{
publci int soma(int Valor1, int Valor2){
int resultado = Valor1+Valor2;
return resultado;}
}

••Método Construtor, padroniza valores
metodos obj;
obj = new metodos();
obj.Valor1 = 1000;
print (obj.valor1);
print (obj.valor2);
~~
class metodos{
public int Valor1;
public string Valor2;
public metodos(){
Valor1 = 10;
Valor2 = "oi";
}
}
~~ou~~
class obj;
obj = new metodos (10, "oi");
print (obj.valor1);
print (obj.valor2);
~~
class metodos{
public int Valor1;
public string Valor2;
public metodos(int valor, string val){
this.Valor1 = valor;
this.Valor2 = val;
}
}

••Método Estático, não precisa criar objeto da classe
int retorno = metodos.soma(2,2);
print (retorno);
class metodos{
public static int soma(int Valor1, int Valor2){
int result = Valor1 + Valor2;
return result;}
}

••This e Base. usa atributo da propria classe e base usa atributo da classe pai
class pai{
public int idade;
public pai(int idade){
this.idade = idade;}
}

class pai : MonoBehaviour{
public int idade = 30;
}
class filho : pai{
public void pegaIdade(){
print(base.idade);}
}

••Sobrecarga de Métodos. criar metodos com mesmo nome que realizam ações diferentes.
calculadora calc;
int resultINT;
float resultFLOAT;
calc = new calculadora
resultINT = calc.calcula(5,2);
resultFLOAT = calc.calcula(2.5f,4.4f)
print (resultINT);
print (resultFLOAT);

class calculadora{
public int calcula(int x, int y){
return x + y;}
public float calcula(float x, float y){
return x + y;}
}

••Herança. Classe herda todas as propriedade e metodos de outra classe.
class pai{
public int idade;
}
class filho : pai{
public void pegaIdade(){
base.idade;}
}

••Encapsulamento. proteger informações, propriedade não tem parenteses
pai p;
p = new pai ();
p.Idade = 20;
print(p.Idade);

class pai : MonoBehaviour{
private int idade = 10;
public int Idade{
get{ return idade; }
set{ if(value > 10){
idade = value;}
else{
print ("Erro");}
}
}

••Polimorfismo, varias formas?
leao leo;
gato cat;

leo = new leao();
cat = new gato();
leo.comer();
cat.comer();

class animal : MonoBehaviour{
public virtual void comer(){
print ("animal está comendo");}
}
class leao : animal{
public override comer (){
print ("leao está comendo");}
}
class gato : animal{
public override comer (){
print ("gato está comendo");}
}