Sauvegarder, Backups et Git sans Panique sur Godot
Formations

Sauvegarder, Backups et Git sans Panique sur Godot

Antharuu Antharuu
11 min de lecture
Godot godot 4 sauvegarde projet godot backup projet godot gestion des scènes godot save et save as godot dossier .godot git pour godot versioning godot bonnes pratiques godot organisation projet godot

Vous avez deja vos scenes Main, Player et HUD, et ca, c'est une base nickel pour commencer. Mais vous vous demandez peut-etre : 'OK... et maintenant, comment je fais pour ne pas tout perdre au premier gros bug, au premier fichier deplace, ou au premier crash ?' Bonne nouvelle : ca s'apprend, et ca se met en place des maintenant, sans outils compliques.

L'objectif de ce module, c'est d'adopter des habitudes simples, mais solides. Pas pour faire 'pro' pour faire pro, mais parce que sur un projet Godot, ce sont ces habitudes qui vous evitent les gros 'tout est casse' et les heures a tout reconstruire.

1) Contexte rapide (ou on en est)

Vous avez un projet Godot deja cree, avec au moins trois scenes :

  • Main.tscn
  • Player.tscn
  • HUD.tscn

Vous savez deja ouvrir une scene, ajouter des noeuds, et sauvegarder. Parfait. Maintenant, on va structurer vos reflexes autour de trois choses :

  1. Sauvegarder proprement (scene + projet, et pas 'a peu pres')
  2. Comprendre ce qui est important dans un dossier Godot (et ce qui est du cache)
  3. Avoir un vrai plan B : backup simple, et optionnellement Git

2) Objectifs (clairs et mesurables)

A la fin du module, vous serez capable de :

  1. Sauvegarder correctement une scene avec Save et Save As, et savoir quand utiliser l'un ou l'autre.
  2. Comprendre la difference entre Save et autosave (et pourquoi l'autosave ne remplace pas un backup).
  3. Identifier ce qui doit etre sauvegarde/versionne dans un projet Godot (et ce qui ne doit surtout pas l'etre).
  4. Mettre en place une routine simple de backups datees (sans outil complique).
  5. (Optionnel) Initialiser un repo Git avec un .gitignore propre pour Godot (init, add, commit, status).
  6. Appliquer 5 reflexes anti-catastrophe (ceux qui evitent les grosses sueurs froides).
  7. Verifier qu'une sauvegarde est valide en ouvrant une copie du projet.

3) Mini glossaire (simple, sans jargon inutile)

  • Scene (.tscn) : fichier Godot qui decrit une hierarchie de noeuds (Player, HUD, niveau, etc.).
  • Projet (project.godot) : fichier central du projet (parametres, scene principale, config). Si lui est casse ou perdu, votre projet est mal en point.
  • Autosave : sauvegarde automatique cote editeur. Pratique, mais ce n'est pas votre strategie de recuperation.
  • .godot/ : dossier genere par l'editeur (cache, imports, infos locales). Utile, mais regenerable.
  • Versioning (Git) : historique des changements. Permet de revenir en arriere et de comprendre ce qui a change.
  • Backup : copie restaurable du projet. Si tout plante, vous repartez de la.

4) Sauvegarder proprement : Save, Save As, autosave

Dans Godot, beaucoup de soucis viennent d'une chose simple : on pense avoir sauvegarde, mais on n'a pas sauvegarde ce qu'on croit. Donc on clarifie.

Save (Ctrl+S) : 'j'enregistre cette scene'

  • Save ecrit par dessus le fichier actuel.
  • Si vous etes dans Player.tscn, Ctrl+S sauvegarde Player.tscn (pas une autre scene).
  • C'est votre geste par defaut, celui a faire souvent.

Quand l'utiliser ?
Tout le temps, des que vous avez fait une petite etape logique : un noeud ajoute, un script modifie, un signal connecte.

Save As (Ctrl+Shift+S) : 'je cree une variante'

  • Save As cree un nouveau fichier de scene.
  • C'est votre bouton 'je tente un truc risqué sans casser l'original'.

Exemples utiles :

  • Vous voulez tester un nouveau systeme de mouvement sur Player.
  • Vous voulez reorganiser la hierarchie de noeuds et vous n'etes pas sur.
  • Vous voulez essayer une refonte du HUD.

Vous pouvez faire :

  • Player.tscn (version stable)
  • Player_test_mouvement.tscn (version de test)

L'idee n'est pas d'accumuler 40 fichiers, mais d'avoir une bouee de secours quand vous tentez un gros changement.

Autosave : 'Godot essaie de m'aider, mais je ne compte pas dessus'

L'autosave (selon la version et les reglages) peut sauver des informations temporaires si l'editeur crash. C'est utile, mais :

  • ce n'est pas forcement clair,
  • ce n'est pas organise,
  • ce n'est pas fait pour etre transporte sur une autre machine,
  • ce n'est pas un historique.

Conclusion simple : l'autosave ne remplace ni un backup, ni Git. C'est un filet de secours, pas votre plan.

Checkpoint (a faire maintenant)

  1. Ouvrez Player.tscn.
  2. Ajoutez un noeud simple (ex : Node2D ou Sprite2D).
  3. Faites Ctrl+S.
  4. Fermez et rouvrez la scene : le noeud est toujours la.
    Si oui : vous etes ok sur Save.

Ensuite : 5. Faites Ctrl+Shift+S et sauvegardez en Player_variante.tscn.
6. Rouvrez Player.tscn (pas la variante) et verifiez que vous etes bien sur l'original.
But : sentir la difference entre 'j'ecrase' et 'je duplique'.

5) Comprendre le dossier projet : ce qui est vital vs ce qui est du cache

Un projet Godot est un dossier. Dans ce dossier, tout n'a pas la meme importance. Certains fichiers sont votre travail. D'autres sont des fichiers regeneres.

Ce que vous voulez absolument preserver (et versionner si vous utilisez Git)

  • project.godot : le coeur du projet
  • *.tscn : vos scenes
  • *.gd : vos scripts
  • vos assets source : png, wav, ogg, ttf, etc.
  • docs utiles : README.md, CHECKLIST_PROJET.md, etc.

En gros : tout ce que vous ne voulez pas refaire a la main.

Ce que vous ne voulez generalement pas versionner : .godot/

Le dossier .godot/ est un dossier genere par l'editeur. Il contient des caches, des infos d'import et d'autres donnees locales. Il peut grossir vite, et surtout :

  • il depend de la machine,
  • il peut changer sans que vous ayez modifie votre jeu,
  • il se regenere.

Le point important : si vous supprimez .godot/, Godot peut le recreer (au prix d'un petit temps d'import au prochain lancement). Donc le versionner ou le mettre dans un backup zippe n'apporte pas grand chose, et ca peut meme creer des conflits si plusieurs personnes travaillent sur le projet.

Petit test (tres instructif)

  1. Fermez Godot.
  2. Faites une copie de votre projet dans un autre dossier.
  3. Dans la copie, supprimez .godot/.
  4. Rouvrez la copie dans Godot.

Si tout s'ouvre et reimporte : vous venez de comprendre la difference entre 'dossier vital' et 'cache regenerable'.

Checkpoint : vous pouvez expliquer en une phrase :

  • project.godot = vital
  • .godot/ = cache regenerable

6) 5 reflexes anti-catastrophe (a appliquer des aujourd'hui)

Voici 5 reflexes simples. Si vous les appliquez, vous evitez la plupart des grosses galeres debutant.

Reflexe 1 : renommer et deplacer depuis Godot, pas depuis l'explorateur

Le piege classique : vous renommez Player.gd ou vous deplacez Player.tscn via Windows/Mac, puis Godot perd des liens (scripts introuvables, textures manquantes).

Regle : renommez et deplacez vos fichiers depuis le panneau FileSystem de Godot.
Godot peut alors mettre a jour les references.

Reflexe 2 : Save souvent, mais surtout sur la bonne scene

Autre piege : vous modifiez le Player, mais vous etes en train de sauvegarder une autre scene ouverte dans un autre onglet.

Regle : avant Ctrl+S, regardez l'onglet actif.
Et apres une grosse modif : faites une petite verification (reouvrir la scene, ou lancer F6).

Reflexe 3 : apres un gros changement, faites un mini test (F6 ou F5)

  • F6 : lance la scene courante
  • F5 : lance le projet (scene principale)

Regle : vous ne faites pas 30 minutes de modifications sans un test rapide.
Un test rapide, c'est 10 secondes, et ca vous evite de cumuler des erreurs.

Reflexe 4 : une variante avant une chirurgie (Save As)

Avant de toucher a quelque chose de sensible (mouvement du player, refonte du HUD, changement de structure), faites une variante.

Regle : si vous avez un doute, Ctrl+Shift+S et vous creez un fichier test.
Ca vous donne un retour arriere simple, meme sans Git.

Reflexe 5 : un backup teste, pas juste un dossier copie

Beaucoup de gens font un dossier 'backup'... sans jamais essayer de l'ouvrir. Le jour ou il faut restaurer, surprise : il manque un fichier, ou la copie est incomplete.

Regle : un backup est considere valide uniquement si vous l'ouvrez et lancez le jeu dans la copie.

7) Option 1 (recommandee) : routine simple de backup par copies datees

C'est la methode la plus simple et la plus efficace pour debuter. Pas besoin d'internet, pas besoin de compte, pas besoin de comprendre Git.

La routine (simple et realiste)

Frequence conseillee :

  • avant une grosse session
  • apres une grosse session
  • et avant un changement risqué

Etapes :

  1. Fermez Godot (important, ca evite de copier des fichiers en cours d'ecriture).
  2. Creez un dossier Backups/ en dehors du dossier du projet principal (ex : sur votre Bureau ou dans Documents).
  3. Copiez le dossier du projet.
  4. Dans la copie, supprimez .godot/ pour alleger.
  5. Renommez la copie avec une date claire.

Exemple de nommage :

  • MonProjet_2026-02-24_0900/
  • MonProjet_2026-02-24_1830/

Optionnel :

  • zippez la copie (MonProjet_2026-02-24_1830.zip) si vous voulez gagner de la place et eviter de modifier la copie par accident.

Checkpoint (le plus important)

Ouvrez la copie dans Godot et lancez :

  • F5 (projet) ou F6 (scene courante)

Si ca marche : backup valide.
Si ca ne marche pas : corrigez maintenant, pas le jour ou vous en aurez besoin.

8) Option 2 : mini intro Git (sans profondeur, mais propre)

Git est un outil d'historique. Ce n'est pas un backup a lui seul (meme si ca aide), mais c'est excellent pour revenir en arriere apres une mauvaise modification.

L'idee ici : vous donner juste le minimum viable :

  • init
  • ignorer le cache
  • premier commit
  • verifier l'etat

Etape 1 : initialiser Git

Dans le dossier racine de votre projet :

git init

Vous devriez voir un dossier .git/.

Etape 2 : ajouter un .gitignore adapte a Godot

Creez un fichier .gitignore a la racine du projet :

.godot/
*.import
*.translation
export.cfg
export_presets.cfg

But : ne pas versionner ce qui est regenerable ou local.

Note importante : selon votre workflow, vous pourriez vouloir versionner export_presets.cfg (si vous exportez souvent et voulez partager les presets). Ici on reste sur une base simple et 'safe' pour debutant.

Etape 3 : premier commit

git add .
git commit -m "Version initiale (Main/Player/HUD)"

Puis verifiez :

git status

Si Git dit que tout est propre, c'est bon.
Si vous voyez .godot/ dans les fichiers suivis, votre .gitignore n'est pas en place au bon moment (il faut l'ajouter avant git add . ou retirer le suivi ensuite).

Routine Git minimale (si vous l'utilisez)
A la fin d'une session :

git add .
git commit -m "Update"

Ce n'est pas parfait, mais c'est deja un filet de securite.

9) Pieges frequents (si tu vois X, c'est souvent Y)

  • Textures manquantes / scripts introuvables : fichiers renommes ou deplaces hors de Godot (explorateur Windows/Mac).
  • Deux scenes quasi identiques et tu ne sais plus laquelle est la bonne : variantes mal nommees. Solution : nom clair (_test, _wip, date) et supprimer les variantes inutiles quand c'est valide.
  • 'Godot n'a pas sauvegarde' : tu as sauvegarde une scene, mais pas celle que tu modifiais, ou tu as oublie project.godot apres un changement de configuration.
  • Repo Git enorme : .godot/ ou imports inclus par erreur.
  • Reimport long a chaque ouverture : normal si tu as supprime .godot/ ou modifie beaucoup d'assets. Ce n'est pas un bug, c'est la regeneration du cache.

10) Exercices (1 facile + 1 challenge)

Exercice facile : creer une copie de sauvegarde restaurable

  1. Fermez Godot.
  2. Creez un dossier Backups/ (en dehors du projet).
  3. Copiez le dossier du projet vers Backups/MonProjet_backup1/.
  4. Dans MonProjet_backup1/, supprimez .godot/.
  5. Ouvrez MonProjet_backup1/ avec Godot.
  6. Lancez la scene principale (F5) ou la scene courante (F6).

Reussite : le projet s'ouvre, tourne, et vous retrouvez vos scenes Main/Player/HUD.

Challenge : ecrire CHECKLIST_PROJET.md (5 lignes)

Creez un fichier CHECKLIST_PROJET.md a la racine du projet, avec exactement 5 lignes, comme ceci :

- [ ] Je sauvegarde la scene active (Ctrl+S) et je verifie que c'est la bonne.
- [ ] Je teste vite (F6 ou F5) apres un changement important.
- [ ] Je ne deplace/renomme jamais hors de Godot (FileSystem uniquement).
- [ ] Je fais une copie datee dans Backups (sans .godot/) et je l'ouvre une fois.
- [ ] Si j'utilise Git : .gitignore OK, git add ., git commit -m 'Update'.

11) Recap + checklist finale + mini quiz

Checklist 'fin de session'

  • Toutes les scenes modifiees sont sauvegardees (Ctrl+S).
  • Le projet a ete teste (F5 ou F6).
  • Un backup date existe (et idealement teste en ouvrant la copie).
  • Aucun fichier n'a ete deplace/renomme hors de Godot.
  • Si Git est utilise : commit propre + .gitignore correct.

Mini quiz (pour verifier que c'est acquis)

  1. Quelle est la difference entre Save et Save As ?
  2. Pourquoi .godot/ n'est generalement pas versionne dans Git ?
  3. Qu'est-ce qui prouve qu'un backup est bon ?
  4. Tu veux renommer un script Player.gd : tu le fais ou, et pourquoi ?
  5. Tu viens de refaire le mouvement du Player : quels reflexes appliques-tu juste apres ?

12) Pont vers le module suivant (sans spoiler)

Maintenant que votre projet est protege par de bons reflexes, vous pouvez avancer sans cette peur en fond ('et si je casse tout ?'). Le prochain module sera le bon moment pour attaquer des scripts basiques cote Player, tester souvent, et progresser vite sans vous retrouver bloque par une catastrophe evitables.

Articles similaires