# cowsay

Projet INF203 autour de `cowsay`.
Cette même README est aussi publiée sur le site : <https://docs.fare-elouan.net/cowsay>, Les graphisme pour la charte seront mieux
il y a aussi le depot sur <https://git.fare-elouan.net/school/cowsay>

## Contenu du dépôt

- `start.sh` : lance un tour guidé de la plupart des programmes du projet.
- `ProjetCowsay.pdf` : document de projet au format PDF.
- `TODO.md` : checklist de suivi du travail demandé.
- `src/bash_scripts/` : scripts Bash.
- `src/C/` : programmes C principaux.
- `src/C/newcows/` : variantes C supplémentaires et script de compilation rapide.

## Dépendances

Pour exécuter tout le projet, il faut au minimum :

- `bash`
- `cowsay`
- `bc` pour `smart_cow.sh`
- un compilateur C : `cc`, `clang` ou `gcc`

## Lancement rapide

Depuis la racine du dépôt :

```bash
bash start.sh
```

Le script de démonstration compile les programmes C dans un dossier temporaire puis exécute les différents exemples les uns après les autres.

## Résumé des scripts Bash

| Programme | Rôle | Exemple |
| --- | --- | --- |
| `cow_kindergarten.sh` | Fait parler la vache de `1` à `10`, avec une pause d'une seconde entre chaque valeur, puis termine avec une langue sortie. | `bash src/bash_scripts/cow_kindergarten.sh` |
| `cow_primaryschool.sh` | Fait parler la vache de `1` à `n`. | `bash src/bash_scripts/cow_primaryschool.sh 5` |
| `cow_highschool.sh` | Affiche les carrés parfaits de `1^2` à `n^2`. | `bash src/bash_scripts/cow_highschool.sh 5` |
| `cow_college.sh` | Affiche les `n` premiers termes de la suite de Fibonacci avec mémoïsation. | `bash src/bash_scripts/cow_college.sh 7` |
| `cow_university.sh` | Affiche les nombres premiers jusqu'à `n` avec un crible d'Ératosthène. | `bash src/bash_scripts/cow_university.sh 30` |
| `smart_cow.sh` | Évalue une expression arithmétique simple et essaie d'afficher le résultat dans les yeux de la vache. | `bash src/bash_scripts/smart_cow.sh '4+13'` |
| `crazy_cow.sh` | Génère une suite "look-and-say" de manière interactive, puis affiche toutes les étapes dans `cowsay`. | `bash src/bash_scripts/crazy_cow.sh` |

## Résumé des programmes C

| Programme | Rôle | Exemple |
| --- | --- | --- |
| `src/C/newcow.c` | Affiche une vache ASCII sans bulle, avec option `-e` ou `--eyes` pour changer les yeux. | `cc src/C/newcow.c -o /tmp/newcow && /tmp/newcow -e ^^` |
| `src/C/newcows/newcowT.c` | Variante de `newcow` qui gère la langue avec l'option `-T`. | `cc src/C/newcows/newcowT.c -o /tmp/newcowT && /tmp/newcowT -T U` |
| `src/C/newcows/newcowp.c` | Ajoute une bulle de texte simple au-dessus de la vache. | `cc src/C/newcows/newcowp.c -o /tmp/newcowp && /tmp/newcowp -p "Hello"` |
| `src/C/newcows/makefilealacon.sh` | Compile rapidement un fichier `.c` en un exécutable `.out` avec `clang`. | `bash src/C/newcows/makefilealacon.sh src/C/newcows/newcowT.c` |
| `src/C/newcow2.c` | Regroupe plusieurs animations terminales : clignement, langue, marche, rebond. | `cc src/C/newcow2.c -o /tmp/newcow2 && /tmp/newcow2 blink` |
| `src/C/reading_cow.c` | Lit un fichier caractère par caractère et montre la vache en train de "manger" le texte. | `cc src/C/reading_cow.c -o /tmp/reading_cow && /tmp/reading_cow --i 0.10 README.md` |
| `src/C/tamagoshi_cow.c` | Mini jeu en boucle avec gestion de `stock`, `fitness` et score de survie. | `cc src/C/tamagoshi_cow.c -o /tmp/tamagoshi_cow && /tmp/tamagoshi_cow` |

## Tour d'ensemble du projet

1. Bash simple avec comptage et pauses.
2. Bash plus algorithmique avec carrés, Fibonacci et nombres premiers.
3. Personnalisation de la vache en C.
4. Animations et interactions dans le terminal.
5. Programme de lecture de fichier.
6. Automate de jeu avec états pour le tamagotchi.

## Partie automate

- `liferocks` si `fitness` est entre `4` et `6`
- `lifesucks` si `fitness` est entre `1` et `3` ou entre `7` et `9`
- `byebyelife` si `fitness` vaut `0` ou `10`

À chaque tour :

- le joueur choisit `lunchfood`
- `fitness` est mise à jour avec un effet de digestion aléatoire
- `stock` est mis à jour avec une variation aléatoire de récolte
- si `fitness` atteint `0` ou `10`, la partie s'arrête

```flow
st=>start: Début du jeu

init=>operation: fitness = 5 ; stock = 5 ; score = 0

etat=>condition: fitness == 0 ou fitness == 10 ?
mort=>end: byebyelife Afficher score final

checkRock=>condition: 4 ≤ fitness ≤ 6 ?
liferocks=>operation: liferocks;Afficher vache saine
lifesucks=>operation: lifesucks;Afficher vache malade

affStock=>operation: Afficher stock

choix=>operation: lunchfood choisi;0 ≤ lunchfood ≤ stock

alea=>operation: digestion ∈ [-3,0];crop ∈ [-3,3]

majFit=>operation: fitness = fitness + lunchfood + digestion
clampFit=>operation: fitness borné entre 0 et 10

majStock=>operation: stock = stock - lunchfood + crop
clampStock=>operation: stock borné entre 0 et 10

score=>operation: score += 1

st->init->etat
etat(yes)->mort
etat(no)->checkRock
checkRock(yes)->liferocks->affStock
checkRock(no)->lifesucks->affStock

affStock->choix->alea->majFit->clampFit->majStock->clampStock->score->etat
```

## Remarques

- Il faut utiliser start.sh pour avoir une demo du projet