Commit ed2b1b15 authored by Viala axel's avatar Viala axel
Browse files

initial commit let's droid dance.

parents
[package]
name = "PaintDroid"
version = "0.1.0"
authors = ["Auteur <Courriel@nom.domaine.tld"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
# Projet DancingDroids
/!\ Attention sujet non fini!!! prevoir des changements /!\
Dans ce projet nous allons réaliser un jeu joué par l'ordinateur dans
un premier temps depuis un fichier predefini.
## Groupes
Compositions des groupes maximum 3 personnes, tentez de pas vous mettre à deux personnes
très à l'aise le but de se projet de de faire coder et progresser tout le monde. ;)
## Rendu
A rendre pour dans 2 semaines!
- L2-A1: 20 octobre
- L2-A2: 27 octobre
- L2-B1: 23 octobre
- L2-B2: 30 octobre
## Partie obligatoire
Afin d'avoir au moins 10 il est neccessaire de faire toutes les parties indispensables.
C'est à dire TOUTE la version 0.1.0. J'incite cependant tout le monde a tenter des
améliorations une fois une version fonctionelle.
Le rendu sera un fork du projet versionné sous git. Pour ce faire vous
pouvez forker ce dépot et faire vos contributions dans votre fork avec votre groupe.
A vous de gérer les droits pour pouvoir facilement editer et push a deux. Les dépots seront
publiques, mais je veillerais a ce que vous n'ayez pas de plaggiat personnellement. :)
L'entre-aide est tolérée surtout pour les bonus! Happy hacking!
## Version 0.1.0 Déplacements et collisions fonctionnelles
## Deplacement orientation
Dans ce jeu des robots vont pouvoir se déplacer dans un espace en deux
dimensions. A chaque tour un robot executera un ordre les ordres concistent en
effectuer une rotation à droite ou à gauche ou avancer ou ne rien faire!
> Conseil: Deux type `enum` vous serons utile! ;) Une pour l'orientation, une pour
> le les instructions!
Dans le fichier d'instructions vous aurrez les caractères suivants possibles:
- L: Oriente le robot de 90 degrée à gauche par exemple passe de orientation: N à W
- R: Oriente le robot de 90 degrée à droite par exemple passe de orientation: N à E
- F: Avance dans le sens de l'orientation d'une case
## Collisions
En cas de collision avec un autre robot lors d'un déplacement le robot devra
dire sur la sortie standard:
Cas des collisions: Faire dire `"Robot ID<numId> Collision en (x, y)"`
Format du fichier definisant le monde:
```txt
5 5 // X_max Y_max
1 1 N // position du robot en x=1 y=1 orientation = nord
FLLFRF
3 2 S // position du robot 2 x=3 y=2 orientation=South
FFLFRRF
```
Pour representer:
- un robot une simple structure suffira.
- La structure pour contenir les robots pourras être un `vec<Robot>`
### Conclusion version 0.1.0
Dans certe première itération, vous devrez pouvoir faire la simulation des robots,
depuis un fichier d'instruction, et afficher a la fin leurs positions finales.
#### Tests
A venir
## Version 0.2.0 Affichage implementation de Display
Dans cette version on va écrire du code pour afficher la positions des robots et
dessiner la grille.
Vous devrez pouvoir dessiner quelque chose comme cela en partant de la grille donnée en exemple plus haut
dans votre terminal:
```txt
Terrain { x_max = 5; y_max = 5 }
Robots [
{ id = 0, x = 1; y = 1; orientation: North },
{ id = 1; x = 3; y = 2; orientation: South },
]
Etat initial
============================
5 . . . . . .
4 . . . . . .
3 . . . . . .
2 . . . ⬇ . .
1 . ⬆ . . . .
0 . . . . . .
0 1 2 3 4 5
Etat final
=============================
5 . . . . . .
4 . . . . . .
3 . . . . . .
2 . . . . . .
1 . ➡ . . . .
0 . . . ⬅ . .
0 1 2 3 4 5
```
Libre a vous d'adapter l'affichage tant que cela reste lisible.
Pour réaliser cela on peut implementer un trait pour nos structures qui s'appelle
`Display` c'est un peu comme un contrat, qui garanti que si une structure,
l'implemente alors on peut avoir une representation humaine sous forme de `String`.
Vous pouvez implementer aussi `Debug` pour vous faciliter la lecture en debuggant
votre code.
## version 0.3.0 : un peu d'aléatoire
Programmer ce qui est neccessaire pour que a chaque *tick* de façon aléatoire un
robot avance sa liste d'instruction serait symbolisée par simplement aucune liste
d'instructions.
Programmer ce qui est neccessaire pour que a chaque *tick* de façon aléatoire un
robot avance sa liste d'instruction serait symbolisée par simplement aucune liste
d'instructions.
## version 0.4.0 : un peu de couleurs
A présent les robots lorsque ils se déplacent laissent une couleur sur les cases
qu'ils ont traversée, les couleurs sont determinées à partir de l'id d'un robot.
Les couleurs seront des couleurs affichables en terminal, à vous d'ecrire une
fonction qui va des id vers les couleurs. indice: fonction de hashage, trait `Hash`.
Une couleur se degrade progressivement sur 5 tours et disparait elle reste destructrice jusque a
sa disparition totale.
Si un robot traverse la couleur d'un autre robot il est mis hors service, il est
hors jeu pour le reste de la partie et sera symbolisé par `'🤖'` par exemple il
reste un element dans lequel les autres robots peuvent entrer en collision.
La collision entre deux robots n'implique pas de mise hors service.
Programmer ce qui est neccessaire pour que a chaque *tick* de façon aléatoire un
robot avance sa liste d'instruction serait symbolisée par simplement aucune liste
d'instructions.
Pour vous aider avec les couleurs vous pouvez utiliser la crate [termion](https://lib.rs/crates/termion)
ou [colored](https://crates.io/crates/colored).
## version 0.5.0 : Paralellization des Robot'z
A présent dans ce bonus, faites le neccessaire pour pouvoir avoir plusieurs robots
qui agisent en parallèlle, vous devrez découvrir l'usage des threads, channels,
`Mutex`, `Arc` ou bien utiliser une bibliothèque comme [Rayon](https://docs.rs/rayon/1.4.1/rayon/) qui abstrait cela.
Voici le chapitre du livre sur le sujet [FearLess concurrency](https://doc.rust-lang.org/book/ch16-00-concurrency.html).
Un petit exercice pour faire des threads est dans exercices/
## version 0.6.0 : De-Serialisation/Serialisation de l'etat du monde
Utilisez une bibliothèque comme [Serde](https://github.com/serde-rs/serde)
pour écrire sur un fichier l'etat des structures de données du jeu pour par
exemple arretter une partie en cas de `Ctrl-C`.
## Version 0.7.0 : Gestion du parsing rationnelle
Utilisez une bibliothèque de votre choix pour gérer le parsing le format de fichier des robots.
Telle que :
- [nom](https://github.com/Geal/nom)
- [pest](https://github.com/pest-parser/pest)
- [lalrpop](https://github.com/lalrpop/lalrpop)
## Version 0.8.0 : Industrialisation et lib de jeu vidéo
Choissisez une bibliothèque pour faire des jeux vidéo en Rust et faites vous plaisir
pour améliorer avec de la gestion des assets, 3D ou autre dans votre projet si vous en êtes
la je peux plus vous retenir.
Site pour choisir ses lib/framework de jeu: <https://arewegameyet.rs/>
Conseil de game-engine:
- [Bevy](https://bevyengine.org/)
- [Amethyst.rs](https://amethyst.rs/)
## Version 0.9.0 : Vous avez dit IA
Programmer ou entrainner une petite IA pour ce jeu. C'est pas simple c'est du gros
bonus. ;)
Le but d'une IA est de survivre en envoyant des commandes pour eviter d'être mise hors
service. Plusieurs IA devraient pouvoir jouer ensemble.
5 5 // X_max Y_max
1 1 N // position du robot 2 en x=1 y=1 orientation=nord
FLLFRF // Liste d'instruction du robot
3 2 S // position du robot 2 x=3 y=2 orientation=South
FFLFRRF
fn main() {
println!("BeBoP?");
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment