Vincent Aranega
Le but de ce projet est de fournir une API Rest pour la gestion de jeux de cartes. L’API (serveur Rest) sera capable de gérer plusieurs jeux de cartes (54 ou 32 cartes) et de fournir plusieurs actions dessus (mélange, tirer une ou plusieurs cartes) et devra aussi gérer la défausse.
Un utilisateur devra être capable au minimum de :
Demander à créer un nouveau jeu (32 ou 54)
Mélanger un jeu à n’importe quel moment
Tirer une ou plusieurs cartes
Retirer une carte de la défausse vers le jeu principal
Mélanger la défausse
Toute autre action que vous jugerez intéressante
Aucun format spécial des objets JSON ou protocol n’est donné, c’est à vous de le proposer.
Le but de ce projet et de fournir un genre de terrain de jeu pour personnage via un serveur REST. Le serveur sera capable d’accepter plusieurs joueurs en même temps et de gérer les plusieurs actions du joueurs. Le protocole donné repose sur des requêtes POST/GET (donné à la fin du document) IMPORTANT: le protocole est à respecter
la connexion du joueur (sans authentification),
l’observation d’une pièce (retourner son l’état),
le déplacement d’un joueur vers une pièce adjacente,
l’observation d’un autre joueur/monstre (retourner l’état d’un joueur/monstre),
mener une attaque vers un autre joueur si on est dans la même pièce.
Ce projet et le complément du projet de serveur de jeu MUD-like. Il se découpe en deux parties, l’une reposant sur l’autre. La première partie est la production d’un binding vers le server de jeux qui répond à un protocole en particulier. La second partie du projet et la production d’une client utilisant ce binding et qui propose une interface simple de jeu sous forme textuelle. IMPORTANT: le protocole est à respecter
Le protocole est le même que celui du serveur, seulement quelques actions sont possibles
se connecter au serveur (sans authentification)
observer une pièce dans laquelle on se trouve
observer un autre joueur/monstre
se déplacer dans un autre pièce
mener une attaque vers un autre joueur si on est dans la même pièce
La transformation d’une image en appliquant plusieurs filtres n’est pas une chose aisée. Si des utilisateurs non developeurs veulent pouvoir effectuer un ensemble d’opérations sur une image, il faut qu’ils les appliquent à la main les uns après les autre, ce qui n’est pas facile si beaucoup d’images doivent être retouchées de la sorte. Pour qu’un utilisateur puisse facilement "composer" la manière dont il veut modifier une image, il serait intéressant de proposer un moteur de transformation d’images.
On vous propose ici de créer un moteur de chaine de transformation d’image qui doit être capable de permettre de représenter et de composer plusieurs transformations d’images. Les transformations d’images en elles-mêmes seront effectuée par transmission de l’image en format base64 à un serveur REST qui s’occupera de prendre l’image, une transformation et ses paramètres et qui effectuera la transformation en renvoyant la nouvelle image en base64. Ces transformations ne sont pas à coder, c’est le serveur qui s’en occupera et elles seront connues à l’avance. L’utilisateur propose alors un moyen de composer une chaine de transformations via un fichier de configuration (YAML, JSON, ou graphique).
Avant de proposer un fichier de configuration, il est important de proposer une abstraction claire pour la représentation d’un modèle qui permet de représenter une chaine de transformations. Même si les transformations sont définies à l’avance, il est important que n’importe quel developeur puisse en rajouter facilement. Pensez donc bien à écrire une architecture claire et à fournir des mécanismes simples pour que n’importe qui puisse facilement rajouter une transformation (par exemple, dans un langage objet, le dev. n’aurait qu’à implémenter une interface pour effectuer l’appel sur le serveur REST).
Dart, F#, Go, Kotlin, Dart,
Typescript, Rust, Swift, Pharo,
C#, Lua, Elixir, Nim, V
Content-Type: application/json
POST <url>/connect
POST <url>/<guid>/command
201
POST <url>/connect
{
"guid": <guid>
"totalvie": <integer>
"salle": {
"description": <description (string)>
"passages": [ "N", "E", ... ]
"entites": [ <guid1>, <guid2>, <guid3>, ...]
}
}
GET <url>/<guid>/regarder
{
"description": <description (string)>
"passages": [ "N", "E", ... ]
"entites": [ <guid1>, <guid2>, <guid3>, ...]
}
POST <url>/<guid>/deplacement
{
"direction": "N" | "S" | "E" | "W"
}
{
"description": <description (string)>
"passages": [ "N", "E", ... ]
"entites": [ <guid1>, <guid2>, <guid3>, ...]
}
GET <url>/<guidsource>/examiner/<guiddest>
{
"description": <description>
"type" : "JOUEUR" | "MONSTRE"
"vie": <integer>
"totalvie": <integer>
}
POST <url>/<guidsource>/taper/<guidcible>
{
"attaquant": {
"guid": <guid>
"degats": <integer>
"vie": <integer>
}
"attaque": {
"guid": <guid>
"degats": <integer>
"vie": <integer>
}
}
Si la requete est malformée (pas du json valide, ou bien manque des fields etc): 400
Si l’URL existe pas (commande inconnue, guid inconnu, etc.): 404
code 409 pour tout autre erreur, réponse json :
{
"type": "MORT" | "MUR"
"message:" string
}