reset levels directory without it translations

2024-11-15 19:04:57 +01:00 · 2022-08-18 14:40:30 +02:00 · 2022-08-18 14:40:30 +02:00 · e80596219a
commit e80596219a
parent 07d33339cc
208 changed files with 193 additions and 3511 deletions
--- a/levels/en/bisect/bisect
+++ b/levels/en/bisect/bisect
--- a/levels/en/bisect/sequence
+++ b/levels/en/bisect/sequence
--- a/levels/en/branches/branch-create
+++ b/levels/en/branches/branch-create
--- a/levels/en/branches/branch-remove
+++ b/levels/en/branches/branch-remove
--- a/levels/en/branches/checkout-commit
+++ b/levels/en/branches/checkout-commit
--- a/levels/en/branches/fork
+++ b/levels/en/branches/fork
--- a/levels/en/branches/grow
+++ b/levels/en/branches/grow
--- a/levels/en/branches/reorder
+++ b/levels/en/branches/reorder
--- a/levels/en/branches/sequence
+++ b/levels/en/branches/sequence
--- a/levels/en/changing-the-past/rebase
+++ b/levels/en/changing-the-past/rebase
--- a/levels/en/changing-the-past/reorder
+++ b/levels/en/changing-the-past/reorder
--- a/levels/en/changing-the-past/sequence
+++ b/levels/en/changing-the-past/sequence
--- a/levels/en/files/files-add
+++ b/levels/en/files/files-add
--- a/levels/en/files/files-delete
+++ b/levels/en/files/files-delete
--- a/levels/en/files/sequence
+++ b/levels/en/files/sequence
--- a/levels/en/index/add
+++ b/levels/en/index/add
--- a/levels/en/index/change
+++ b/levels/en/index/change
--- a/levels/en/index/checkout
+++ b/levels/en/index/checkout
--- a/levels/en/index/compare
+++ b/levels/en/index/compare
--- a/levels/en/index/new
+++ b/levels/en/index/new
--- a/levels/en/index/reset
+++ b/levels/en/index/reset
--- a/levels/en/index/rm
+++ b/levels/en/index/rm
--- a/levels/en/index/sequence
+++ b/levels/en/index/sequence
--- a/levels/en/index/steps
+++ b/levels/en/index/steps
--- a/levels/en/intro/cli
+++ b/levels/en/intro/cli
--- a/levels/en/intro/commit
+++ b/levels/en/intro/commit
--- a/levels/en/intro/copies
+++ b/levels/en/intro/copies
--- a/levels/en/intro/init
+++ b/levels/en/intro/init
--- a/levels/en/intro/remote
+++ b/levels/en/intro/remote
--- a/levels/en/intro/risky
+++ b/levels/en/intro/risky
--- a/levels/en/intro/sequence
+++ b/levels/en/intro/sequence
--- a/levels/en/intro/who-are-you
+++ b/levels/en/intro/who-are-you
--- a/levels/it/bisect/bisect
+++ b/levels/it/bisect/bisect
@ -1,43 +0,0 @@
 title = Strada di mattoni gialli
 cards = checkout commit-auto reset-hard bisect-start bisect-good bisect-bad
 [description]
 (Perpiacere rimpicciolisci un pochino usando la rotella del mouse! :D)
 Oh no! Hai perso la tua chiave da qualche parte durante il giorno!
 Sicuro, certo potresti guardare in ogni singolo commit nella speranza di trovarlo - ma c'è un modo migliore: la tua macchina del tempo ha un modo integrato per trovare velocemente il punto nel tempo dove le cose sono andate male!
 Per prima cosa, gioca la carta "bisec start". Quindi, vai ad un commit in cui non hai la chiave e gioca la carta "bisect bad". Allo stesso modo vai velocemente in un commit dove hai la chiave *in tascca* e gioca la carta "bisect goofìd".
 Dopo aver trovato l'ultimo commit valido reimposta la branch principale su di esso. Cosa è successo alla chiave dopo che l'hai persa?
 [setup]
 echo "Hai ancora la tua chiave." > you
 for i in {1..30}; do
    if test $i -eq 12; then
        echo "La tua tasca è vuota." > you
        echo "E' per terra." > key
    fi
    if test $i -eq 13; then
        echo "Tiene una chiave nel becco." > bird
        rm key
    fi
    if test $i -eq 14; then
        rm bird
    fi
    git add .
    git commit --allow-empty -m "$i"
 done
 [win]
 # Trova l'ultimo commit buono
 test "$(git log --pretty=%s main | head -1)" -eq 11
 [congrats]
 Molto bene! :) L'unico problema è che adesso devi tornare a casa camminando, dinuovo...
--- a/levels/it/bisect/sequence
+++ b/levels/it/bisect/sequence
@ -1 +0,0 @@
 bisect
--- a/levels/it/branches/branch-create
+++ b/levels/it/branches/branch-create
@ -1,44 +0,0 @@
 title = Creare ramificazioni
 cards = checkout commit-auto branch branch-delete reset-hard
 [description]
 Vieni invitato a due feste! In una di queste, suona il tuo gruppo preferito e l'altra è la festa del tuo miglio amico. Dove andrai? Non preoccuparti - come agente del viaggio nel tempo, puoi andare ad entrambe le feste!
 Per rendere più facile dire quale sia la linea temporale, puoi creare portali temporali! (Chiamiamoli "rami-branchs")
 [cli]
 Anche viaggiare tra differenti rami temporali è davvero facile usando la linea di comando! Hai un ramo chiamato "birthday", puoi digitare `git checkout birthday` per arrivarci.
 [setup]
 echo "Incarta il regalo di compleanno e prendi il biglietto del concerto." > you
 git add .
 git commit -m "Preparazione serale"
 echo "Vai alla festa di compleanno!" >> you
 git add .
 git commit -m "Vai al compleanno"
 git checkout HEAD~1
 echo "Vai al concerto!" > you
 git add .
 git commit -m "Vai al concerto"
 git checkout HEAD~1
 git branch -D main
 [win]
 # Crea un ramo chiamato 'birthday' questo punta alla linea temporale del compleanno
 git show birthday | grep 'birthday'
 # Crea un ramo chiamato 'concert' questo punta alla linea temporale del compleanno
 git show concert | grep 'concert'
 [congrats]
 Adesso tu puoi viaggiare tra quie rami facilmente (usando `git checkout`) - Prova!
 Il tuo amico è felice che tu sia andato alla sua festa di compleanno e anche tu sei contento del biglietto del concerto firmato. Yay!
--- a/levels/it/branches/branch-remove
+++ b/levels/it/branches/branch-remove
@ -1,47 +0,0 @@
 title = Cancellare rami
 cards = checkout commit-auto reset-hard branch-delete
 [description]
 La vita è piena di pericolim, vero? Anche quando cammini a scuola2, sembra che ci siano molti rischi!
 Questo Lunedì è particolarmente brutto.Sei arrivato a scuola ma ci sono delle line temporali che tu non vuoi tenere in giro
 [setup]
 echo Esci di casa e ti incammini verso la scuola. > you
 git add .
 git commit -m "Buon giorno!"
 echo Cammini nel lato destro della strada. >> you
 git commit -am "Lato destro"
 echo Salti in un tombino nel marciapiede e arrivi in orario a scuola. >> you
 git commit -am "Salto"
 git checkout HEAD^ -b friend
 echo "All'improvviso cadi in una pozzanghera puzzolente e vieni mangiato da degli alligatori." >> you
 git commit -am "Un nuovo amico"
 git checkout HEAD~2 -b music
 echo Cammini nel lato sinistro della strada. >> you
 git commit -am "Lato sinistro"
 echo Siccome sei in ritardo, inizi a corre ma qualcuno lanci un pianoforte dalla finestra e ti schiacci. >> you
 git commit -am "Bei suoni"
 git checkout HEAD^ -b ice-cream
 echo Non sei preoccupato e cammini lentamente. Prendi anche un gelato per strada. Arrivi troppo tardi a scuola, il tuo insegnante è arrabbiato e vieni espulso da scuola. >> you
 git commit -am "Yum"
 git branch -M main leap
 git checkout leap^^
 [win]
 # Trova i rami cattivi e cancellali. Tieni solo il migliore.
 test "$(git show-ref --heads | cut -f2 -d' ')" = "$(echo refs/heads/leap)"
 [congrats]
 Ripensandoci preferisci la linea temporale del gelato? :)
--- a/levels/it/branches/checkout-commit
+++ b/levels/it/branches/checkout-commit
@ -1,43 +0,0 @@
 title = Muoversi attraverso il tempo
 cards = checkout commit-auto
 [description]
 La scatole gialle sono un punto fisso nel tempo, possiamo chiamarli "commits"! Puoi viaggiare tra loro usando la carta "checkout"! (Provala!)
 Puoi scoprire cosa è successo qui? Quindi, durante ultimo commit, modifica i files per risolvere il problema ed invia un nuovo commit!
 [cli]
 Guarda uno specifico commit, digita `git checkout` uno spazio e premi il tasto destro sopra il commit che vuoi!
 Questo inserirà l'identificatore unico del commit!
 [setup]
 echo "Questo salvadanaio appartiene alla sorella maggiore.
 Contiene 10 monete." > piggy_bank
 git add .
 git commit -m "L'inizio"
 echo "Una giovane donna con capelli, ricci, marroni." > little_sister
 git add .
 git commit -m "La sorella piccola è arrivata"
 echo "Ha 10 monete." >> little_sister
 echo "Questo salvadanaio appartiene alla sorella maggiore.
 E' vuoto." > piggy_bank
 git add .
 git commit -m "La sorella piccola ha fatto qualcosa"
 git checkout HEAD^^
 git branch -df main
 [win]
 # Ripristina il salvadanaio della sorella.
 { git show HEAD:piggy_bank | grep "10 monete"; } && { git show HEAD:little_sister | grep -v "10 monete"; } && { git rev-parse HEAD^^^; }
 [congrats]
 Stupendo! Adesso hai preso famiglirità con la macchina del tempo, vediamo situazioni più complicate...
--- a/levels/it/branches/fork
+++ b/levels/it/branches/fork
@ -1,65 +0,0 @@
 title = Crea universi paralleli
 cards = checkout commit-auto
 [description]
 Sai che creare line temporali parallele è perfettamente legale e sicuro? Vero!
 Puoi scoprire qundo le cose sono andate male in questo zoo? Poi torna all'ultimo momento buono e crea un universo parallelo dove sono tutti felicy!
 [cli]
 L'animale blue rappresenta un concetto conosciuto come "HEAD pointer" in Git: Ti mostra qual'è il commit attuale.
 Ecco un simpatico trucchetto andare al commit precedente:
    git checkout HEAD^
 Puoi anche andare indietro di 2 commit digitando, pre esempio:
    git checkout HEAD~2
 [setup]
 mkdir cage
 echo "Sembra molto affamato." > cage/lion
 echo "Un ragazzino..
 Ama veramente i gatti!" > child
 git add .
 git commit -m "L'inizio"
 echo "Tiene in mano un leccalecca." >> child
 git commit -am "Il ragazzo compra qualcosa"
 mv child cage
 git add .
 git commit -m "Il bambino si arrampica da qualche parte"
 git rm cage/child
 echo "E' felice. :)" > cage/lion
 git add .
 git commit -m "Oh no"
 echo "Sta dormendo." > cage/lion
 git add .
 git commit -m "Ora del pisolino!"
 git checkout --detach
 git branch -d main
 [win]
 # Assicurati che il ragazzino sia felice.
 git ls-tree --name-only -r HEAD | grep child
 # Assicurati che il leone abbia qualcosa da mangiare.
 git show HEAD:cage/lion | grep -v "molto affamato"
 [congrats]
 Whew, ottimo lavoro! Questo sembra un risultato molto migliore.
 Sentiti libero di aggiungere altre line temporali parallele o allungarle.
 Se sei pronto, la prossima missione ci sta aspettando...
--- a/levels/it/branches/grow
+++ b/levels/it/branches/grow
@ -1,48 +0,0 @@
 title = I rami crescono con tè!
 cards = checkout commit-auto branch branch-delete reset-hard
 [description]
 Nota che ci sono due opzioni per "viaggire fino alla fine della linea temporale":
 Primo, puoi direttamente viaggiare al commit, come abbiamo fatto prima.
 e secondo, puoi viaggiare fino all'etichetta del ramo. In questo caso, quando crei un nuovo commit, il ramo cresce con te e punta ancora alla fine della linea temporale!
 [cli]
 Per viaggire in un ramo, digita `git checkout name_of_the_branch`.
 e per viaggiare all'ultimo commit, digita `git checkout --detach name_of_the_branch`.
 [setup]
 echo "In carti il regalo di complanno e prendi il biglietto del concerto." > you
 git add .
 git commit -m "Preparazioni della sera"
 echo "Vai alla festa di compleanno!" >> you
 git add .
 git commit -m "Vai alla festa di compleanno"
 git branch birthday
 git checkout HEAD~1
 echo "Vai al concerto!" > you
 git add .
 git commit -m "Vai al concerto"
 git branch concert
 git checkout HEAD~1
 git branch -D main
 [win]
 # Viaggi direttamente all'ultimo commit giallo della line temporale del compleanno, fai un cambiamento per te e crea un commit
 for commit in $(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep 'commit$' | cut -f1 -d' '); do
    if test $(git rev-parse $commit^) = $(git rev-parse birthday); then
        return 0
    fi
 done
 return 1
 # Viaggi fino al ramo, blue, del concerto, fai un cambiamento ed un commit.
 git show concert^ | grep "Vai al concerto"
--- a/levels/it/branches/reorder
+++ b/levels/it/branches/reorder
@ -1,89 +0,0 @@
 title = Muovere i rami
 cards = checkout commit-auto merge reset-hard
 [description]
 Uno dei tuoi colleghi ha fatto un casino qui e ha messo le branches nelle line temporali sbagliate!
 Potresti cancellare e ricreare queste branches - ma puoi anche muoverle direttamente in un differente commit usando:
    git checkout
 nel nome della branch e poi usare
    git reset --hard
 nel commit dove vuoi che la branch vada.
 La ciambella è nella branch giusto ma la linea temporale è incompleta - fai *mangiare* la ciambella a quella branch!
 [setup]
 echo "Tu non hai una baguette.
 Non hai un caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "L'inizio"
 git checkout -b coffee
 echo "Tu hai una baguette.
 Non hai un caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Compri una ciambella"
 echo "Mangi una baguette.
 Non hai un caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Mangi una baguette"
 git checkout -b baguette main
 echo "Non hai una ciambella.
 Hai un caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Compri un pò di caffe"
 echo "Non hai una baguette.
 Hai bevuto caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Bevi il caffe"
 git checkout -b donut main
 echo "Non hai una baguette.
 Non hai caffe.
 Hai una ciambella." > you
 git add .
 git commit -m "Compri una ciambella"
 git checkout --detach main
 [win]
 # Mangi una baguette nella branch delle baguette?
 git show baguette:you | grep "Mangi.*baguette"
 # Bevi un caffe nella branch del caffe?
 git show coffee:you | grep "Bevi.*coffe"
 # Mangi una ciambella nella branch delle ciambelle?
 git show donut:you | grep "Mangi.*ciambella"
 [actions]
 test "$(git rev-parse HEAD^)" = "$(git rev-parse donut)" && hint "Ricordati di controllare l'etichetta branch blue quando vuoi che cresca con la linea temporale."
--- a/levels/it/branches/sequence
+++ b/levels/it/branches/sequence
@ -1,6 +0,0 @@
 checkout-commit
 fork
 branch-create
 grow
 branch-remove
 reorder
--- a/levels/it/changing-the-past/rebase
+++ b/levels/it/changing-the-past/rebase
@ -1,86 +0,0 @@
 title = Rebasing
 cards = checkout commit-auto reset-hard rebase
 [description]
 Okay - Salta vuori che risparmiare tempo al mattino utilizzando universi paralleli è contro il regolamento dell'International Time Travel Association. Dovrai svolgere i tuoi compiti in sequenza dopotutto.
 Vedi la carta "rebase"? Quando la trascini su di un commit, copierà dopo di esso tutti gli eventi della linea temporale su cui ti trovi! In questo modo crei una linea temporale chiara e pulita dove visiti tutti e tre i negozzi.
 Nuovamente, vogliamo rendere questa la nostra realtà di base - il ramo "main" dovrebbe puntare a quella linea temporale!
 [setup]
 echo "Non hai una baguette.
 Non hai caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "L'inizio"
 git checkout -b baguette main
 echo "Hai una baguette.
 Non hai caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Compri una baguette"
 echo "Mangi una baguette.
 Non hai caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Mangi la baguette"
 git checkout -b coffee main
 echo "Non hai una baguette.
 Hai del caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Compri un pò di caffe"
 echo "Non hai una baguette.
 Hai bevuto caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Bevi il caffe"
 git checkout -b donut main
 echo "Non hai una baguette
 Non hai caffe.
 Hai una ciamebella." > you
 git add .
 git commit -m "Compri una ciambella"
 echo "Non hai una baguette.
 Non hai caffe.
 Mangi una ciambella." > you
 git add .
 git commit -m "Mangi la ciambella"
 git checkout --detach main
 [win]
 # Ordina le tre ramificazioni in una e muovi il riferimento al ramo principale
 { git show main:you | grep "Mangi.*baguette"; } && { git show main:you | grep "bevuto.*caffe"; } && { git show main:you | grep "Mangi.*ciambella"; } && { test "$(git log main --oneline | wc -l)" -eq 7; }
 [congrats]
 Nota come gli altri commit e linee temporali siano ancora li - se qualcosa va storto, puoi ancora tornare in dietro.
 E' davvero difficile *distruggere* le cose con la tua macchina del tempo.
--- a/levels/it/changing-the-past/reorder
+++ b/levels/it/changing-the-past/reorder
@ -1,77 +0,0 @@
 title = Riordinare gli eventi
 cards = checkout commit-auto reset-hard rebase-interactive cherry-pick
 [description]
 Oops, guarda c'è qualcosa di incasinato qui. Puoi rimettere gli eventi nel corretto ordine?
 Ci sono due modi per farlo: Puoi trascinare la carta "interactive rebase" sul commit precedente a quello che vuoi cambiare, poi riordinare le linee nel file che si apre e salvarlo.
 Oppure puoi reimpostare il tag principale al primo commit, quindi selezionare i singoli commit (cherry-pick) nell'ordine desiderato. Hai carte per entrambe i modi!
 [setup]
 echo "Ti sei appena svegliato.
 Non indossi biancheria intima.
 Non indossi pantaloni.
 Non indossi la maglia.
 Non indossi le scarpe." > you
 git add .
 git commit -m "L'inizio"
 echo "Ti sei appena svegliato.
 Non indossi biancheria intima.
 Non indossi pantaloni.
 Non indossi la maglia.
 Indossi le scarpe." > you
 git commit -am "Metti le scarpe"
 echo "Ti sei appena svegliato.
 Non indossi biancheria intima.
 Indossi pantaloni.
 Non indossi la maglia.
 Indossi le scarpe." > you
 git commit -am "Metti i pantaloni"
 echo "Ti sei appena svegliato.
 Indossi la biancheria intima.
 Indossi pantaloni.
 Non indossi la maglia.
 Indossi le scarpe." > you
 git commit -am "Metti biancheria intima"
 echo "Ti sei appena svegliato.
 Indossi biancheria intima.
 Indossi pantaloni.
 Indossi la maglia.
 Indossi le scarpe." > you
 git commit -am "Ti metti la maglia"
 [win]
 # Riordina i commit per vestirti nel modo corretto
 { git log main --oneline | perl -0777 -ne'exit(1) if not /scarpe[\s\S]*pantaloni[\s\S]*biancheria/'; } && { test "$(git log main --oneline | wc -l)" -eq 5; }
 [congrats]
 Sentiti libero di resettare il livello e provare l'altra strategia! Qual'è quella che preferisci?
--- a/levels/it/changing-the-past/sequence
+++ b/levels/it/changing-the-past/sequence
@ -1,2 +0,0 @@
 rebase
 reorder
--- a/levels/it/files/files-add
+++ b/levels/it/files/files-add
@ -1,31 +0,0 @@
 title = Arredatore di interni
 cards = file-new file-delete
 [description]
 Ora che la tua stanza sembra in ordine, puoi iniziare a disfare le tue cose. Hai portato con te due mobili nuovi e con un sorriso luminoso,
 vedi che i loro colori corrispondono al colore del tuo letto!
 Costruisci i tuoi due mobili usando la carta touch.
 Quindi dai il nome ai tuoi mobili - puoi sciegliere quello che tu vuoi.
 Assicurati che i colori siano uguali! Puoi trovare il colore del letto nella descrizione.
 Non dimenticare di aggiungere un colore e una descrizione anche ai tuoi nuovi mobile.
 [setup]
 echo Un accogliente letto giallo. > bed
 [win]
 # Aggiungi altri due mobili
 NUM_FILES="$(ls | wc -l)"
 test "$NUM_FILES" -ge 3
 # Assicurati che i colori corrispondano a quelle del tuo letto
 NUM_FILES="$(ls | wc -l)"
 YELLOW_FILES="$(grep -li giallo * | wc -l)"
 test "$NUM_FILES" -ge 2 && test "$YELLOW_FILES" = "$NUM_FILES"
 [congrats]
 Non ti senti già più a casa?
--- a/levels/it/files/files-delete
+++ b/levels/it/files/files-delete
@ -1,36 +0,0 @@
 title = Coinquilini inaspettati
 cards = file-delete
 [description]
 Il primo giorno alla Scuola del viaggio nel tempo sta per finire e tu ricevi le chiavi della tua stanza.
 Eccitatissimo apri la porta giusto per vedere... ragnatele! Ragnatele ovunque!
 Cava tutte le ragnatele che puoi trovare con la carta remove!
 [cli]
 Nella line di comando, puoi facilmente eliminare tutti i file che finiscono in "web" usando il comando:
    rm *web
 [setup]
 echo Una piccola ragnatela è accanto alla tua finestra. > tiny_web
 echo Una grande ragnatela attaccata sopra al tuo letto. > big_web
 echo Un letto accogliente. > bed
 echo Una ragnatela spessa è alla destra della tua porta. > thick_web
 [win]
 # Rimuovi tutte le ragnatele.
 ! ls | grep thick_web &&
 ! ls | grep big_web &&
 ! ls | grep tiny_web
 # Ma assicurati di mantenere il tuo letto!
 ls | grep bed
 [congrats]
 Guarda la tua stanza adesso è davvero ordinata ed accogliente! Il momento per disfare le valige!
--- a/levels/it/files/sequence
+++ b/levels/it/files/sequence
@ -1,3 +0,0 @@
 files-delete
 files-add
--- a/levels/it/index/#sequence#
+++ b/levels/it/index/#sequence#
@ -1,5 +0,0 @@
 compare
 new
 change
 reset
 steps
--- a/levels/it/index/add
+++ b/levels/it/index/add
@ -1,38 +0,0 @@
 title = Updating files in the index
 cards = add commit checkout
 [description]
 So you start working, and make changes to your files! Git lets you choose which of these changes you want to put in the next commit. This is like updating the index version of that file to the new version.
 This allows you to have smaller commits, that describe better what you changed!
 The command for this is the same - `git add`!
 [setup]
 echo a > a
 echo b > b
 echo c > c
 git add .
 git commit -m "Initial commit"
 [win]
 # Make changes to all files!
 test "$(cat a)" != "a" &&
 test "$(cat b)" != "b" &&
 test "$(cat c)" != "c"
 # Add only the changes of a and c, and make a commit! Finally, make a commit which captures the changes in b!
 test "$(git show main:a)" != "a" &&
 test "$(git show main:b)" != "b" &&
 test "$(git show main:c)" != "c" &&
 test "$(git show main^:a)" != "a" &&
 test "$(git show main^:b)" == "b" &&
 test "$(git show main^:c)" != "c"
 [congrats]
 Well done! Try tavelling between the commits using `git checkout`, so you can look at their contents again!
--- a/levels/it/index/change
+++ b/levels/it/index/change
@ -1,31 +0,0 @@
 title = Aggiornare i file nell'indice
 cards = add commit
 [description]
 Quando cambiamo i files l'indice non cambia da solo. Dobbiamo usare `git add` per aggiornare l'indice alla nuova versione del file..
 Proviamoci!
 Le icone nel file manager ti mostrano quando il file attuale (bianco) e la versione nell'indice (blu) differiscono o sono uguali!
 [win]
 Bene! L'indice è anche chiamato "staging area" (area di staging) - E contiene esattamente ciò che finisce nel prossimo commit quando usi `git commit`!
 [setup]
 echo "La candela brucia con una fiamma blu." > candle
 git add .
 git commit -m "L'inizio"
 [win]
 # Fai una modifica alla candela
 test "$(git diff --name-only)" = "candle" || file -f .git/candle-changed && touch .git/candle-changed
 # Aggiungi la candella.
 test "$(git diff --cached --name-only)" = "candle" || file -f .git/candle-added && touch .git/candle-added
 # Fai un commit.
 test "$(git diff --name-only HEAD HEAD^)" = "candle"
--- a/levels/it/index/checkout
+++ b/levels/it/index/checkout
@ -1,25 +0,0 @@
 title = Checking out files from the index
 cards = add reset-file checkout-file commit
 [description]
 So you've made changes to your files, but you decide that you don't want to keep them! You can use `git checkout` for that!
 What happens if you have already update the index, like in file c? You have to reset the index first!
 [setup]
 echo a > a
 echo b > b
 echo c > c
 git add .
 git commit -m "Initial commit"
 echo x > a
 echo x > b
 echo x > c
 git add c
 [win]
 # Remove all changes in your local files!
 test "$(git diff --name-only | wc -l)" -eq 0
--- a/levels/it/index/compare
+++ b/levels/it/index/compare
@ -1,51 +0,0 @@
 title = Passo dopo passo
 cards = checkout commit-auto
 [description]
 Benvenuto! nella lezione di oggi impareremo come creare commits con più precisione!
 Dai un'occhiata a queste due linee temporali. Hanno lo stesso risultato, ma in una delle due è molto più semplice capire cosa è successo.
 [win]
 # Esatto! Avere ogni cambiamento nel proprio commit rende più facile capire cosa sta succedendo!
 git branch --show-current | grep step-by-step
 [setup]
 echo "Una piccola ma pesante palla di vetro." > ball
 echo "Un sottile libro che sta in piedi." > book
 echo "Una candela brucia con una fiamma blu." > candle
 echo "Un sensore di fumo. E' assolutamente silenzioso." > smoke_detector
 git add .
 git commit -m "L'inizio"
 git branch -M all-at-once
 echo "La palla adesso tocca il libro." > ball
 echo "Il libro è caduto." > book
 echo "La candella è stata spenta." > candle
 git commit -am "La fine"
 git checkout HEAD^
 git checkout -b step-by-step
 echo "La palla adesso tocca il libro." > ball
 git commit -am "La palla rotola verso il libro"
 echo "Il libro è caduto." > book
 git commit -am "Il libro è caduto"
 echo "La candela è stata spenta." > candle
 git commit -am "Il libro ha spento la candela"
 git checkout HEAD~3
 [win]
 # Prendi la sequenza temporale più chiara e fai suonare il sensore di fumo!
 git show step-by-step:smoke_detector | tail -n 1 | grep -v "assolutamente silenzioso"
--- a/levels/it/index/new
+++ b/levels/it/index/new
@ -1,28 +0,0 @@
 title = Aggiungere nuovi file all'indice
 cards = add commit
 [description]
 Finora, quando abbiamo eseguito un commit abbiamo sempre registrato lo stato di tutti gli oggetti, vero?
 Ma Git ti permette di scegliere i cambiamenti che si vogliono mettere in un commit!
 Per sapere come funziona, dobbiamo conoscere l'"indice"! Nell'indice, possiamo preparare ciò che sarà nel prossimo commit. In questo gioco, l'indice è rappresentato da un'aura blu attorno alle icone nel file manager!
 Inizialmente, l'indice è vuoto. Per fare un commit che contenga un nuovo file, dobbiamo aggiungerlo!
 [cli]
 Puoi usare il completamento con la tabulazione nel terminale! Inizia a scrivere il nome di un file e premi il tasto tab per completarlo. Così risparmi tempo!
 [setup]
 echo "La candela brucia con una fiamma blu." > candle
 [win]
 # Aggiungi la candela.
 test "$(git diff --cached --name-only)" = "candle" || file -f .git/candle-added && touch .git/candle-added
 # Crea un commit.
 test "$(git ls-tree --name-only HEAD)" = "candle"
--- a/levels/it/index/reset
+++ b/levels/it/index/reset
@ -1,37 +0,0 @@
 title = Resettare i file nell'indice
 cards = add reset-file commit
 [description]
 Vedi l'ombra scura dietro le icone? Questa è la versione del file nell'ultimo commit!
 Per esempio, queste candele sono state spente e quella modifica è stata aggiunta!
 Ma è stato un errore! Vuoi solo spegnere al candela rossa nel prossimo commit!
 Se hai già aggiunto un file modificato all'indice ma vuoi ripristinarlo, puoi usare `git reset`!
 [setup]
 echo "Sta bruciando!" > red_candle
 echo "Sta bruciando!" > green_candle
 echo "Sta bruciando!" > blue_candle
 git add .
 git commit -m "L'inizio"
 echo "È stata spenta." > red_candle
 echo "È stata spenta." > green_candle
 echo "È stata spenta." > blue_candle
 git add .
 [win]
 # Ripristina i cambiamenti nella candela verde e in quella blu!
 git show :green_candle | grep burning &&
 git show :blue_candle | grep burning &&
 git show :red_candle | grep -v burning
 # E fai un commit
 git show main:green_candle | grep burning &&
 git show main:blue_candle | grep burning &&
 git show main:red_candle | grep -v burning
--- a/levels/it/index/rm
+++ b/levels/it/index/rm
@ -1,24 +0,0 @@
 title = Delete a file in the next commit
 cards = add reset-file checkout-file rm file-delete commit
 [description]
 If you want to remove a file in the next commit, you can use `git rm`! This will both delete the file locally, and in the index.
 If a file is modified, you'll need to reset these changes first/reset the files.
 [setup]
 echo a > a
 echo x > b
 echo x > c
 git add .
 git commit -m "Initial commit"
 echo x > a
 echo b > b
 git add b
 [win]
 # Make a commit where all files are deleted ¯\_(^_^)_/¯
 test "$(git ls-tree main | wc -l)" -eq 0
--- a/levels/it/index/sequence
+++ b/levels/it/index/sequence
@ -1,5 +0,0 @@
 compare
 new
 change
 reset
 steps
--- a/levels/it/index/steps
+++ b/levels/it/index/steps
@ -1,53 +0,0 @@
 title = Aggiungere le modifice una per volta
 cards = add reset-file commit
 [description]
 L'indice è veramente utile perché ci permette di essere precisi su quali cambiamenti vogliamo includere in ogni commit!
 [setup]
 echo "Un martello, in equilibrio sul suo manico." > hammer
 echo "Una bottiglia contenente un liquido trasparente." > bottle
 echo "Un cubetto di zucchero bianco." > sugar_cube
 git add .
 git commit -m "L'inizio"
 [win]
 # Fai dei cambiamenti a tutti e tre gli oggetti per creare una sequenza logica di eventi!
 test "$(git diff --name-only | wc -l)" -eq 3 || file -f .git/candle-changed && touch .git/candle-changed
 # Aggiungi solo uno dei cambiamenti!
 test "$(git diff --cached --name-only | wc -l)" -eq 1 || file -f .git/candle-added && touch .git/candle-added
 # E fai un commit
 COUNT=0
 for commit in $(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep 'commit$' | cut -f1 -d' '); do
    if test "$(git diff --name-only $commit $commit^ | wc -l)" -eq 1; then
        COUNT=$((COUNT+1))
    fi
 done
 test "$COUNT" -ge 1
 # Fai un secondo commit che registri solo un singolo cambiamento.
 COUNT=0
 for commit in $(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep 'commit$' | cut -f1 -d' '); do
    if test "$(git diff --name-only $commit $commit^ | wc -l)" -eq 1; then
        COUNT=$((COUNT+1))
    fi
 done
 test "$COUNT" -ge 2
 # E aggiungine un terzo.
 COUNT=0
 for commit in $(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep 'commit$' | cut -f1 -d' '); do
    if test "$(git diff --name-only $commit $commit^ | wc -l)" -eq 1; then
        COUNT=$((COUNT+1))
    fi
 done
 test "$COUNT" -ge 3
--- a/levels/it/intro/cli
+++ b/levels/it/intro/cli
@ -1,27 +0,0 @@
 title = La line di comando
 cards = 
 [description]
 Queste carte da gioco sono state disegnate per essere usate e ricordate facilmente! Ti consigliamo di attenerti a loro se non hai molta esperienza di Git!
 [cli]
 Ma c'è un'altra via per interagire con Git:
 Prova a digitare `git init` nel terminale qui sotto e premere il pulsante Enter!
 [setup]
 rm -rf .git
 [win]
 # Inizializza la macchina del tempo!
 test -d .git
 [congrats]
 Perfetto! Al posto di usare le carte da gioco, puoi anche fare tutto dalla line di comando!
 La line di comando e piuttosto potente! A volte, puoi usarla per risolvere le attività più velocemente che con l'interfaccia grafica.
--- a/levels/it/intro/commit
+++ b/levels/it/intro/commit
@ -1,32 +0,0 @@
 title = Il tuo primo commit!
 cards = commit-auto
 [description]
 Puoi usare la tua macchina del tempo per scattare istantanee degli oggetti intorno a te! Qui puoi metterlo in pratica!
 (Il tuo insegnante versa un pò di acqua nel bicchiere)
 [cli]
 Nuovamente, al posto di usare le carte, puoi scrivere i comandi, che sono stampati sulle carte, nel terminale in basso! 
 Questo è totalmente opzionale! Ma questa è una conoscenza super utile nel mondo reale - e ti farà avere un distintivo scintillante! :)
 [setup]
 echo "Il bicchiere è pieno di acqua." > glass
 [win]
 # Crea un'istantanea del bicchiere (un "commit")
 git rev-parse HEAD
 # Cambia il contenuto del bicchiere!
 ! test "$(cat glass)" = "Il bicchiere è pieno di acqua."
 # E crea un secondo "commit"!
 git rev-parse HEAD^ && ! test "$(git show main:glass)" = "Il bicchiere è bieno di acqua."
 [congrats]
 Perfetto! Puoi provare a creare altri "commit". Quando ti sentirai a posto, premi su "Next Level".
--- a/levels/it/intro/copies
+++ b/levels/it/intro/copies
@ -1,42 +0,0 @@
 title = Crea una copia
 cards =
 [description]
 Questa volta, stai facendo molte copie di backup - puoi guardarli cliccandoci sopra!
 [congrats]
 Okay, questo è un modo di lavorare.
 Ma sei preoccupato che ti ritroverai con centinaia di copie di questo modulo e sarà difficile tenerne traccia nel tempo.
 Specialmente quando lavori con altre persone, inviare copie avanti ed indietro non sembra l'ideale.
 Fermati, devi provare questa macchina del tempo!
 [setup]
 rm -rf .git
 echo "~ Perchè voglio imparare Git ~
 (Devo ancora scriverlo.)" >> form.txt
 echo "~ Perchè volgio imparare Git ~
 - Così posso annullare gli errori" >> form2.txt
 echo "~ Perchè volgio imparare Git ~
 - Così posso annullare gli errori
 - Per tracciare i mie progetti attraverso il tempo" >> form2_final.txt
 cp form2_final.txt form2_really_final.txt
 [win]
 # Aggiungi una nuova line al file form2_really_final.txt!
 test "$(cat form2_really_final.txt | wc -l )" -ge 5
--- a/levels/it/intro/init
+++ b/levels/it/intro/init
@ -1,24 +0,0 @@
 title = Entra nella machina del tempo
 cards = init
 [description]
 Sei stato accettato nella scuola della macchina del tempo! Questo è il tuo primo giorno! Il tuo insegnate ti spiega:
 "Per fare qualsiasi cosa con una macchina del tempo, devi prima inizializzarla!"
 Trascina quella carta blu verso l'alto per usarla!
 [setup]
 rm -rf .git
 [win]
 # Inizializzazione della macchina del tempo
 test -d .git
 [congrats]
 Perfetto! Vedi quel piccolo animale che è apparso? Sarà il tuo compagno e ti mostrerà dove ti trovi nel tempo!
--- a/levels/it/intro/remote
+++ b/levels/it/intro/remote
@ -1,52 +0,0 @@
 title = Dai lavoriamo tutti assieme
 cards = pull commit-auto push
 [description]
 Aggiungi il tuo nome nella nostra lista di studenti!
 Ho già un secondo "commit" nella mia macchina del tempo - Dai lavoriamo tutti assieme!
 [cli]
 Per tornare in dietro alle vecchie istruzioni, puoi premere la freccia in alto o in basso. In questo modo non devi digitare, nuovamente, le istruzioni.
 [congrats]
 Benvenuto nella scuola del viaggio nel tepo! :) Ci vediamo domani per la tua prima lezione!
 [setup]
 echo "~ Lista degli attuali studenti ~" > students
 git add .
 git commit -m "Versione iniziale"
 git push -u teacher main
 git update-ref -d refs/remotes/teacher/main
 [setup teacher]
 git reset --hard main
 echo " 
 - Sam
 - Alex" >> students
 git add .
 git commit -m "Aggiunti due studenti"
 [win]
 # Ottieni il secondo "commit" dal tuo insegnante usando `git pull`.
 test "$(git log --oneline teacher/main | wc -l)" -ge 2
 # Aggiungi il tuo nome alla lista degli studenti.
 test "$(cat students |wc -l)" -ge 5
 # Crea un'istantanea dei risultati.
 test "$(git show main:students |wc -l)" -ge 5
 [win teacher]
 # E usa `git push` per inviarlo al tuo insegnante!
 test "$(git show main:students |wc -l)" -ge 5
--- a/levels/it/intro/risky
+++ b/levels/it/intro/risky
@ -1,42 +0,0 @@
 title = Vivere è pericoloso
 cards =
 [description]
 Quindi hai deciso di fare domanda per la scuola di viaggio nel tempo, per usare la macchina del tempo chiamata "Git"!
 Che emozione!
 Hai quasi concluso le scartoffie! Devi solamente inserire un motivo per il quale vuoi imparare Git.
 [congrats]
 All'improvviso, il tuo gatto salta sul tavolo, strappa via il modulo, e scappa via! Oh no. Tutto il tuo duro lavoro, andato!
 Devi trovare una buona soluzione.
 (Premi "Prossimo livello" appena sei pronto!)
 [setup]
 rm -rf .git
 echo "~ Perchè voglio imparare Git ~
 - Così posso cancellare gli errori
 - Per seguire il mio progetto attraverso il tempo" >> form.txt
 [actions]
 test "$(cat form.txt | wc -l )" -ge 5 && echo "(E' stato rubato dal tuo gatto.)
 " > form.txt
 [win]
 # Aggiungi un'altra line a form.txt!
 test "$(cat form.txt | wc -l )" -ge 5
--- a/levels/it/intro/sequence
+++ b/levels/it/intro/sequence
@ -1,6 +0,0 @@
 risky
 copies
 init
 cli
 commit
 remote
--- a/levels/it/intro/who-are-you
+++ b/levels/it/intro/who-are-you
@ -1,38 +0,0 @@
 title = Benvenuto nella scuola del viaggio nel tempo!
 cards = config-name commit-auto checkout
 [description]
 Sei ancora confuso da tutto quello che sta succedendo. Il giorno seguente, decidi di iscriverti nella scuola del viaggio nel tempo!
 Il tuo insegnante del viaggio nel tempo ti saluta: "Ciao come va! Vuoi dirci il tuo nome?"
 [setup]
 git config --global user.name "TU"
 echo "~ Chi vuole imparare come si usa la macchina del tempo? ~
 [ ] Per essere sicuro che il mio gatto non mangi il mio lavoro.
 [ ] Così non devo tenere copie di tutti i miei saggi.
 [ ] Per collaborare con altri studenti del viaggio nel tempo.
 [ ] Altro, perfavore specifica:" > form
 [actions]
 test "$(git config user.name)" != "TU" && cat form | grep -v Signature && echo "
 Firma: $(git config user.name)" >> form
 [win]
 # Presentati.
 test "$(git config user.name)" != "TU"
 # Compila l'iscrizione e inviala!
 git show main:form | grep '\[[xX]\]'
 [congrats]
 "Siamo lieti di averti con noi!
 Git puoi aiutarti a correggere i problemi del passato! Ti aiuta a collaborare con gli studenti del viaggio nel tempo! E' davvero potente e e popolare! Ci vediamo domani per la tua prima lezione!"
--- a/levels/it/low-level/basics
+++ b/levels/it/low-level/basics
@ -1,26 +0,0 @@
 [description]
 For this prototype, we assume you have some experience with the command line. Here are some commands that will be useful:
 - ls
 - echo content > file
 - cat file
 - mkdir dir
 Find the riddle in your current directory and put the answer into the file "answer"!
 [congrats]
 Omnomnom!
 For technical reasons, you can't use `cd` in this prototype yet. But there won't be a lot of interaction with the file system anyways. :)
 [setup]
 mkdir riddle
 echo "ppl p" > riddle/consonants
 echo "ae ie" > riddle/vowels
 [win]
 cat answer | grep -i "apple \\?pie"
--- a/levels/it/low-level/blob-create
+++ b/levels/it/low-level/blob-create
@ -1,38 +0,0 @@
 [description]
 At its core, Git is very simple. It stores "objects", which are basically files identified by an "identifier" (short: ID).
 There are four types of objects: blobs, trees, commits, and tags. The simplest type is a "blob", which is just a piece of text.
 Let's create some blobs! To do that, create a file with the desired content, and then use
    git hash-object -w <file>
 The flag -w means "write", and tells Git to actually write the new blob to the disk.
 Create three new blobs!
 [congrats]
 Tip: You can also use a command like this to create a blob in a single line:
    echo "awesome content" | git hash-object -w --stdin
 Did you already notice that you can drag and drop all objects? :)
 [setup]
 [setup goal]
 echo "Hi" > file1
 echo "Ho" > file2
 echo "Hu" > file3
 git hash-object -w file1
 git hash-object -w file2
 git hash-object -w file3
 [win]
 BLOB_COUNT=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep blob | wc -l)
 test "$BLOB_COUNT" -gt 2
--- a/levels/it/low-level/blob-remove
+++ b/levels/it/low-level/blob-remove
@ -1,27 +0,0 @@
 [description]
 There's a simple command to remove all objects that are not referenced by anything:
    git prune
 Remove all blobs in this repository.
 [congrats]
 Generally, `git prune` will be useful if you want to clean up some objects you made.
 Alternatively, you can also click the "Reload" button to restart a level.
 [setup]
 echo "My master password is a1b2c3d4e5" | git hash-object -w --stdin
 echo "This blob really should not exist" | git hash-object -w --stdin
 echo "This is a virus" | git hash-object -w --stdin
 [setup goal]
 [win]
 OBJECT_COUNT=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | wc -l)
 test "$OBJECT_COUNT" -eq 0
--- a/levels/it/low-level/commit-create
+++ b/levels/it/low-level/commit-create
@ -1,37 +0,0 @@
 [description]
 So a tree describes a directory structure at a specific point in time.
 It would be nice if we could remember when that state existed, and who authored it, right?
 Enter: commits. They are objects that point to a tree and contain some additional metadata. You can create a commit using
    git commit-tree <tree> -m "Description of your commit"
 Make a commit from the tree in this repository!
 [setup]
 touch empty_file
 git add .
 git write-tree
 rm empty_file
 git update-index --remove empty_file
 [setup goal]
 touch empty_file
 git add .
 git write-tree
 rm empty_file
 git update-index --remove empty_file
 git commit-tree 3185 -m 'Clever commit message'
 [win]
 COMMIT_COUNT=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep commit | wc -l)
 test "$COMMIT_COUNT" -gt 0
--- a/levels/it/low-level/commit-parents
+++ b/levels/it/low-level/commit-parents
@ -1,31 +0,0 @@
 [description]
 When using the commit-tree command, you can optionally specify a parent:
    git commit-tree <tree> -m "Description" -p <parent commit>
 Make a string of three commits!
 Hint: You'll need a tree object. What could be the easiest way to obtain one?
 [setup]
 [setup goal]
 git write-tree
 FIRST_COMMIT=$(git commit-tree 4b82 -m 'First commit :O')
 SECOND_COMMIT=$(git commit-tree 4b82 -p $FIRST_COMMIT -m 'Second commit :D')
 THIRD_COMMIT=$(git commit-tree 4b82 -p $SECOND_COMMIT -m 'Third commit \o/')
 [win]
 COMMITS=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep commit | cut -f1 -d" ")
 for COMMIT in $COMMITS; do
    echo a commit named $COMMIT
    if [ $(git rev-list $COMMIT | wc -l) -ge 3 ]; then
        return 0
    fi
 done
 return 1
--- a/levels/it/low-level/commit-rhombus
+++ b/levels/it/low-level/commit-rhombus
@ -1,30 +0,0 @@
 [description]
 A commit can have multiple parents! You can specify the -p option multiple times, like this:
    git commit-tree <tree> -m "Description" -p <parent1> -p <parent2>
 Build a rhombus shape from commits, where two commits point to the same parent, and then a fourth commit points to both of them.
 [setup]
 [setup goal]
 TREE=$(git write-tree)
 SOUTH=$(git commit-tree $TREE -m "South")
 EAST=$(git commit-tree $TREE -m "East" -p $SOUTH)
 WEST=$(git commit-tree $TREE -m "West" -p $SOUTH)
 NORTH=$(git commit-tree $TREE -m "Nort" -p $EAST -p $WEST)
 [win]
 COMMITS=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep commit | cut -f1 -d" ")
 for COMMIT in $COMMITS; do
    # My first parent's parents has to be the same as my second parent's parent.
    if [ "$(git rev-parse --verify -q $COMMIT^1^)" = "$(git rev-parse --verify -q $COMMIT^2^)" ]; then
        return 0
    fi
 done
 return 1
--- a/levels/it/low-level/index-add
+++ b/levels/it/low-level/index-add
@ -1,37 +0,0 @@
 [description]
 Blobs usually represent the content of a file. But on their own, they don't have any metadata, not even a name!
 Git has a very powerful concept to store metadata related to blobs: the index! It's a list that relates blobs to filenames and access permissions.
 The most convenient option to add an entry to the index is via an existing file:
    echo "my content" > file
    git update-index --add file
 Add three entries to the index! For a bonus challenge: can you add a file that is inside of a directory, like "directory/file"?
 [congrats]
 There's another way to add an entry to the index directly:
    git update-index --add --cacheinfo <mode>,<blobhash>,<name>
 The first three numbers of the mode describe the type of the entry, "100" is a regular file.
 The second three number describe the permissions. Only "644" (non-executable) and "755" (executable) are supported.
 You can insert the hash of an object into the terminal by right-clicking on it! :)
 [setup]
 [setup goal]
 echo "file 1" > file1
 echo "file 2" > file2
 echo "file 3" > file3
 git add .
 [win]
 test "$(git ls-files | wc -l)" -ge 3
--- a/levels/it/low-level/index-remove
+++ b/levels/it/low-level/index-remove
@ -1,29 +0,0 @@
 [description]
 To remove an entry from the index, use a command like this:
    git update-index --force-remove <file>
 Remove all entries from the index!
 [setup]
 echo "file 1" > file1
 echo "file 2" > file2
 echo "file 3" > file3
 git add .
 [setup goal]
 echo "file 1" > file1
 echo "file 2" > file2
 echo "file 3" > file3
 git add .
 git update-index --force-remove file1
 git update-index --force-remove file2
 git update-index --force-remove file3
 [win]
 test "$(git ls-files | wc -l)" -eq 0
--- a/levels/it/low-level/index-update
+++ b/levels/it/low-level/index-update
@ -1,33 +0,0 @@
 [description]
 Instead of removing an entry from the index and adding one with the same name, you can also directly update that entry!
 Put the content you want in a file with a matching name, and then run
    git update-index <file>
 This will create a new blob, and update the hash of the entry to that blob.
 Update an entry in the index!
 [setup]
 echo "file 1" > file1
 echo "file 2" > file2
 echo "file 3" > file3
 git add .
 [setup goal]
 echo "file 1" > file1
 echo "file 2" > file2
 echo "file 3" > file3
 git add .
 echo "new content" > file1
 git update-index file1
 [win]
 # This is not really a good test for the winning condition...
 test "$(git ls-files -s | git hash-object --stdin)" != "10c4b28623e7e44e09f5a596450a50ab7ac31fbe" -a "$(git ls-files | wc -l)" -eq 3
--- a/levels/it/low-level/puzzle-apocalypse
+++ b/levels/it/low-level/puzzle-apocalypse
@ -1,41 +0,0 @@
 [description]
 Delete all objects in this repository using git commands only!
 Useful commands:
    git prune
    git reflog expire
 [setup]
 echo foo > foo
 BLOB=$(git hash-object -w foo)
 echo bar > bar
 git add .
 git commit -m "Initial commit"
 echo blabber >> bar
 git commit -a -m "Second commit"
 git update-ref refs/important HEAD
 git update-ref refs/interesting "$BLOB"
 [setup goal]
 echo foo > foo
 BLOB=$(git hash-object -w foo)
 echo bar > bar
 git add .
 git commit -m "Initial commit"
 echo blabber >> bar
 git commit -a -m "Second commit"
 git update-ref refs/important HEAD
 git update-ref refs/interesting "$BLOB"
 TREE=$(git mktree)
 git read-tree $TREE
 rm -rf .git/refs/*
 rm -rf .git/objects/*
 [win]
 test "$(git cat-file --batch-check --batch-all-objects | wc -l)" -eq 0
--- a/levels/it/low-level/puzzle-precious-blob
+++ b/levels/it/low-level/puzzle-precious-blob
@ -1,28 +0,0 @@
 [description]
 Create two trees pointing to the same blob!
 [setup]
 [setup goal]
 BLOB=$(echo "I am precious" | git hash-object -w --stdin)
 git update-index --add --cacheinfo 100644,$BLOB,a
 git write-tree
 git update-index --force-remove a
 git update-index --add --cacheinfo 100644,$BLOB,b
 git write-tree
 git update-index --force-remove b
 [win]
 TREES=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep tree | cut -f1 -d" ")
 ALL_TREE_CHILDREN=$(for TREE in $TREES; do
    git cat-file -p $TREE | cut -f1 | cut -f3 -d" "
 done)
 NUMBER_OF_CHILDREN=$(echo "$ALL_TREE_CHILDREN" | wc -l)
 UNIQUE_CHILDREN=$(echo "$ALL_TREE_CHILDREN" | sort -u | wc -l)
 test "$NUMBER_OF_CHILDREN" -gt "$UNIQUE_CHILDREN"
--- a/levels/it/low-level/puzzle-trees-all-the-way-down
+++ b/levels/it/low-level/puzzle-trees-all-the-way-down
@ -1,34 +0,0 @@
 [description]
 Construct a chain of three trees, which don't point to anything else.
 This is hard! The `git mktree` command might be useful.
 [setup]
 [setup goal]
 git mktree
 TREE=$(echo -e "040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904\tdir" | git mktree)
 echo -e "040000 tree $TREE\tdir" | git mktree
 [win]
 TREES=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep tree | cut -f1 -d" ")
 for TREE in $TREES; do
    if [ "$(git cat-file -p $TREE | wc -l)" -eq 1 ]; then
        if [ "$(git cat-file -p $TREE | cut -f1 | grep tree | wc -l)" -eq 1 ]; then
            # So the tree has exactly one child, and it is a tree!
            TREE2=$(git cat-file -p $TREE | cut -f1 | grep tree | cut -f3 -d" ")
            if [ "$(git cat-file -p $TREE2 | wc -l)" -eq 1 ]; then
                if [ "$(git cat-file -p $TREE2 | cut -f1 | grep tree | wc -l)" -eq 1 ]; then
                    # Same for its child! \o/
                    return 0
                fi
            fi
        fi
    fi
 done
 return 1
--- a/levels/it/low-level/ref-create
+++ b/levels/it/low-level/ref-create
@ -1,42 +0,0 @@
 [description]
 Let's take a look at "refs" (short for "references")! Refs are not objects, but rather very simple *pointers* to objects! They can help you keep track of what's where.
 You can create or update a ref with
    git update-ref refs/<refname> <newvalue>
 Make sure to always start a ref's name with "refs/"! That's a convention that helps Git find all refs you create. If you forget the "refs/", you will not see the ref.
 Create refs that point to all objects in this repository!
 [setup]
 echo hello > hello
 echo world > world
 BLOB1=$(git hash-object -w hello)
 BLOB2=$(git hash-object -w world)
 git add .
 TREE=$(git write-tree)
 COMMIT=$(git commit-tree $TREE -m "Initial commit")
 [setup goal]
 echo hello > hello
 echo world > world
 BLOB1=$(git hash-object -w hello)
 BLOB2=$(git hash-object -w world)
 git add .
 TREE=$(git write-tree)
 COMMIT=$(git commit-tree $TREE -m "Initial commit")
 git update-ref refs/a $BLOB1
 git update-ref refs/b $BLOB2
 git update-ref refs/c $TREE
 git update-ref refs/d $COMMIT
 [win]
 OBJECTS=$(git cat-file --batch-check='%(objectname)' --batch-all-objects | sort)
 REF_TARGETS=$(git show-ref -s | sort | uniq)
 test "$OBJECTS" = "$REF_TARGETS"
--- a/levels/it/low-level/ref-move
+++ b/levels/it/low-level/ref-move
@ -1,41 +0,0 @@
 [description]
 You can point refs to a new location using the same command you use to create them:
    git update-ref refs/<refname> <object>
 As an exercise, make all refs in this repository point to the tree object!
 [setup]
 echo hello > hello
 echo world > world
 BLOB1=$(git hash-object -w hello)
 BLOB2=$(git hash-object -w world)
 git add .
 TREE=$(git write-tree)
 COMMIT=$(git commit-tree $TREE -m "Initial commit")
 git update-ref refs/a "$BLOB1"
 git update-ref refs/b "$COMMIT"
 [setup goal]
 echo hello > hello
 echo world > world
 BLOB1=$(git hash-object -w hello)
 BLOB2=$(git hash-object -w world)
 git add .
 TREE=$(git write-tree)
 COMMIT=$(git commit-tree $TREE -m "Initial commit")
 git update-ref refs/a "$BLOB1"
 git update-ref refs/b "$COMMIT"
 for REF in $(git for-each-ref --format='%(refname)'); do
    git update-ref "$REF" "$TREE"
 done
 [win]
 test "$(git show-ref -s | sort -u)" = "c7863f72467ed8dd44f4b8ffdb8b57ca7d91dc9e"
--- a/levels/it/low-level/ref-remove
+++ b/levels/it/low-level/ref-remove
@ -1,41 +0,0 @@
 [description]
 And finally, to delete a ref, use
    git update-ref -d refs/<refname>
 Delete all refs! :P (Well, except for HEAD. HEAD is special.)
 [setup]
 echo hello > hello
 echo world > world
 BLOB1=$(git hash-object -w hello)
 BLOB2=$(git hash-object -w world)
 git add .
 TREE=$(git write-tree)
 COMMIT=$(git commit-tree $TREE -m "Initial commit")
 git update-ref refs/best_blob_ever "$BLOB1"
 git update-ref refs/beautiful_commit "$COMMIT"
 [setup goal]
 echo hello > hello
 echo world > world
 BLOB1=$(git hash-object -w hello)
 BLOB2=$(git hash-object -w world)
 git add .
 TREE=$(git write-tree)
 COMMIT=$(git commit-tree $TREE -m "Initial commit")
 git update-ref refs/best_blob_ever "$BLOB1"
 git update-ref refs/beautiful_commit "$COMMIT"
 for REF in $(git for-each-ref --format='%(refname)'); do
    git update-ref -d "$REF"
 done
 [win]
 test "$(git show-ref | wc -l)" -eq 0
--- a/levels/it/low-level/sequence
+++ b/levels/it/low-level/sequence
@ -1,18 +0,0 @@
 welcome
 basics
 blob-create
 blob-remove
 index-add
 index-remove
 index-update
 tree-create
 tree-read
 tree-nested
 commit-create
 commit-parents
 commit-rhombus
 ref-create
 ref-move
 ref-remove
 symref-create
 symref-no-deref
--- a/levels/it/low-level/symref-create
+++ b/levels/it/low-level/symref-create
@ -1,21 +0,0 @@
 [description]
 Instead of pointing directly to objects, refs can also point to other refs!
 When that happens, they are called "symbolic refs". You can create or update a symbolic ref using
    git symbolic-ref <name> <ref>
 Create a symbolic ref called "refs/rainbow"!
 [setup]
 [setup goal]
 BLOB=$(git hash-object -w --stdin)
 git update-ref refs/double "$BLOB"
 git symbolic-ref refs/rainbow refs/double
 [win]
 git symbolic-ref refs/rainbow
--- a/levels/it/low-level/symref-no-deref
+++ b/levels/it/low-level/symref-no-deref
@ -1,46 +0,0 @@
 [description]
 When you have a symbolic ref (a ref pointing at another ref), and you decide you want it to be a regular ref again (pointing to an object), you're in for some trouble! :)
 What happens when you try pointing the symbolic ref directly to the blob using `git update-ref`?
 Oops! Turns out that when you reference a symbolic ref, it acts as if you had specified the ref it points to. To de-symbolic-ize it, use the `--no-deref` option directly after `update-ref`!
 Weird, huh?
 [congrats]
 Whew, we've covered a lot of things: Blobs! The index! Trees! Commits! Refs!
 You now know about almost everything about how Git repositories look like on the inside! We think that's pretty cool! :)
 Everything else is just convention and high-level commands that make interacting with the objects more convenient.
 We haven't covered:
 - tag objects (they are the fourth object type - a bit like refs with a description and an author)
 - configuration (allows you to specify remote repositories, for example)
 - working with local files (which is, uh, arguably pretty important :P)
 Thanks for playing! You're welcome to check out the "puzzle" levels in the dropdown, some of them are more advanced!
 [setup]
 BLOB1=$(echo delicious | git hash-object -w --stdin)
 BLOB2=$(echo very | git hash-object -w --stdin)
 git update-ref refs/curly "$BLOB1"
 git symbolic-ref refs/fries refs/curly
 [setup goal]
 BLOB1=$(echo delicious | git hash-object -w --stdin)
 BLOB2=$(echo very | git hash-object -w --stdin)
 git update-ref refs/curly "$BLOB1"
 git symbolic-ref refs/fries refs/curly
 git update-ref --no-deref refs/fries "$BLOB2"
 [win]
 git symbolic-ref refs/fries && return 1
 test "$(git show-ref -s refs/fries)" = "035e2968dafeea08e46e8fe6743cb8123e8b9aa6"
--- a/levels/it/low-level/tree-create
+++ b/levels/it/low-level/tree-create
@ -1,35 +0,0 @@
 [description]
 After carefully building the index we want, it would be nice to save a permanent snapshot of it, right?
 This is what the second type of objects is for: trees! You can convert the index into a tree using
    git write-tree
 Try it! :)
 [congrats]
 Nice!
 Can you make a different tree? Modify the index, then call `git write-tree` again!
 [setup]
 echo "file 1" > file1
 echo "file 2" > file2
 echo "file 3" > file3
 git add .
 [setup goal]
 echo "file 1" > file1
 echo "file 2" > file2
 echo "file 3" > file3
 git add .
 git write-tree
 [win]
 git cat-file -p 21a638f28022064c1f1df20844278b494d197979
--- a/levels/it/low-level/tree-nested
+++ b/levels/it/low-level/tree-nested
@ -1,38 +0,0 @@
 [description]
 Trees can also point to other trees! This way, they can describe nested directory structures.
 When you add a file inside of a directory to the index, and then call `git write-tree`, it will create a nested tree for the directory, and attach the blob to it.
 To solve this level, build a little stick figure, as shown on the left - a tree that points to two blobs, as well to a tree that points to two blobs.
 [setup]
 [setup goal]
 echo "I'm the left arm" > arm1
 echo "I'm the right arm" > arm2
 mkdir hip
 echo "I'm the left leg" > hip/leg1
 echo "I'm the right leg" > hip/leg2
 git add .
 git write-tree
 [win]
 TREES=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep tree | cut -f1 -d" ")
 for OUTER_TREE in $TREES; do
    NUMBER_OF_BLOB_CHILDREN=$(git cat-file -p $OUTER_TREE | cut -f2 -d" " | grep blob | wc -l)
    NUMBER_OF_TREE_CHILDREN=$(git cat-file -p $OUTER_TREE | cut -f2 -d" " | grep tree | wc -l)
    if [ $NUMBER_OF_BLOB_CHILDREN -eq 2 -a $NUMBER_OF_TREE_CHILDREN -eq 1 ]; then
        TREE_CHILD=$(git cat-file -p $OUTER_TREE | cut -f1 | grep tree | cut -d" " -f3)
        NUMBER_OF_BLOB_CHILDREN_OF_TREE_CHILD=$(git cat-file -p $TREE_CHILD | cut -f2 -d" " | grep blob | wc -l)
        if [ $NUMBER_OF_BLOB_CHILDREN_OF_TREE_CHILD -eq 2 ]; then
            return 0
        fi
    fi
 done
 return 1
--- a/levels/it/low-level/tree-read
+++ b/levels/it/low-level/tree-read
@ -1,51 +0,0 @@
 [description]
 As soon as you have some tree objects, you can always read them and set the index exactly to their content! Unsurprisingly, the command is called
    git read-tree <tree>
 For <tree>, you can provide the hash of any tree object - you can right-click one to insert its hash into the terminal!
 Try reading some of the trees in this repository into the index!
 [setup]
 EMPTY_TREE=$(git write-tree)
 echo "file 1" > file1
 echo "file 2" > file2
 git add .
 git write-tree
 rm *
 echo "file A" > fileA
 echo "file B" > fileB
 echo "file C" > fileC
 git add .
 TRIPLE_TREE=$(git write-tree)
 git read-tree "$EMPTY_TREE"
 [setup goal]
 EMPTY_TREE=$(git write-tree)
 echo "file 1" > file1
 echo "file 2" > file2
 git add .
 git write-tree
 rm *
 echo "file A" > fileA
 echo "file B" > fileB
 echo "file C" > fileC
 git add .
 TRIPLE_TREE=$(git write-tree)
 git read-tree "$EMPTY_TREE"
 git read-tree "$TRIPLE_TREE"
 [win]
 test "$(git ls-files | wc -l)" -gt 0
--- a/levels/it/low-level/welcome
+++ b/levels/it/low-level/welcome
@ -1,33 +0,0 @@
 [description]
 This is prototype #1 for the Git learning game by @bleeptrack and @blinry. Thanks for checking it out! <3
 You can interact with the repository labelled "yours" by typing Bash commands in the terminal below! The visualization will show you its internal status.
 Let's get started by initializing an empty Git repository in the current directory by typing:
    git init
 [congrats]
 Well done!
 An empty Git repository is... well, quite empty. The only thing that always exists is a reference called "HEAD" - we'll learn what that is later!
 But first, let's look at some basics!
 (Click "Next Level" as soon as you're ready!)
 [setup]
 rm -rf .git
 [setup goal]
 rm -rf .git
 git init
 [win]
 test -d .git
--- a/levels/it/merge/conflict
+++ b/levels/it/merge/conflict
@ -1,47 +0,0 @@
 title = Contraddizioni
 cards = checkout commit-auto merge reset-hard
 [description]
 A volte le linee temporali si contraddicono a vicenda.
 Per esempio, in questo caso, un nostro cliente vuole che queste linee temporali siano unite ma hanno mangiato cose differenti in entrambe le linee temporali.
 Prova ad unirle! Noterai che c'è un conflitto! La macchina del tempo ti lascerà decidere come procedere: puoi modificare l'elemento problematico, ti verranno mostrate le parti che vanno in conflitto. Puoi mantenere una delle due versioni o creare una combinazione di entrambe! Poi rimuovi i marcatori >>>, <<<, e === e crea un nuovo commit per finalizare l'unione!
 La tua linea temporale definitiva è "main".
 [setup]
 echo "Si è appena svegliato. È affamato." > sam
 git add .
 git commit -m "L'inizio"
 git checkout -b pancakes
 echo "Ha fatto colazione con pancakes ai mirtilli e sciroppo d'acero." > sam
 git add .
 git commit -m "Pancakes!"
 echo "
 È al lavoro." >> sam
 git commit -am "Va al lavoro"
 git checkout -b muesli main
 echo "Ha fatto colazione con muesli all'avena e fragole." > sam
 git add .
 git commit -m "Muesli!"
 echo "
 È al lavoro." >> sam
 git commit -am "Va al lavoro"
 git checkout main
 [win]
 # Crea un compromesso tra le due colazioni nel branch "main".
 git rev-parse main^ && test "$(git rev-parse main^1^^)" = "$(git rev-parse main^2^^)"
 [congrats]
 Yum, questa sembra una buona colazione!
--- a/levels/it/merge/merge
+++ b/levels/it/merge/merge
@ -1,82 +0,0 @@
 title = Unire le linee temporali
 cards = checkout commit-auto merge
 [description]
 Ecco un trucco per domire un pò più a lungo: svolgi tutte le tue attività mattutine in universi paralleli, e poi uniscile!
 [setup]
 echo "Non hai una baguette.
 Non hai caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "L'inizio"
 echo "Hai una baguette.
 Non hai caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Compri una baguette"
 echo "Mangi una baguette.
 Non hai caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Mangi la baguette"
 git checkout HEAD~2
 echo "Non hai una baguette.
 Hai caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Compri un pò di caffe"
 echo "Non hai una baguette.
 Bevi il caffe.
 Non hai una ciambella." > you
 git add .
 git commit -m "Bevi il caffe"
 git checkout HEAD~2
 echo "Non hai una baguette.
 Non hai caffe.
 Hai una ciambella." > you
 git add .
 git commit -m "Compri una ciambella"
 echo "Non hai una baguette.
 Non hai caffe.
 Mangi una ciambella." > you
 git add .
 git commit -m "Mangi la ciambella"
 git checkout --detach
 git branch -D main
 [win]
 # Crea una situazione dove consumi una baguette, un caffe e una ciambella.
 { git show HEAD:you | grep "Mangi.*baguette"; } && { git show HEAD:you | grep "Bevi.*caffe"; } && { git show HEAD:you | grep "Mangi.*ciambella"; }
 # Crea (e spostati su) un commit di unione.
 test "$(git log --pretty=%P -n 1 HEAD | wc -w)" -ge 2
 [congrats]
 Mi chiedo se sei più rilassato quando *dormi* in linee temporali parallele...
--- a/levels/it/merge/merge-abort
+++ b/levels/it/merge/merge-abort
@ -1,54 +0,0 @@
 title = Interrompere un merge
 cards = checkout commit-auto merge merge-abort
 [description]
 Può capitare che tu voglia unire il contenuto di due commit ma si verifica un conflitto che al momento non vuoi risolvere. 
 In queste situazioni, puoi interrompere il merge per riprendere successivamente. Usa
    git merge --abort
 mentre sei nel processo di merge.
 Prova a unire i due commit e interrompi la procedura di merge.
 [setup]
 echo "Un nuovo giorno sta iniziando" > you
 git add .
 git commit -m "Start"
 echo "Stai camminando sulla corsia principale." >> you
 git add .
 git commit -m "Corsia Principale"
 git checkout HEAD~1
 echo "Stai camminando sulla corsia laterale." >> you
 git add .
 git commit -m "Corsia laterale"
 git checkout HEAD~1
 git branch -D main
 [actions]
 if test -f .git/MERGE_HEAD; then
    touch .git/secretfile
 fi
 [win]
 # Hai provato a fare il merge?
 test -f .git/secretfile
 # Hai interrotto il merge?
 test -f .git/secretfile && ! test -f .git/MERGE_HEAD && ! git rev-parse HEAD^^
 [congrats]
 Aaah, faremo il merge più tardi...
--- a/levels/it/merge/sequence
+++ b/levels/it/merge/sequence
@ -1,3 +0,0 @@
 merge
 conflict
 merge-abort
--- a/levels/it/remotes/friend
+++ b/levels/it/remotes/friend
@ -1,47 +0,0 @@
 title = Amici
 cards = pull push commit-auto checkout
 [description]
 Il tuo amico ha aggiunto un'altra linea alla tua tesi! Prendilo, aggiungine un'altra e reinvialo!
 Fate botta e risposta fino a che non ti ritrovi ad avere cinque linee!
 [setup yours]
 echo "Linea 1" > essay
 git add .
 git commit -m "Una linea"
 git push -u friend main
 [setup friend]
 git checkout main
 echo "Linea 2, gnihihi" >> essay
 git commit -am "Un'altra linea"
 [actions friend]
 if test "$(git log --oneline | wc -l)" -eq 3; then
    git reset --hard main # Necessario perché la directory di lavoro non è aggiornata quando viene inviata all'amico
    echo "Linea 4, blurbblubb" >> essay
    git commit -am "Linea finale"
    hint "Oh bene, Ho aggiunto la quarta linea!"
 fi
 [win]
 # Ricevuto la seconda linea dal tuo amico.
 git show HEAD:essay | grep gnihihi
 # Ricevuto la quarta linea dal tuo amico.
 git show HEAD:essay | grep blurbblubb
 [win friend]
 # L'amico ha ricevuto la terza linea da te.
 test "$(git show HEAD:essay | wc -l)" -ge 3
 # L'amico ha ricevuto la quinta linea da te.
 test "$(git show HEAD:essay | wc -l)" -ge 5
--- a/levels/it/remotes/problems
+++ b/levels/it/remotes/problems
@ -1,33 +0,0 @@
 title = Problemi
 cards = checkout add pull push commit-auto merge
 [description]
 Entrambi, tu ed il tuo amico, avete lavorato sullo stesso file e volete sincronizare!
 [setup yours]
 echo "Il capannone delle bici dovrebbe essere ???" > file
 git add .
 git commit -m "inizio"
 git push -u friend main
 echo "Il capannone delle bici dovrebbe essere verde" > file
 [setup friend]
 git checkout main
 echo "Il capannone delle bici dovrebbe essere blu" > file
 git commit -a -m "versione dell'amico"
 [win]
 # Fai il commit delle tue modifiche locali.
 test "$(git status -s)" = ""
 [win friend]
 # Quarda il suggerimento dell'amico, trova un compromesso e rimandalo in dietro.
 git rev-parse main^ && test "$(git rev-parse main^1^)" = "$(git rev-parse main^2^)"
--- a/levels/it/remotes/sequence
+++ b/levels/it/remotes/sequence
@ -1,2 +0,0 @@
 friend
 problems
--- a/levels/it/sandbox/empty
+++ b/levels/it/sandbox/empty
@ -1,7 +0,0 @@
 title = Empty sandbox
 [description]
 This is an empty sandbox you can play around in.
 [setup]
--- a/levels/it/sandbox/remote
+++ b/levels/it/sandbox/remote
@ -1,22 +0,0 @@
 title = Sandbox with a remote
 cards = checkout commit-auto pull fetch push
 [description]
 Here's a sandbox with a remote! Try pulling, fetching, or pushing!
 How can you push tags and branches on a remote? How can you delete them again?
 [setup yours]
 echo "Line 1" > essay
 git add .
 git commit -m "Initial commit"
 git push -u friend main
 [setup friend]
 git checkout main
 echo "Line 2" >> essay
 git commit -am "Another line"
--- a/levels/it/sandbox/sequence
+++ b/levels/it/sandbox/sequence
@ -1,3 +0,0 @@
 empty
 remote
 three-commits
--- a/levels/it/sandbox/three-commits
+++ b/levels/it/sandbox/three-commits
@ -1,26 +0,0 @@
 title = Sandbox with three commits
 cards = checkout add reset-file checkout-file commit merge rebase
 [setup]
 echo "You wake up." > you
 git add .
 git commit -m "The beginning"
 echo "You drink coffee." >> you
 git commit -am "First things first"
 echo "You hear a knock on the door." >> you
 git commit -am "Who's there?"
 git branch not_main
 [description]
 Here's a sandbox you can play around in.
 You can use both the playing cards, as well as the terminal. This is a real Git terminal! Fun things to try:
 - Make a commit that merges three timelines together at once!
 - Create and delete some tags!
 - Make a timeline that's completely independent of the rest!
--- a/levels/it/sequence
+++ b/levels/it/sequence
@ -1,13 +0,0 @@
 intro
 files
 branches
 merge
 index
 remotes
 changing-the-past
 shit-happens
 workflows
 bisect
 stash
 tags
 sandbox
--- a/levels/it/shit-happens/bad-commit
+++ b/levels/it/shit-happens/bad-commit
@ -1,31 +0,0 @@
 title = Annullare un cattivo commit
 cards = reset commit-a
 [description]
 Oh no, abbiamo fatto un cattivo commit! Come possiamo annullare un commit e tornare ad un punto dove poter riprovare?
 La risposta è usare `git reset [commit]` che fa due cose:
 - Reimposta il riferimento (ref) del ramo corrente al commit che hai specificato.
 - Reimposta l'indice a quel commit.
 Non cambia la tua directory di lavoro in nessun modo, il che significa che dopo puoi provare a rifare il commit che desideri.
 [setup]
 echo "1 2 3 4" > numbers
 git add .
 git commit -m "commit iniziale"
 echo "1 2 3 4 5 6 7 8 9 11" > numbers
 git commit -am "Più numerrrrri"
 [win]
 # Nel primo commit il file numbers contiene i numeri da 1 a 10.
 test "$(git show main:numbers)" = "1 2 3 4 5 6 7 8 9 10"
 # Il messaggio di questo commit è "Più numeri".
 git log -1 --oneline | grep "Più numeri"
 # Il commit con l'errore si battitura non fa più parte del ramo principale.
 git log --oneline | grep -v "rrrrr"
--- a/Show more
+++ b/Show more