Controle de Versão com GitHub e Unity usando GitHub Desktop

1️⃣ CRIANDO UMA CONTA NO GITHUB – PASSO A PASSO

💡 O que é o GitHub?

O GitHub é como uma rede social misturada com um “Google Drive de programadores”. Nele, você salva os seus projetos de forma organizada, com histórico, e pode colaborar com outras pessoas.

🧭 Passo 1: Acessar o site

Abra seu navegador (Chrome, Edge, Firefox).

Digite na barra de endereço:
👉 https://github.com/login

🧭 Passo 2: Iniciar o cadastro

Clique no link “Create na account”.

Você será levado para uma tela de cadastro.

🧭 Passo 3: Preencher seus dados

Você precisará informar:

• Email: Use um e-mail que você consiga acessar, pois vai precisar confirmar depois.
• Password (Senha): Crie uma senha forte! Use letras maiúsculas, minúsculas, números e símbolos. Ex: Jog0$Unity#2025
• Username (Nome de usuário): Escolha um nome legal, sem espaços, que te represente.
  Ex: joao-dev, gabijogos, player123
• Your Country/Region: Seu país de origem (Brazil)
• Clique em Create Account.

🧭 Passo 4: Verificar e confirmar

O GitHub irá solicitar um código de verificação que será enviado no e-mail cadastrado.

Abra seu e-mail para copiar o código de verificação. Você recebera uma mensagem semelhante a imagem abaixo.

Depois de colar o código ou digitar clique em Continue. Você será redirecionado para a página de login do gitHub.

Entre com seu UserName ou e-mail, senha e clique em Sign In.

✅ Pronto!

Agora você tem uma conta no GitHub!

Pode começar a criar seus repositórios e guardar versões do seu projeto Unity online.

📘 Analogia para entender melhor:

🧠 Criar uma conta no GitHub é como fazer uma conta no Google Drive…
…mas voltada para programadores.

Aqui, você pode salvar várias versões do seu jogo como se fossem checkpoints, e ainda trabalhar junto com colegas no mesmo projeto, sem bagunça.

🧩 2️⃣ INSTALANDO O GITHUB DESKTOP

🎮 Por que usar o GitHub Desktop?

O GitHub Desktop é um programa que deixa o uso do GitHub mais fácil.

Você não precisa digitar comandos: é tudo com botões!

Ideal para quem está começando e quer versionar projetos Unity sem dor de cabeça.

🧭 Passo 1: Acessar o site oficial

Abra seu navegador e digite:
👉 https://desktop.github.com

Clique em Download Now.

Você irá para uma tela com um botão escrito “Download for Windows (64bit)”

🧭 Passo 2: Fazer o download

Clique no botão de download.

Aguarde o arquivo .exe (no Windows) ser baixado.

📌 Dica: No Windows, o arquivo fica normalmente em “Downloads”.

🧭 Passo 3: Instalar o programa

No Windows:

Dê dois cliques no arquivo .exe baixado.

O instalador irá abrir e instalar automaticamente (sem perguntas).

💡 É bem rápido, como instalar o Discord ou o Visual Studio Code.

🧭 Passo 4: Abrir o GitHub Desktop

Após instalado, procure no menu Iniciar por “GitHub Desktop”.

Abra o programa.

Vai aparecer uma tela de boas-vindas.

🧭 Passo 5: Fazer login com sua conta do GitHub

Clique no botão “Sign in to GitHub.com”

Clique em Clone a Repository.

Irá abrir uma janela, clique em Sign in. Depois em Continue with browser.

Digite seu e-mail e senha usados no GitHub (aquele que você criou no passo 1).

Autorize o acesso.

Irá abrir uma janela em seu navegador, clique em Abrir GitHubDesktop.

Irá abrir o GitHub Desktop, com a janela de clonar um repositório, apenas feche a janela.

✅ Pronto!

Agora você está logado no GitHub Desktop!

Ele está conectado à sua conta e pronto para criar repositórios ou sincronizar com o GitHub.

📘 Analogia:

O GitHub Desktop é como um pendrive invisível que liga seu computador à nuvem do GitHub.
Tudo que você “salva” nele pode ser enviado com um clique para o GitHub, sem precisar digitar nenhum comando chato!

🔧 3️⃣ CONFIGURANDO A UNITY PARA USAR GIT

Vamos criar um projeto de exemplo para facilitar nosso aprendizado no uso do Git Hub, esse projeto é meramente didático.

🎮 Por que precisamos configurar a Unity?

Quando trabalhamos com Git + Unity, precisamos ensinar a Unity a:

Mostrar todos os arquivos do projeto (inclusive os ocultos)

Salvar os dados de forma que o Git consiga comparar e versionar

Se a gente não configurar isso, o Git pode ignorar arquivos importantes e o projeto pode quebrar ao compartilhar com amigos ou recuperar uma versão antiga.

Obs.: Algumas versões da Unity já vêm configurado, se for seu caso, apenas faça a verificação se está tudo certo.

🔹 Passo 1: Criar um projeto Unity 2D

Abra o Unity Hub.

Clique em “New Project”.

Escolha a opção 2D (Core ou URP).

Dê um nome ao projeto, como JogoGitTest.

Escolha uma pasta onde ele será salvo. ( no caso do aluno será d:\alunos\seu RM\ Unity).

Clique em “Create project”.

🔹 Passo 2: Acessar as configurações do projeto

Com o projeto aberto:

No topo da Unity, vá no menu:
Edit > Project Settings…

🔹 Passo 3: Ativar “Version Control” (Controle de Versão)

Na seção “Version Control”, faça o seguinte:

Onde está escrito “Mode”, mude de Hidden Meta Files para:
✅ Visible Meta Files

🔎 O que isso faz?

A Unity cria arquivos .meta invisíveis para cada asset (imagem, áudio, prefab). Esses arquivos são essenciais!
Com a opção “Visible”, o Git consegue enxergar esses arquivos e versionar corretamente.

📘 Analogia: é como mostrar a etiqueta de cada objeto do seu jogo. Sem isso, o Git não sabe quem é quem!

🔹 Passo 4: Ativar “Asset Serialization”

Ainda na mesma tela (Project Settings), vá na seção Editor, procure pelo item “Asset Serialization”:

Mude de Mixed para:

✅ Force Text

🔎 O que isso faz?

Todos os arquivos de configurações (como cenas, prefabs e animações) passarão a ser salvos em formato de texto, e não como arquivos binários.

📘 Analogia: é como escrever os dados do jogo em uma linguagem que o Git consegue comparar, como um documento do Word ao invés de um PDF criptografado.

🔹 Passo 5: Fechar a Unity (importantíssimo!)

Depois de configurar tudo e salvar a cena:

✅ Feche o projeto Unity completamente!

🔎 Por quê?

O Git e o GitHub Desktop só conseguem reconhecer todos os arquivos depois que a Unity for fechada corretamente. Alguns arquivos só são gerados no fechamento!

📘 Analogia: é como desligar o videogame antes de tirar o cartão de memória. Se tirar com o jogo ligado, pode corromper!

💾 4️⃣ CRIANDO UM REPOSITÓRIO NO GITHUB DESKTOP

🎯 O que vamos fazer?

Vamos criar um repositório Git para o projeto Unity, ou seja, uma “caixa de controle de versões” onde o Git vai guardar cada alteração do seu jogo como se fosse um check-in no tempo.

🎮 Antes de começar:

Certifique-se de que:

Você já criou seu projeto Unity 2D (ex: JogoGitTest).

Já fechou a Unity após configurar o projeto para Git. (importante ).

Já tem o GitHub Desktop instalado e logado.

🧭 Passo 1: Abrir o GitHub Desktop

Vá até o menu iniciar (Windows), ou área de trabalho, e procure por GitHub Desktop.

Abra o programa.

🧭 Passo 2: Criar um repositório local

No menu superior, clique em:
👉 File > New Repository…

Vai abrir uma janela com campos a preencher:

✍️ Passo 3: Preencher as informações

📦 Passo 4: Criar o repositório

Clique no botão azul “Create Repository”.

O GitHub Desktop agora vai criar o repositório local e você verá seu projeto listado à esquerda.

☁️ Passo 5: Enviar para a nuvem (GitHub)

Agora que o repositório está criado no seu computador, vamos “subir” ele para o GitHub na internet:

Clique no botão “Publish repository” no topo direito.

Aparecerá uma janela com as seguintes opções:

Clique em Publish Repository.

⏱️ Em alguns segundos, seu projeto estará disponível no seu perfil do GitHub!

✅ Verificando online:

Acesse: https://github.com/seu-usuario

Clique no repositório que acabou de criar.

Você verá os arquivos da Unity (como Assets, ProjectSettings, README.md) já visíveis online!

📝 Analogia didática:

É como se você tivesse criado uma pasta na nuvem onde:

Cada vez que muda algo no jogo, você marca um checkpoint.

Esses checkpoints são enviados para um cofre online (o GitHub).

Se der algo errado, você pode voltar no tempo.

🧠 E depois disso?

A cada mudança que fizer no projeto:

O GitHub Desktop vai detectar as alterações.

Você pode fazer commits e push para manter tudo atualizado na nuvem.

🚀 5️⃣ PRIMEIRAS AÇÕES: COMMIT E PUSH

🎯 O que vamos fazer?

Agora que você criou o repositório Git para seu projeto Unity, está na hora de começar a “salvar suas mudanças” de forma organizada usando dois comandos muito importantes:

🧪 Situação prática (simulação para o aluno): Suponha que você abriu o projeto JogoGitTest na Unity e trocou o sprite do personagem principal por outro melhor. Exemplo :

Vou trocar o quadrado por um círculo

Agora queremos que o Git saiba que isso aconteceu, registre essa alteração e envie para o GitHub.

🧭 Passo a passo no GitHub Desktop

🖼️ 1. Abrir o GitHub Desktop

Abra o GitHub Desktop.

Certifique-se de que está com o repositório JogoGitTest selecionado na lista à esquerda.

🔍 2. Verificar arquivos modificados

Você verá uma lista de arquivos na parte esquerda da tela com marcações.

Esses arquivos estão “destacados” porque o Git percebeu que você fez alterações neles (como o sprite do personagem).

🟡 Os arquivos modificados geralmente aparecem com:

✅ Caixas marcadas indicando que você quer incluí-los no commit.

📝 Linhas que mostram o que mudou (verde = novo, vermelho = removido).

📝 3. Escrever a mensagem do commit

Abaixo da lista de arquivos, do lado esquerdo inferior,’ você verá um campo com o texto:

Summary (required)

➡️ Digite uma mensagem simples e clara, por exemplo:

Alterando personagem principal

🧠 Dica: Sempre escreva o que você mudou, como se estivesse explicando para um colega do grupo.

💾 4. Fazer o commit

Depois de escrever a mensagem, clique no botão:
👉 “Commit to main”

💡 Isso cria um checkpoint no seu computador local.
Ainda não foi para a nuvem.

☁️ 5. Fazer o push (enviar para o GitHub)

Agora clique no botão azul no topo:
👉 “Push origin”

💡 Isso envia a alteração para o repositório no GitHub, que fica disponível online para você (ou sua equipe) acessar de qualquer lugar.

✅ Verificando se deu certo:

Acesse https://github.com/seu-usuario/JogoGitTest

Clique na aba “Commits”.

Você verá a mensagem “Alterando personagem principal” listada lá.

🧠 Analogia:

💬 Curiosidade:

Você pode fazer quantos commits quiser por dia.

Commits ajudam a entender quem fez o quê, quando, e por quê — ótimo para projetos em grupo!

🔄 6️⃣ SINCRONIZANDO: O COMANDO PULL

🎯 O que é “Pull”?

O comando Pull serve para puxar as últimas mudanças do repositório online (GitHub) para o seu computador local.

💬 Imagine que seu colega adicionou uma nova fase ao projeto JogoGitTest e já fez o commit e o push.
Você precisa dessas mudanças no seu computador, certo?

➡️ É aí que entra o Pull!

🎮 Situação prática (cenário real em equipe)

Você e seu colega estão desenvolvendo o JogoGitTest.
Ele criou uma fase chamada “Fase2” e já fez:

Commit

Push (enviou para o GitHub)

Agora é sua vez de continuar o trabalho, mas antes de abrir a Unity, você deve atualizar seu projeto local para receber essas novidades.

🧭 PASSO A PASSO: COMO USAR O COMANDO PULL

✅ Passo 1: Abrir o GitHub Desktop

Abra o GitHub Desktop.

Verifique se o repositório JogoGitTest está selecionado no canto superior esquerdo.

✅ Passo 2: Verificar se há novidades no GitHub

No topo da tela, veja se aparece um botão azul com algo como:
👉 “Fetch origin” ou “Pull origin”

Se aparecer “Fetch origin”, clique nele para checar por novidades.

Se houver mudanças, o botão vai mudar para:
👉 “Pull origin”

✅ Passo 3: Fazer o Pull

Clique em “Pull origin”

📦 O GitHub Desktop agora vai:

• Baixar as mudanças que seu colega enviou
• Atualizar os arquivos do projeto Unity no seu computador
• Abra seu Unity e veja as mudanças.

💡 Isso pode incluir novas cenas, scripts, assets ou qualquer coisa que tenha sido alterada no projeto.

🎯 Quando usar o Pull?

💡 ANALOGIA DIDÁTICA

Usar Pull é como verificar se seus colegas já escreveram algo no caderno coletivo da sala antes de começar a escrever a sua parte.

Assim, você não cópia uma versão antiga, nem escreve por cima de algo importante.

❗ E se eu esquecer de dar Pull?

Você pode acabar trabalhando em uma versão desatualizada do projeto.

Se fizer um Push depois disso, pode gerar conflitos difíceis de resolver.

Por isso: sempre faça Pull antes de começar a editar!

🧠 Resumo didático:

🌿 7️ RAMIFICAÇÕES: USANDO BRANCHES

🎯 O que é um branch?

Um branch (ou ramificação) é como uma linha do tempo paralela do seu projeto.

🔍 Pense assim:

O projeto principal está na linha principal (chamada main)

Mas você quer fazer um experimento — como criar uma fase

Se fizer isso diretamente no main, pode quebrar algo que já funciona

Então, você cria um branch separado para testar!

📘 Analogia Didática:

Imagine que seu jogo é um caderno de desenho.

A página principal (main) tem o personagem pronto e funcionando.

Mas você quer experimentar uma fase nova…

Em vez de desenhar direto na folha original, você tira uma cópia e desenha nela.

Se der certo, você cola a nova folha de volta no caderno.
Se der errado, joga a folha fora e a original continua intacta.

🧭 PASSO A PASSO: CRIANDO UM BRANCH

✅ Passo 1: Abrir o GitHub Desktop

Abra o GitHub Desktop

Confirme que o repositório JogoGitTest está selecionado no canto superior esquerdo.

✅ Passo 2: Criar um novo branch

No topo da janela, clique em:
👉 Current branch (estará escrito “main”)

No menu suspenso, clique em:
👉 “New branch”

✅ Passo 3: Dar um nome ao branch

No campo de nome, digite:

nova-fase

Clique no botão azul:
👉 Create Branch

📌 Pronto! Você agora está trabalhando no branch nova-fase, uma cópia paralela do main. Mas você ainda estará trabalhando apenas na versão local do seu versionamento.

🟦 E agora aparece um botão novo: Publish branch

Assim que o branch é criado, o GitHub Desktop mostra um botão azul no canto superior direito:

👉 Publish Branch

🧠 O que é “Publish branch”?

O botão Publish branch serve para enviar o novo branch para o GitHub na nuvem.

Ou seja:

O branch já existe no seu computador

Mas ainda não está visível no GitHub online

E ninguém da equipe poderá ver ou usar enquanto você não publicar

🎮 Exemplo prático no projeto JogoGitTest:

Você criou o branch nova-fase e está testando a nova fase do jogo…

Se você não publicar esse branch, seu colega:

Não vai enxergar essa nova ramificação no GitHub

Não poderá dar pull desse branch

Não poderá contribuir ou revisar o que você fez

➡️ Por isso é essencial clicar em “Publish branch”

🧭 Como publicar o branch:

Após criar o branch nova-fase, clique no botão azul:
👉 Publish branch

O GitHub Desktop enviará esse branch para seu repositório online.

Em segundos, ele estará disponível em:
👉 https://github.com/seu-usuario/JogoGitTest/branches

✅ Como saber se deu certo?

Vá para https://github.com/seu-usuario/JogoGitTest

Clique no menu suspenso onde está escrito main

Você verá o branch nova-fase listado ali!

📘 Recapitulando com uma tabela:

💡 Analogia:

Criar o branch é como criar uma nova aba no seu caderno de rascunho.
Mas ela está só no seu caderno.

Quando você clica em Publish branch, é como tirar uma foto dessa aba e mandar para o grupo da turma ver.

💬 Dica final:

Sempre que criar um novo branch e quiser colaborar com alguém ou simplesmente fazer backup online, lembre-se:

Commit > Push = salvar e publicar 🚀

🧪 O que posso fazer no novo branch?

Agora, você pode:

Criar uma cena na Unity (ex: Fase3.unity)

Adicionar novos inimigos, obstáculos ou sons

Testar novas mecânicas

Editar scripts sem afetar o jogo principal

Exemplo:

💡 Tudo isso ficará separado do que está funcionando no branch main.

📢 Muito importante!

Você deve fazer commits normalmente nesse novo branch:

Alterou algo no Unity?

Volte ao GitHub Desktop

Escreva a mensagem do commit (ex: Criando fase 3)

Clique em Commit to nova-fase

Depois clique em Push origin

🔁 Assim, o branch nova-fase será atualizado no GitHub online, e poderá ser acessado pela equipe.

🤝 Em equipe? Melhor ainda!

Se estiver trabalhando com colegas:

Cada um pode criar seu próprio branch

Depois, vocês podem juntar os trabalhos com segurança, se tudo estiver Ok (isso se chama merge. Explicarei logo em seguida).

📘 Recapitulando com uma tabela:

🧠 Dica de boas práticas:

Use nomes claros para seus branches, como:

• fase2, menu-ajustes, sistema-pontuacao
• Sempre teste bem antes de juntar com o main
• Evite trabalhar no main diretamente em projetos em equipe!

🔗 8️⃣ JUNÇÃO: USANDO MERGE

🎯 O que é Merge?

Merge significa mesclar dois branches diferentes — normalmente o que você criou (ex: nova-fase) com o branch principal do projeto (geralmente chamado main).

Imagine que você e seu colega estão escrevendo capítulos diferentes do mesmo livro.
Depois de revisar, vocês querem juntar tudo no documento oficial.
Essa junção é o Merge.

🎮 Exemplo com JogoGitTest

Você:

Criou o branch nova-fase

Trabalhou em uma nova cena chamada Fase2

Testou e está tudo funcionando ✅

Agora quer levar essa nova fase para o jogo principal, ou seja, juntar nova-fase com o main.

🧭 PASSO A PASSO: FAZENDO O MERGE

✅ Passo 1: Voltar para o branch main

Abra o GitHub Desktop

No topo, clique em:
👉 Current branch (que está em nova-fase)

Selecione:
👉 main
(Você está dizendo: “Quero voltar para o documento principal”)

✅ Passo 2: Iniciar o merge

Vá no menu superior e clique em:
👉 Branch > Merge into current Branch

Aparecerá uma janelinha com a lista dos branches disponíveis.

Selecione:
👉 nova-fase
(Isso significa: “quero trazer o conteúdo de nova-fase para o main”)

Clique em Merge

✅ Passo 3: Finalizar com Push

Clique no botão azul:
👉 Push origin

🔁 Isso envia a versão atualizada do branch main para o GitHub online, agora com a nova fase incluída!

📘 Analogia Didática:

✏️ O branch nova-fase era um rascunho separado onde você desenhou a nova fase do jogo.

📄 O branch main é o documento oficial, que está sendo entregue ao público.

✅ Agora que o rascunho foi testado e aprovado, você cola ele no documento oficial.

🔄 FLUXOGRAMA

TRABALHO EM EQUIPE (COM BRANCHES)

─────────────────────────────────────────────────

INÍCIO (branch principal: main)

│

┌─────────▼─────────┐

│ Criar branch │

│ nova-fase │

└─────────┬─────────┘

│

[Desenvolver nova fase]

│

[Fazer commit e push]

│

┌─────────▼─────────┐

│ Voltar para main │

└─────────┬─────────┘

│

Fazer Merge de nova-fase

│

Clique em Push origin

│

🏁 Projeto atualizado no GitHub!

❗ E se der conflito?

Se você e seu colega modificaram os mesmos arquivos ou trechos, o Git vai avisar que há conflito.

Mas se trabalharam em partes diferentes (ex: cenas diferentes, scripts separados), o merge geralmente é feito automaticamente sem problemas.

🧠 Dica de ouro:

Sempre teste a branch antes de fazer merge.

Combine com a equipe: “Podemos juntar agora?”

Faça um último Pull no main antes do merge, para garantir que está tudo atualizado.

Se você fez tudo certinho, seguiu as discas, vai dar tudo certo, mas erros acontecem abaixo vomos tentar acertar um deles, que é bem comum.

❗ O QUE FAZER QUANDO O MERGE DER CONFLITO?

📘 Situação prática (Exemplo com JogoGitTest):

Você criou a branch nova-fase e alterou o script PlayerMovimento.cs

Enquanto isso, um colega também alterou o mesmo arquivo no branch main

Agora você quer fazer merge de nova-fase para o main

⚠️ O Git avisa: “Merge Conflict detected!”

🧠 O QUE SIGNIFICA ISSO?

O Git está dizendo:

“Ei, os dois editaram o mesmo trecho do mesmo arquivo! Eu não consigo decidir sozinho qual versão está certa.”

🧭 PASSO A PASSO: COMO RESOLVER UM CONFLITO DE MERGE

✅ 1. GitHub Desktop mostra o conflito

No momento do Merge, o GitHub Desktop vai mostrar uma tela com:

Conflicts

You have unresolved conflicts

O(s) arquivo(s) com conflito estarão listados com botão:
👉 “Resolve conflicts”

✅ 2. Clicar em Resolve conflicts

Clique no botão “Resolve conflicts”

Vai abrir um editor visual (geralmente o próprio Visual Studio Code ou outro que você configurou)

O Git vai mostrar o trecho com conflito assim:

<<<<<<< HEAD

// Código da branch main

=======

// Código da branch nova-fase

>>>>>>> nova-fase

✅ 3. Escolher o que manter

Você tem três opções:

1. Manter o que está no main
2. Manter o que está no nova-fase
3. Mesclar manualmente as duas versões (editando o código)

✏️ Edite o trecho para ficar como deseja, por exemplo:

// Código final escolhido (combinando ou escolhendo um dos dois)

Depois de editar:

Salve o arquivo

Volte ao GitHub Desktop

✅ 4. Marcar como resolvido

No GitHub Desktop, clique em:
👉 “Mark as resolved”

Agora o botão “Commit merge” estará disponível

Clique nele para finalizar o merge

✅ 5. Fazer Push

Clique em:
👉 Push origin

O conflito foi resolvido e o novo código foi enviado ao GitHub com sucesso 🎉

💡 DICA VISUAL

💥 Antes do conflito:

plaintext

CopiarEditar

PlayerMovimento.cs

<<<<< HEAD (main)

Velocidade = 10;

=====

Velocidade = 8;

>>>>> nova-fase

✍️ Depois da resolução:

// Versão final escolhida

Velocidade = 10; // ou 8, ou algo novo!

📘 ANALOGIA DIDÁTICA:

Imagine que duas pessoas editaram o mesmo parágrafo de uma redação ao mesmo tempo.

O Git não consegue adivinhar qual versão está certa, então ele te mostra as duas para que você escolha qual manter (ou junte as ideias!).

🧠 DICA DE OURO:

Combine com a equipe quem está trabalhando em qual parte do projeto

Faça Pull com frequência para evitar conflitos

Use branches diferentes para recursos diferentes

Faça commits pequenos e frequentes

⏳ 9️⃣ VOLTAR NO TEMPO: COMO VOLTAR PARA UM COMMIT ANTIGO

🎯 O que é voltar para um commit?

No Git, cada commit é como um checkpoint salvo do seu projeto.

Se você cometeu um erro ou quebrou algo no jogo, pode simplesmente voltar para um estado anterior onde tudo estava funcionando.

🕰️ Por isso, dizemos que o Git funciona como uma máquina do tempo!

🎮 Exemplo prático com JogoGitTest

Você alterou o script de movimentação do personagem.
Depois percebeu que quebrou a movimentação, e que o commit anterior estava funcionando.

➡️ Em vez de apagar arquivos manualmente ou tentar lembrar o que você fez, o GitHub Desktop te permite reverter o commit.

🧭 PASSO A PASSO: COMO VOLTAR PARA UM COMMIT ANTIGO

✅ Passo 1: Abrir o GitHub Desktop

Abra o GitHub Desktop.

Verifique se o repositório selecionado é o JogoGitTest.

✅ Passo 2: Acessar o histórico de commits

No menu lateral esquerdo, clique em:
👉 “History”

Aqui você verá todos os commits feitos no projeto, organizados por ordem do mais recente para o mais antigo.

Cada commit tem:

• Uma mensagem (ex: Criando fase 3)
• Data e hora
• Autor

Como está na Unity antes do revert à

✅ Passo 3: Escolher o commit para reverter

Procure um commit anterior ao erro.

Clique com o botão direito do mouse sobre ele.

No menu que aparecer, clique em:
👉 “Revert This Commit”

🧠 O que isso faz?

O Git cria um novo commit que “desfaz” o commit escolhido.
Ele não apaga nada — apenas adiciona uma nova alteração que volta ao estado anterior.

O Unity após o revert à

✅ Passo 4: Fazer Push

Depois de reverter:

Clique em:
👉 Push origin

Isso envia a reversão para o GitHub online, atualizando o projeto para todos os colaboradores.

💡 Dica didática:

📘 ANALOGIA DIDÁTICA

Imagina que você escreveu uma redação e cometeu um erro no parágrafo 3.

Em vez de apagar tudo ou reescrever, você pega uma versão antiga salva antes do erro e recupera só aquele trecho.

O Git faz isso por você com apenas dois cliques!

⚠️ Importante:

Você não deve apagar arquivos manualmente para “voltar atrás”.

Usar o Revert é mais seguro, pois mantém o histórico completo.

Você pode reverter quantos commits quiser, inclusive commits de colegas.

🧠 Dica de ouro:

Faça commits pequenos e frequentes.
Assim, se algo quebrar, eles poderão voltar para um estado anterior com facilidade, sem perder muito trabalho.

🎯 A dúvida:

“Se eu já fiz o commit e dei push (ou seja, enviei para o GitHub online), ainda consigo voltar para a versão anterior?”

✅ Sim! Você consegue.
O Git nunca “apaga” nada. Ele guarda tudo — inclusive os commits antigos, mesmo depois do push.

🧠 Entendendo com exemplo real (projeto JogoGitTest)

Você tinha:

• Um commit com a cena Fase3.unity.

Depois:

1. Você clicou em Revert This Commit.
2. Isso removeu a cena Fase3.
3. Fez o commit da reversão.
4. Fez o Push para atualizar o repositório online.

Agora você percebeu:

😱 “Opa! Eu apaguei a Fase3, mas quero ela de volta!”

E agora? Como voltar?

🅰️ Usar “Revert This Commit” (a mais segura)

Vá em History

Clique com o botão direito no commit com erro

Selecione “Revert This Commit”

O Git cria um novo commit.

Clique em Push origin para mandar a reversão para o GitHub

Teremos de volta a cena Fase3, Mas funciona com alterações menores.

🧠 Resumo Rápido:

🔟 TRABALHANDO EM EQUIPE

🎯 Por que usar GitHub em equipe?

Desenvolver um jogo sozinho já é um desafio… mas em equipe, sem organização, vira bagunça!

O GitHub resolve esse problema permitindo que várias pessoas colaborem no mesmo projeto sem sobrescrever ou perder arquivos.

🧑‍🤝‍🧑 Exemplo prático:

Você está desenvolvendo o projeto JogoGitTest com Unity e quer que seu colega te ajude criando a Fase 2 do jogo.

Para isso, você precisa dar permissão para ele acessar e contribuir no seu repositório GitHub.

🧭 PASSO A PASSO: COMO COLABORAR COM UM AMIGO

1. Acesse o seu repositório online

Vá para o site: https://github.com

Clique na sua conta (canto superior direito)

Acesse o repositório JogoGitTest

2. Vá até as configurações do repositório

No topo do repositório, clique na aba “Settings” (⚙️ ícone de engrenagem)

No menu da esquerda, clique em “Collaborators” ou em “Access > Manage access” (em inglês, depende da interface)

3. Adicione o seu colega

Clique no botão “Invite a collaborator”

Digite o nome de usuário ou o e-mail GitHub do seu colega

🧠 Seu amigo precisa ter uma conta GitHub criada e ativa!

Clique em Add

4. Seu amigo aceita o convite

Ele receberá um e-mail ou notificação no GitHub

Basta aceitar para se tornar colaborador no projeto

5. Seu amigo pode clonar o projeto

Agora que ele tem acesso, ele pode:

Abrir o GitHub Desktop

Clicar em File > Clone repository

Procurar pelo repositório JogoGitTest

Escolher uma pasta local e clicar em Clone

🧠 Isso copia o projeto da nuvem para o computador dele, pronto para ser editado.

💡 BOAS PRÁTICAS DE TRABALHO EM EQUIPE

✅ Combine antes quem vai fazer o quê

Para evitar bagunça, sempre falem:

“Eu vou mexer nos menus”

“Eu vou fazer o personagem”

“Eu mexo nas fases”

✅ Trabalhem com branches diferentes

Branches são como linhas do tempo paralelas do projeto.

Exemplo:

Você trabalha no branch main

Seu colega cria um branch chamado fase2

Assim, ele pode editar tudo o que quiser sem atrapalhar o que está funcionando no branch principal

📌 Depois, quando tudo estiver testado, vocês podem fazer um merge (juntar as mudanças).

✅ Usem commits com mensagens claras

Evitem escrever só “mudança” ou “teste”. Prefiram:

Adicionando fase 2 com inimigos

Corrigindo bug de colisão no personagem

✅ Façam push e pull com frequência

Push = enviar suas mudanças para o GitHub

Pull = baixar as mudanças dos outros

🧠 Dica de ouro: Sempre dê Pull antes de começar a editar, para garantir que está com a versão mais atual.

🧠 ANALOGIA DIDÁTICA

Trabalhar em equipe no GitHub é como trabalhar numa pasta compartilhada do Google Drive, mas com superpoderes:

Cada um edita sua cópia (branch)

Dá pra comparar versões, voltar no tempo, e juntar tudo no final

Sem risco de sobrescrever sem querer o trabalho do outro