Fórum MixMods

What is git?

Git is a tool that allow you to have a version control of you folder, it is usually used for programming proyects, but it can be used to have a version control from any folder.
It works like a time machine, if you change some files and you don't remember witch one you can get back to get the original file to avoid problems.

What we need:
- Windows Terminal
- Git

First of all, you need a clear copy of gta sa, you can get one from Miscellaneous-C (google it), and install it outside the program files folder, you can install you gta in desktop or documents folder.



Once you have it, open the game folder, if you have already installed windows terminal, when you do a right click in a empty space you will see in the context menu a option called "Open in terminal", press that option

A window like this will appear



D:\GTA SA  is the name of the directory where you gta is installed, it could be different for you.
If you type the command dir and press enter, you can see the files inside that folder



And with the command cls or clear you can clear the terminal window.



Now, if you don't have installed git yet, you can use the command winget install git.git to install it. Once it is installed let's start working with git.

Let's start a repository

First of all, you need to use the command git init to start a repository. What is a repository? Basically it is a database that store all the change you made in the folder.

After that, you will see something like this



Now lets get the status of the repository with the command git status



Why are there files/folders in red? Well, that are files that are untracked, untracked files means that they are not added to the version control of git. Lets add them all with the command git add *
This may take a while the first time, just wait until the command stops processing.

Once it is done, if you use the command git status again, you will see something like this:



That are all the files that was added to be commited

Commits

What is a commit? Basically there are a version confirmation of the modified files. It is a snapshot of the current state of the files and is considered a "safe" version of the project.

So lets do a commit, you can do a commit with the command git commit -m "" 
We use -m to add a comment or message of what change we did to the files, the comment is placed between the " simbols. Since it is the first commit we made, lets use Original gta installation as a comment.

For that lets use the command git commit -m "Original GTA Installation"


After using the git commit command, you will see something like this



Let's use the git status command again


Well, there is no change in the files, now lets review the log of commits, for that we use the command git log
You will see something like this



We have the commit code, and the information of witch branch we are, the branch will be explained later.

Ok, now we have a fully original gta sa installation, but we all know that we don't can play the game without Essentials Pack, so lets install it before continue.

If we use git status again, we will see that some files are not added, and some ones were modified



So lets add them with git add * and lets make another commit
It is very important that the comments are related to witch change we do, since we installed essential pack, let's said that
We use the command git commit -m "Essentials Pack installed" now



If we check the git log we will see something like this



And if we use the dir command, we could see the files from essentials pack that was installed



Remember when i said that git is like a time machine? well let's go back in time.

Going back in git

There is several ways to get back to a previous version. Let's see some ones

Temporaly going back

First of all, you must write down the id of the commits you want to return to, to see them just use the git log command



Let's go back to the first commit, for doing that you need to use the command git checkout [commit id]



This way is to make experimental changes, if you use the git log command it will look like this



And if you use dir this will appear



Well, let's do some test, for now let's delete the .dll files, you can use the command del *.dll to delete all the .dll files

When you use git status, this will appear



And there will be no .dll files in your folder



To restore the files, you can use the command git restore [file name]
And as you can see, the file is restored



Let's make a commit with the changes



If you use git log, you can see the change we made



Remember that this mode is for experimental purposes, well, if we use the command git switch - we go back to the master branch



If we see the git log, it seams like we don't do any change, and if you use the dir command, all the files are still there



Going back permanently

Let's first do some change in the repository to test this



Ok, let's suppose we made a mistake, we deleted the .dll files and make a commit, since we already do a commit we can't use the git restore [file name], like in the previous screnshot to restore that files, but we can go back to a previous commit

First lets use the git log command to get the commit id



To going back permanently, we need to use the command git reset [mode] and the id of the commit you want to return to.

But what about that [mode] param?

Well, the [mode] param have 2 ways to be used, they are:

• --soft: We go back to the commit we set, but the change that we made are still avaliable to be commited.
  
• --hard: We go back to the same state the folder was when we do the commit that we want, that mean all the change made are not saved.
  

Let's test each one

Git reset --soft

In this case, let's use git reset --soft [id], in this case lets use the id from the Essentials Pack commit


If we use the git status command, we can see that the change we add to be commited are still there



And we can use git restore --staged [file] to remove the file from the change we are going to commit.
Now you only need to use git restore to restore the deleted files



You can use the command git restore --staged * to take all the files from the change to be stored when you use git commit

The same happen with git restore * to restore all the deleted files



Now if you can see, there is no change to be commited.

Git reset --hard

Let's delete one more time the dll files, and test the hard mode

This time i am not using the git status to see what happen to the files



Ok, if we use git log, there is our commit



Let's use the git reset --hard command



Well, it seams that there is no changes, what about our dll files?

This time i use dir *.dll to only view the .dll files



There they are, since we do a hard reset we go back to the same state that the folder was when we do the commit, but all the changes we made between those versions that were not commented on have been lost. Because of that only use the hard mode if you really need to go back to a stable version of your game, and you don't want to keep any changes you've previously made.

And that is the most common ways to get back to a previous version.

Now lets talk about ignored files

Ignored files? Yes, some files need to be ignored, if not they will always appear in the git status command, specially the .log files, that change every time you open the game
So if you don't want to see your git status command like this



Keep reading

How to ignore files

Ok, first of all you need to create a file called .gitignore in the root directory, you can create the file using this command echo. > .gitignore



Once you have that file, open it with notepad, then add the next lines
 

And save the file

If you use the git status command, you will see that now the .log files are not in the list of changed files



You can also add folders to be ignored in the .gitignore file, like this
 
To ignore the change from that folders

Why you want to ignore folders? Well, some heavy mods make that when you use the git add * command, makes it take a while to be processed. One example is RoSA, if you are sure you will not make any change in that mod folder, you can add it in the .gitignore file like this:
 

To save some time, you remember the first git add we do? the one for the original game files? Remember how long it takes to add all the files? Well, you could create the .gitignore file and add the folders to be ignored to save some time; but since there are some mods that change files from that folders, the best thing to do is to make sure you have a commit with the original files.

Some mods have .ini files that are changed any time you use the game, to avoid view them in the git status command, it's good to add it to gitignore file.

Let's add the files and commit the change



And that is, now you can add more mods to the game and commit them, remember to add one by one to avoid posible problems.

Also, it is a good practice to use Stress Test from time to time to make sure that you game is working fine, you can do commits like git commit -m "Stress test [date]" and change [date] with the date you make the test.

What about the branchs?

Oh right, the branchs. Branchs are basically a copy of the master/main branch, where you can do changes without affecting the main branch. For example if you want to test a mod that change a lot of thing in your game, you could create a new branch to test that mod, if you like the mod, you can commit the changes back to the master main, or just have 2 branch, one to use that mod, and the other with you original game installation.

To view the branch you have you use the command git branch



To create a new branch, you can use the command git branch [name of the branch]
Let's create the branch dev



Ok, now we still are in the master branch, to go to the dev branch you use the command git checkout [name of the branch]
In this case, let's use the command git checkout dev to go to the dev branch, then we use git status to know in which branch we are



Now let's install another mod, let's install Project Urbanize as an example



Let's do an add and commit the change



Now we can see that in the branch dev we have project urbanize installed, let's go back to the master branch

If we see the log, Project Urganize is not in the game, and there is no change in this branch



Now we have basically 2 gta installations, one with Project Urbanize installed and the other without it, let's pull the change in the dev branch to the master one.

For that we use the command git merge [branch name]

Note: make sure you have in the right branch before using that command, that mean if you can put the change from the dev branch into the master branch, first you need to use git checkout master and then the git merge dev command

You can see that all the changes from the dev branch are now in the master branch



And if we see the log, now we have the commit from the dev branch



Now let's see what happen if we go back to the dev branch and do a hard reset to the previous commit



If we use git log, there is nothing about urbanize



Now if we get back to the master branch and see the log we have this



As you can see, the dev branch are update until the gitignore commit, but the master branch have the urbanize commit, if both branch have the same state, then the green text will be in the same commit (like in the image before the hard reset)

You can create as many branch you want, but i recommend you to only use 2 branch, one to test mods, and the other to have a stable gta installation, if after testing a mod and make a stress test you make sure that the game is stable, you can pull the commit from the test branch to the master branch.

Also, branchs are usefull to have multiple gta installation in one folder, something like the profiles in modloader, but that can be used with files outside modloader, like enb series or renderhook.

About git log

When you use git log, and you have a lot of commits, you will see something like this



If you press the down key, the log continue. To continue typing commands you must press the q key to exit the log.

Also, if you type gta_sa.exe and press enter you can launch the game from the terminal itselft.

¿Qué es Git?

Git es una herramienta que te permite realizar un control de version de tus carpetas, usualmente es usado en proyectos de programación, pero puede ser usado para tener un control de version de cualquier carpeta.
Funciona como una maquina del tiempo, si cambias algunos archivos y no recuerdas cuales haz cambiado, puedes volver a los archivos originales para evitar problemas.


Qué necesitamos:
- Windows Terminal
- Git

Primero que todo, necesitas tener una copia limpia del gta sa, puedes obtener una en Miscellaneous-C (buscalo en google), e instalarla afuera de la carpeta program files, puedes instalar tu gta en el escritorio o en la carpeta documentos.




Una vez que lo tengas, abre la carpeta del juego, si ya haz instalado el windows terminal, cuando hagas un click derecho en algún lugar vacio veras en el menu contextual una opción llamada "Abrir en terminal", presiona dicha opción.

Una ventana como está aparecerá




D:\GTA SA  es el nombre del directorio donde tu gta se encuentra instalado, puede ser diferente para vos.
Si escribes el comando dir y presionas enter, puedes ver los archivos dentro de la carpeta.



Y con el comando cls o clear puedes limpiar la ventana del terminal.



Ahora, si aún no haz instalado git, puedes usar el comando winget install git.git para instalarlo. Una vez instalado comencemos a trabajar con git.


Comenzemos un repositorio

Primero que nada, necesitas usar el comando git init para iniciar un repositorio. ¿Qué es un repositorio? Basicamente es una base de datos que almacena todos los cambios que hagas en la carpeta.

Después de eso, verás algo como lo siguiente:




Ahora vamos a obtener el estado del repositorio con el comando git status




¿Por qué hay archivos/carpetas en rojo? Bueno, esos archivos no tienen seguimiento (o son untracked), que los archivos no tengan seguimiento significa que no han sido añadidos al control de version de git. Vamos a añadir a todos con el comando git add *
Esto puede tardar un rato la primera vez, solo debes esperar hasta que el comando termine de procesarse.

Una vez listo, si usas el comando git status otra vez, verás algo como esto:



Esos son todos los archivos que han sido añadidos para ser comentados.


Commits

¿Qué es un commit? Basicamente son una versión confirmada de los archivos modificados. Es como una captura del estado actual de los archivos y se considera una versión "segura" del proyecto.

Entonces hagamos un commit, puedes realizar un commit con el comando git commit -m ""
Usamos -m para añadir un comentario o mensaje sobre que cambios hemos realizado a los archivos, dicho comentario se encuentra entre los simbolos ". Como es el primer comentario que hacemos, usemos Original gta installation como un comentario.

Para ello usaremos el comando git commit -m "Original GTA Installation"



Después de usar el comando git commit, verás algo como esto:




Usemos el comando git status de vuelta



Bueno, no hay cambios en los archivos, ahora veamos el log de los commits, para ello usamos el comando git log
Verás algo como lo siguiente:




Tenemos el id del commit, y la información de cual rama nos encontramos, las ramas o branchs serás explicadas más adelante.

Ok, ahora tenemos una instalación del gta sa completamente original, pero todos sabemos que no se puede jugar el juego sin el Essentials Pack, entonces vamos a instalarlo antes de continuar.


Si usas git status otra vez, verás que hay algunos archivos que no se han añadido, y otros han sido modificados



Entonces vamos a añadirlos con git add * y realizar otro commit
Es muy importante que los comentarios estén relacionados con los cambios que hemos hecho, como hemos instalado el essential pack, comentemos eso.
Ahora usamos el comando git commit -m "Essentials Pack installed"



Si revisamos el git log veremos algo como lo siguiente:



Y si usarmos el comando dir, podremos ver que los archivos del essential pack que fueron instalados.



Recuerdas cuando dije que git es como una maquina del tiempo? Bueno, es hora de volver en el tiempo.


Volviendo atrás en git

Hay varias formas de volver a una version anterior. Veamos algunas de ellas


Volver atrás de forma temporal

Primero que nada, necesitas anotar el id de los commits a los que quieres regresar, para verlos usamos el comando git log



Volvamos al primer commit, para ello necesitas usar el comando git checkout [commit id]




Esta forma es para realizar cambios experimentales, si usas el comando git log verás algo como esto




Y si usas dir esto aparecerá



Bueno, hagamos algunas pruebas, for ahora vamos a eliminar todos los achivos .dll, para ello puedes usar el comando del *.dll para eliminar todos los archivos .dll
Cuando uses git status, esto aparecerá




Y no habrá ningún archivo .dll en tu carpeta



Para restaurar los archivos, puedes usar el comando git restore [file name]
Y como puedes ver, los archivos han sido restaurados



Hagamos un commit con los cambios



Si vez el git log, puedes ver los cambios que hemos realizado



Recuerda que este modo es de proposito experimental, bueno, si usas el comando git switch - podemos volver a la rama master



Si vemos el git log, parece como que nada ha cambiado, y si usas el comando dir, todos los archivos aún se encuentran allí



Volver atrás permanentemente

Comenzemos realizando algunos cambios en el repositorio para probar eso



Ok, supongamos que hemos hecho un error, hemos borrado todos los archivos .dll y realizado un commit, como ya hemos realizado un commit, no podemos usar el comando git restore [file name], como en la captura de pantalla previa para restaurar los archivos, pero podemos volver a un commit anterior.

Primero usemos el comando git log para obtener el id del commit



Para volver atrás permanentemente, nesesitamos usar el comando git reset [mode] con el id del commit al cual queremos regresar.

¿Pero qué pasa con el parametro [mode]?

Bueno, el parametro [mode] tiene 2 formas de uso, ellas son:
 

• --soft: Regresamos al commit que elegimos, pero todos los cambios que hayamos hecho seguirán estando disponibles para ser comentados posteriormente.
  
• --hard: Regresamos al mismo estado en la que estaba la carpeta cuando hemos realizado el commit al cual queremos volver, eso significa que todos los cambios que hemos realizado no serán guardados.
  

Vamos a probar cada modo

Git reset --soft

En este caso, usaremos git reset --soft [id], en este caso usaremos el id del commit del Essentials Packmit



Si usamos el comando git status, podremos ver que los cambios que han sido añadidos para ser comentados aún se encuentran allí



Y podemos usar git restore --staged [file] para remover los archivos de los cambios que vamos a comentar.
Ahora solo necesitas usar git restore para restaurar los archivos eliminados



Puedes usar el comando git restore --staged * para quitar todos los archivos que han sido añadidos para ser almacenados cuando uses git commit

Lo mismo sucede con git restore * para restaurar todos los archivos eliminados.




Ahora como puedes ver, no hay ningún cambio para ser comentado.

Git reset --hard

Vamos a borrar una vez más todos los archivos .dll, y probar el modo hard

Esta vez no voy a usar git status para mostrar que sucede con los archivos



Ok, si usamos git log, allí está nuestro commit



Usemos el comando git reset --hard



Bueno, parece que no hay cambios, ¿qué paso con nuestro archivos .dll?

Esta vez use el comando dir *.dll para ver solamente los archivos .dll



Allí están, como hemos realizado un hard reset, volvemos al mismo estado en el que se encontraba la carpeta cuando hemos realizado el commit, pero todos los cambios que hicimos entre esas versiones que no han sido comentadas se han perdido. Debido a ello solo se debe usar el modo hard si realmente necesitas volver a una version estable de tu juego, y no necesitas mantener ningún cambio previo que hayas realizado.

Y esos son las formas más comunes para volver a una versión anterior.

Ahora hablemos de los archivos ignorados

¿Archivos ignorados? Si, algunos archivos necesitas ser ignorados, si no ellos siempre apareceran en el comando git status, especialmente los archivos .log, que cambian cada vez que abres el juego.
Entonces, si no quieres que aparezcan en el comando git status como en la siguiente imagen



Sigue leyendo

Como ignorar archivos

Ok, primero que nada necesitas crear un archivo llamado .gitignore en el directorio principal, puedes crear el archivo usando el comando echo. > .gitignore



Una vez que tengas el archivo, abrelo con el bloc de notas, y añade las siguientes lineas

Y guarda el archivo

Si usas el comando git status, verás que los archivos .log no aparecen en la lista de archivos modificados



También puedes añadir carpetas para ser ignoradas en el archivo .gitignore, así

 
Para ignorar los cambios de esas carpetas

¿Por qué quisieras ignorar carpetas? Bueno, algunos mods pesados hacen que al usar el comando git add * tome un tiempo largo hasta ser procesados. Un ejemplo es RoSA, si estás seguro que no haras ningún cambio en la carpeta del mod, puedes añadirlo en el archivo
.gitignore así
 

Para ahorrarte algo de tiempo, ¿recuerdas que el primer git add que hicimos? ¿El de los archivos originales del juego? ¿Recuerdas que tanto tiempo llevo para añadir todos los archivos? Bueno, podrías haber creato el archivo .gitignore y añadir las carpetas para ser ignoradas para ahorrate algo de tiempo; pero debido a que algunos mods cambian archivos de dichas carpetas, la mejor cosa a realizar es asegurarte que tengas un commit con los archivos originales.

Algunos mods tiene archivos .ini que pueden modificarse cada vez que abres el juego, para evitar verlos en el comando git status, es una buena idea añadirlos al archivo .gitignore.

Vamos a añadir los archivos y realizar un commit con los cambios



Y eso es todo, ahora puedes añadir más mods al juego y comentarlos, recuerda añadirlos uno por uno para evitar posibles problemas.

Además, es una buena practica usar Stress Test de vez en cuando para asegurarte de que tu juego funciona correctamente, puedes añadir comentarios como git commit -m "Stress test [date]", y cambiar [date] con la fecha en la que hiciste el test.

¿Qué pasa con las ramas?

Cierto, las ramas. Las ramas son basicamente una copia de la rama master/main, donde puedes realizar cambios sin afectar la rama principal. Por ejemplo, si quieres probar un mod que cambia muchas cosas en tu juego, puedes crear una rama nueva para probarlo, si te gusta el mod, puedes hacer un commit de los cambios en la rama principal, o solamente tener 2 ramas, una para usar le mod y otra con la instalación del juego original.

Para ver las ramas que tienes, usa el comando git branch



Para crear una nueva rama, puedes usar el comando git branch [name of the branch]
Creemos la rama dev



Ok, ahora aún nos encontramos en la rama master, para ir a la rama dev usaremos el comando git checkout [name of the branch].
En este caso, usaremos el comando git checkout dev para ir a la rama dev, luego usaremos git status para saber en que rama estamos.



Ahora instalemos otro mod, vamos a instalar Project Urbanize como ejemplo



Vamos a añadir y comentar los cambios



Ahora podemos ver que ne la rama dev tenemos Project Urbanize instalado, volvamos a la rama master

Si vemos el git log, Project Urbanize no está en el juego, y no hay cambios en esta rama




Ahora tenemos basicamente 2 instalaciones de gta, una con Project Urbanize instalado y la otra sin el, vamos a traer los cambios de la rama dev a la rama master.

Para ello usaremos el comando git merge [branch name]
 

Nota: asegurate de estar en la rama correcta antes de usar el comando, eso significa que si quieres traer los cambios de la rama dev a la rama master, primero debes usar git checkout master y luego usar el comando git merge dev

Puedes ver que todos los cambios de la rama dev ahora se encuentran en la rama master



Y si vemos el git log, ahora tenemos los commits de la rama dev



Ahora veamos que sucede si volvemos a la rama dev y hacemos un hard reset a un commit previo



Si usamos git log, no hay nada del Project Urbanize



Ahora si volvemos a la rama master y vemos el git log tenemos lo siguiente



Como puedes ver, la rama dev se encuentra actualizada hasta el commit de gitignore, pero la rama master tiene el commit de Urbanize, si ambas ramas tienen el mismo estado, entonces el texto en verde aparecerá en el mismo commit (como en la imagen antes de realizar el hard reset)

Puedes crear tantas ramas como quieras, pero te recomiendo usar solamente 2 ramas, una para probar mods, y la otra para tener una instalación de gta estable, si después de instalar un mod y hacer un stress test te aseguras que el juego es estable, puedes traer los commit de la rama de prueba a la rama master.

Además, las ramas son utiles para tener multiples instalaciones de gta en una sola carpeta, algo similar a los perfiles del modloader, pero que pueden ser usados con archivos afuera de la carpeta modloader, como enb series o renderhook.

Acerca de git log

Cuando usas git log, y tienes muchos commits, podrías ver algo como esto



Si presionas la flecha abajo, el log continua. Para seguir escribiendo comando debes presionar la tecla q para salir del log.

Además, si escribes gta_sa.exe y presionas enter, puedes abrir el juego desde la misma terminal.

O que é git??

Git é uma ferramenta que permite realizar controle de versão das suas pastas. Geralmente é usada em projetos de programação, mas também pode ser usada para ter controle de versão de qualquer pasta.
Funciona como uma máquina do tempo: se você modificar alguns arquivos e não lembrar quais foram alterados, pode voltar aos arquivos originais para evitar problemas.


O que precisamos:
- Windows Terminal
- Git

Primeiramente, você precisa ter uma cópia limpa do GTA SA. Você pode conseguir uma em Miscellaneous-C (procure no Google) e instalá-la fora da pasta Arquivos de Programas. Pode instalar seu GTA na área de trabalho ou na pasta Documentos.



Uma vez que você tiver o jogo, abra a pasta dele. Se você já instalou o Windows Terminal, ao clicar com o botão direito em algum espaço vazio, verá no menu de contexto uma opção chamada "Abrir no Terminal". Clique nessa opção.

Uma janela como esta vai aparecer:




D:\GTA SA é o nome do diretório onde seu GTA está instalado, pode ser diferente para você.
Se você digitar o comando dir e pressionar Enter, poderá ver os arquivos dentro da pasta.



E com o comando cls ou clear, você pode limpar a janela do terminal.



Agora, se você ainda não instalou o Git, pode usar o comando winget install git.git para instalá-lo.
Uma vez instalado, vamos começar a trabalhar com o Git.


Comenzemos un repositorio

Primeiro de tudo, você precisa usar o comando git init para iniciar um repositório. O que é um repositório? Basicamente é um banco de dados que armazena todas as alterações feitas na pasta.

Depois disso, você verá algo como o seguinte:




Ahora vamos a obtener el estado del repositorio con el comando git statusAgora vamos obter o status do repositório com o comando git status

Depois disso, você verá algo como o seguinte:



Por que há arquivos/pastas em vermelho? Bem, esses arquivos não estão sendo rastreados (ou seja, são untracked). Arquivos sem rastreamento significam que ainda não foram adicionados ao controle de versão do Git.
Vamos adicionar todos com o comando git add *
Isso pode demorar um pouco na primeira vez, é só esperar até que o comando termine de ser processado.

Quando estiver pronto, se você usar o comando git status novamente, verá algo como isto:



Esses são todos os arquivos que foram adicionados para serem comitados.

Commits

O que é um commit? Basicamente, é uma versão confirmada dos arquivos modificados.
É como uma captura do estado atual dos arquivos e é considerada uma versão "segura" do projeto.

Então, vamos fazer um commit. Você pode fazer um commit com o comando git commit -m ""
Usamos o -m para adicionar um comentário ou mensagem sobre as mudanças que fizemos nos arquivos. Esse comentário vai entre aspas "".
Como é o primeiro comentário que estamos fazendo, vamos usar Original GTA Installation como mensagem.

Para isso, usaremos o comando git commit -m "Original GTA Installation"



Depois de usar o comando git commit, você verá algo assim:




Vamos usar o comando git status novamente



Bom, não há alterações nos arquivos, agora vamos dar uma olhada no log de commit, para isso usamos o comando git log
Você verá algo como o seguinte:



Temos o ID do commit e a informação de em qual branch estamos. As branches (ou ramificações) serão explicadas mais adiante.

Ok, agora temos uma instalação do GTA SA completamente original, mas todos sabemos que não dá pra jogar o jogo sem o Essentials Pack, então vamos instalá-lo antes de continuar.

Se você usar git status novamente, verá que alguns arquivos ainda não foram adicionados e outros foram modificados.



Então vamos adicioná-los com git add e fazer outro commit.
É muito importante que os comentários estejam relacionados às mudanças que fizemos. Como instalamos o Essentials Pack, vamos comentar isso.
Agora usamos o comando git commit -m "Essentials Pack installed"



Se verificarmos o git log, veremos algo parecido com o seguinte:



E se usarmos o comando dir, poderemos ver os arquivos do Essentials Pack que foram instalados.



Lembra quando eu disse que o Git é como uma máquina do tempo? Pois bem, é hora de voltar no tempo.

Voltando no tempo com o Git

Existem várias formas de voltar a uma versão anterior. Vamos ver algumas delas.


Voltar no tempo de forma temporária

Primeiramente, você precisa anotar o ID dos commits para os quais deseja voltar.
Para vê-los, usamos o comando git log



Vamos voltar ao primeiro commit. Para isso, você precisa usar o comando git checkout [commit id]



Essa forma é usada para fazer alterações experimentais.
Se você usar o comando git log, verá algo parecido com isto:



E se você usar o comando dir, isso aparecerá:



Bom, vamos fazer alguns testes. Por agora, vamos deletar todos os arquivos .dll.
Para isso, você pode usar o comando del .dll para deletar todos os arquivos .dll.
Quando você usar git status, isso aparecerá:




E não haverá nenhum arquivo .dll na sua pasta.



Para restaurar os arquivos, você pode usar o comando git restore [nome do arquivo]
E como você pode ver, os arquivos foram restaurados.



Vamos fazer um commit com as alterações.



Se você olhar o git log, poderá ver as alterações que fizemos.



Lembre-se de que esse modo é para fins experimentais.
Bom, se você usar o comando git switch -, podemos voltar para a branch master.



Se olharmos o git log, parece que nada mudou. E se você usar o comando dir, todos os arquivos ainda estarão lá.



Voltar no tempo de forma permanente

Vamos começar fazendo algumas alterações no repositório para testar isso.



Ok, vamos supor que cometemos um erro: apagamos todos os arquivos .dll e fizemos um commit.
Como já realizamos um commit, não podemos usar o comando git restore [nome do arquivo], como na captura de tela anterior, para restaurar os arquivos.
Mas podemos voltar para um commit anterior.

Primeiro, vamos usar o comando git log para obter o ID do commit.



Para voltar no tempo de forma permanente, precisamos usar o comando git reset [modo] com o ID do commit para o qual queremos voltar.

Mas o que acontece com o parâmetro [modo]?

Bom, o parâmetro [modo] tem duas formas de uso, que são:
 

• --soft: Voltamos para o commit que escolhemos, mas todas as alterações que fizemos ainda estarão disponíveis para serem commitadas posteriormente.
  
• --hard: Voltamos ao mesmo estado em que a pasta estava quando fizemos o commit ao qual queremos retornar, isso significa que todas as alterações que fizemos não serão salvas.
  

Vamos testar cada modo.

Git reset --soft

Neste caso, usaremos git reset --soft [id]. Neste exemplo, usaremos o ID do commit do Essentials Pack.



Se usarmos o comando git status, veremos que as alterações que foram adicionadas para serem commitadas ainda estão lá.



E podemos usar git restore --staged [arquivo] para remover os arquivos das alterações que vamos commitar.
Agora você só precisa usar git restore para restaurar os arquivos deletados.



Você pode usar o comando git restore --staged * para remover todos os arquivos que foram adicionados para serem salvos quando você usar o git commit.

O mesmo vale para git restore *, para restaurar todos os arquivos deletados.



Agora, como você pode ver, não há nenhuma alteração para ser commitada.

Git reset --hard

Vamos deletar mais uma vez todos os arquivos .dll e testar o modo hard.

Desta vez, não vou usar o git status para mostrar o que acontece com os arquivos.



Ok, se usarmos git log, lá está o nosso commit.



Vamos usar o comando git reset --hard.



Bom, parece que não houve alterações. O que aconteceu com nossos arquivos .dll?

Desta vez usei o comando dir *.dll para ver apenas os arquivos .dll.



Lá estão eles. Como fizemos um reset hard, voltamos ao mesmo estado em que a pasta se encontrava quando realizamos o commit, mas todas as alterações feitas entre essas versões que não foram commitadas foram perdidas.
Por isso, o modo hard só deve ser usado se você realmente precisar voltar para uma versão estável do seu jogo e não precisar manter nenhuma alteração anterior que tenha feito.

E essas são as formas mais comuns de voltar para uma versão anterior.

Agora vamos falar sobre os arquivos ignorados.

Arquivos ignorados? Sim, alguns arquivos precisam ser ignorados, caso contrário eles sempre aparecerão no comando git status, especialmente os arquivos .log, que mudam toda vez que você abre o jogo.
Então, se você não quiser que eles apareçam no comando git status, como na imagem a seguir



Continue lendo

Como ignorar arquivos

Ok, antes de tudo você precisa criar um arquivo chamado .gitignore no diretório principal.
Você pode criar o arquivo usando o comando echo. > .gitignore



Depois de criar o arquivo, abra-o com o Bloco de Notas e adicione as seguintes linhas:

E salve o arquivo.

Se você usar o comando git status, verá que os arquivos .log não aparecem na lista de arquivos modificados.



Você também pode adicionar pastas para serem ignoradas no arquivo .gitignore, assim:

 
Para ignorar as alterações dessas pastas

Por que você iria querer ignorar pastas? Bem, alguns mods pesados fazem com que, ao usar o comando git add *, leve muito tempo para ser processado. Um exemplo é o RoSA, se você tem certeza de que não fará nenhuma alteração na pasta do mod, pode adicioná-la no arquivo .gitignore assim:
 

Para economizar um pouco de tempo, lembra do primeiro git add que fizemos? O dos arquivos originais do jogo? Lembra quanto tempo levou para adicionar todos os arquivos? Bem, você poderia ter criado o arquivo .gitignore e adicionado as pastas para serem ignoradas, para economizar tempo; mas, como alguns mods modificam arquivos dessas pastas, a melhor coisa a fazer é garantir que você tenha um commit com os arquivos originais.

Alguns mods possuem arquivos .ini que podem ser modificados cada vez que você abre o jogo, para evitar vê-los no comando git status, é uma boa ideia adicioná-los ao arquivo .gitignore.

Vamos adicionar os arquivos e fazer um commit com as mudanças.



E isso é tudo, agora você pode adicionar mais mods ao jogo e fazer commits, lembre-se de adicioná-los um por um para evitar possíveis problemas.

Além disso, é uma boa prática usar o Stress Test de vez em quando para garantir que seu jogo está funcionando corretamente. Você pode adicionar comentários como git commit -m "Stress test [data]", e substituir [data] pela data em que você fez o teste.

O que acontece com os branches?

Certo, os branches. Os branches são basicamente uma cópia do branch master/main, onde você pode fazer alterações sem afetar o branch principal. Por exemplo, se você quiser testar um mod que muda muitas coisas no seu jogo, pode criar um novo branch para testá-lo. Se você gostar do mod, pode fazer um commit das alterações no branch principal, ou simplesmente manter dois branches: um para usar o mod e outro com a instalação original do jogo.

Para ver os branches que você tem, use o comando git branch



Para criar um novo branch, você pode usar o comando git branch [nome do branch]
Vamos criar o branch dev



Ok, ainda estamos no branch master. Para mudar para o branch dev, usaremos o comando git checkout [nome do branch].
Neste caso, usaremos o comando git checkout dev para mudar para o branch dev, e depois usaremos git status para saber em qual branch estamos.



Agora vamos instalar outro mod. Vamos usar o Project Urbanize como exemplo.



Vamos adicionar e comentar as alterações.



Agora podemos ver que na branch dev temos o Project Urbanize instalado. Vamos voltar para a branch master.

Se olharmos o git log, veremos que o Project Urbanize não está no jogo, e que não há alterações nessa branch.




Agora temos basicamente duas instalações do GTA, uma com o Project Urbanize instalado e outra sem ele. Vamos trazer as alterações da branch dev para a branch master.

Para isso, usaremos o comando git merge [nome da branch]
 

Nota: certifique-se de estar na branch correta antes de usar o comando. Isso significa que, se você quiser trazer as alterações da branch dev para a branch master, primeiro deve usar git checkout master e depois usar o comando git merge dev

Você pode ver que todas as alterações da branch dev agora estão na branch master



E se vermos o git log, agora temos os commits da branch dev.



Agora vejamos o que acontece se voltarmos para a branch dev e fizermos um reset hard para um commit anterior.



Se usarmos git log, não há nada do Project Urbanize.



Agora, se voltarmos para a branch master e usarmos o comando git log, veremos o seguinte:



Como você pode ver, a branch dev está atualizada até o commit do .gitignore, mas a branch master ainda tem o commit do Project Urbanize. Se ambas as branches tivessem exatamente o mesmo estado, o texto em verde (indicando a branch atual) apareceria no mesmo commit — como vimos antes de fazer o hard reset.

Você pode criar quantas branches quiser, mas eu recomendo usar apenas duas:

Uma branch para testar mods.

E outra (geralmente a master) para manter uma instalação estável do GTA.

Se depois de instalar um mod e fazer um stress test o jogo continuar funcionando bem, você pode trazer os commits da branch de testes para a branch master.

Além disso, as branches são muito úteis para ter múltiplas instalações do GTA na mesma pasta — algo parecido com os perfis do modloader, mas com a vantagem de que funcionam também com arquivos fora da pasta modloader, como ENB Series ou RenderHook.

Sobre o git log

Quando você usa o git log, e tem muitos commits, você pode ver algo assim:



Se você pressionar a seta para baixo, o log continuará. Para voltar a escrever comandos, você deve pressionar a tecla q para sair do log.

Além disso, se você digitar gta_sa.exe e pressionar Enter, poderá abrir o jogo diretamente do terminal.

1. Essentials Pack (move the files to the root folder)
   
2. Open Limit Adjuster
   
3. SkyGfx Extended
   
4. Proper Fixes
   
5. RoSA Project Evolved
   
6. Project Urbanize
   
7. Tunning mod (if you use it)
   

After that you could install others mods without problem, like PedFuncs, car mods, buildings and more, just make sure to add them and commit them one by one