3IIR 2

Rapport

YOUSSEF ELHBOUSSI
▪ PLAN :

Introduction

Etude théorique

Conception

Code et résultat

Conclusion
 ▪ Application de Gestion de Tournoi d'Échecs.

Introduction

Le cahier des charges présenté décrit de manière claire et concise les

fonctionnalités attendues pour une application de gestion de tournoi d'échecs. Les
fonctionnalités couvrent tous les aspects essentiels de la gestion d'un tournoi, de
l'inscription des joueurs à la publication des résultats. La section sur les
fonctionnalités supplémentaires encourage les étudiants à être créatifs et à proposer
des idées innovantes pour améliorer l'application.

Points forts du cahier des charges:

• Clarté et précision: Le cahier des charges est bien rédigé et facile à
comprendre. Les fonctionnalités sont décrites de manière détaillée et précise.
• Couverture complète: Le cahier des charges couvre tous les aspects
essentiels de la gestion d'un tournoi d'échecs.
• Encouragement à la créativité: La section sur les fonctionnalités
supplémentaires encourage les étudiants à être créatifs et à proposer des
idées innovantes pour améliorer l'application.
Suggestions d'amélioration:
• Exemples concrets: Il serait utile d'inclure des exemples concrets pour
illustrer certaines fonctionnalités, comme la planification des parties ou la
gestion des réservations de places.
• Diagrammes et schémas: L'utilisation de diagrammes et de schémas
pourrait aider à visualiser les processus et les interactions entre les
différentes fonctionnalités.
• Considérations techniques: Il serait intéressant de réfléchir aux aspects
techniques de la mise en œuvre de l'application, tels que le choix du langage
de programmation et de la base de données.
 Etude théorique
Introduction

Le développement d'une application de gestion de tournoi d'échecs nécessite une

approche méthodique pour répondre aux besoins des joueurs, des organisateurs et
des spectateurs. Cette étude théorique et professionnelle fournira un aperçu des
principaux aspects à considérer lors de la conception et du développement de
l'application.

1. Analyse des Besoins

La première étape consiste à comprendre les besoins des parties prenantes. Cela
implique des entretiens avec les organisateurs de tournois, les joueurs d'échecs et les
spectateurs pour identifier les fonctionnalités essentielles et les aspects critiques de
l'expérience utilisateur.

2. Conception de l'Architecture

L'architecture de l'application doit être robuste, évolutive et sécurisée. Une approche

modulaire peut faciliter la maintenance et les mises à jour futures. La conception
devrait inclure des composants pour la gestion des joueurs, des salles, des parties,
des arbitres et des réservations, avec des interfaces utilisateur intuitives.

3. Sécurité des Données

La sécurité des données est primordiale pour protéger les informations personnelles
des joueurs, les résultats des parties et les décisions arbitrales. L'application devrait
implémenter des mesures de sécurité telles que le chiffrement des données, la
gestion des accès et la protection contre les attaques de sécurité.

4. Interface Utilisateur Conviviale

Une interface utilisateur conviviale est essentielle pour assurer une adoption réussie
de l'application. Les joueurs, les organisateurs et les spectateurs doivent pouvoir
naviguer facilement dans l'application, effectuer des actions telles que l'inscription
aux tournois, la réservation de places et la consultation des résultats des parties.

5. Fonctionnalités Avancées

En plus des fonctionnalités de base énumérées dans le cahier des charges, des
fonctionnalités avancées peuvent améliorer l'efficacité et l'expérience utilisateur. Cela
pourrait inclure des notifications en temps réel des mises à jour du tournoi, des
analyses de parties intégrées et des outils de communication pour les joueurs et les
organisateurs.

6. Tests et Validation

Avant le déploiement de l'application, des tests approfondis doivent être effectués

pour s'assurer de sa stabilité, de sa performance et de sa conformité aux exigences
fonctionnelles. Les retours des utilisateurs peuvent également être recueillis lors de
phases de validation pour identifier les éventuels problèmes et améliorations
nécessaires.

Conclusion

Le développement d'une application de gestion de tournoi d'échecs nécessite une

approche holistique qui prend en compte les besoins des utilisateurs, la sécurité des
données, l'expérience utilisateur et la qualité du logiciel. En suivant les principes de
conception et de développement énoncés dans cette étude théorique et
professionnelle, l'application peut offrir une solution efficace et satisfaisante pour
tous les acteurs impliqués dans l'organisation et la participation aux tournois
d'échecs.

Conception
 Le règlement du jeu

Le règlement du jeu d'échecs, également connu sous le nom de "Lois du jeu

d'échecs", est un ensemble de règles établies par la Fédération internationale
des échecs (FIDE) pour régir le déroulement des parties d'échecs. Voici
quelques-unes des règles fondamentales :

1. Disposition initiale des pièces: Les pièces sont placées sur la rangée la plus
proche de chaque joueur de la manière suivante : de gauche à droite, tour,
cavalier, fou, dame, roi, fou, cavalier, tour. Les pions sont placés sur la rangée
juste devant ces pièces. Les joueurs ont une disposition identique, mais miroir
l'un de l'autre.

2. Déplacement des pièces : Chaque pièce a des règles spécifiques de

déplacement. Par exemple, la tour peut se déplacer horizontalement ou
verticalement sur toute distance, le fou se déplace en diagonale, le cavalier se
déplace en formant un L, etc.

3. Capture : Une pièce est capturée lorsqu'elle est déplacée sur une case
occupée par une pièce adverse. La pièce capturée est retirée du plateau.

4. Promotion des pions: Lorsqu'un pion atteint la dernière rangée du plateau

adverse, il est promu et peut être échangé contre n'importe quelle autre pièce,
à l'exception du roi.

5. Règles spéciales: Il existe des règles spéciales telles que le roque

(déplacement du roi et d'une tour en un seul mouvement), la prise en passant
(permettant à un pion de capturer un pion adverse qui vient de se déplacer de
deux cases), etc.

6. Échec et échec et mat: Un joueur est en échec lorsque son roi est menacé
par une pièce adverse. Si le roi est en échec et qu'il n'y a aucun moyen de le
 protéger, c'est l'échec et mat, ce qui signifie que le jeu est terminé et que le
joueur en échec et mat perd la partie.

7. Pat : Un joueur est en pat lorsque son roi n'est pas en échec, mais il n'a
aucun coup légal possible. Dans ce cas, la partie est nulle.

8. Cadence de jeu : Les parties d'échecs sont généralement jouées avec un

certain temps limite pour chaque joueur, appelé cadence de jeu. Il existe
différents types de cadences, comme le jeu rapide, le jeu blitz et le jeu en
cadence lente.

Ces règles sont fondamentales, mais il existe de nombreuses autres subtilités

et règles spécifiques qui régissent le jeu d'échecs.
Code et résultat

#include <iostream>
#include <vector>
#include <string>
using namespace std;

class Joueur {
private:
string nom;
int id;
public:
Joueur(string n, int e) : nom(n), id(e) {}
string getNom() const { return nom; }
int getid() const { return id; }
};

class Spectateur {
private:
 int id;
string nom;
public:
Spectateur(string n) : nom(n), id(0) {}
int getId() const { return id; }
string getNom() const { return nom; }
};

class Salle {
private:
int id;
string nom;
int capacite;
public:
Salle(string n, int c) : nom(n), capacite(c), id(0) {}
int getId() const { return id; }
string getNom() const { return nom; }
int getCapacite() const { return capacite; }
};

class Match {
private:
Joueur joueur1;
Joueur joueur2;
string resultat;
string winner;
public:
Match(Joueur j1, Joueur j2) : joueur1(j1), joueur2(j2) {}
void setResultat(string r) { resultat = r; }
void setWinner(string w) { winner = w; }
void afficher() const {
cout << joueur1.getNom() << " contre " << joueur2.getNom() << " -
Résultat : " << resultat << ", Winner: " << winner << endl;
 }
};

class Reservation {
private:
int id;
Spectateur spectateur;
Salle salle;
double prix;
public:
Reservation(Spectateur s, Salle r, double p) : spectateur(s), salle(r), prix(p),
id(0) {}
int getId() const { return id; }
Spectateur getSpectateur() const { return spectateur; }
Salle getRoom() const { return salle; }
double getPrice() const { return prix; }
void setPrice(double p) { prix = p; }
};

class Arbitre {
private:
int id;
string nom;
public:
Arbitre(string n) : nom(n), id(0) {}
int getId() const { return id; }
string getNom() const { return nom; }
void setId(int i) { id = i; }
void setNom(string n) { nom = n; }
};

class Tournoi {
private:
 string nom;
vector<Joueur> joueurs;
vector<Match> matches;
vector<Salle> salles;
vector<Arbitre> arbitres;
vector<Reservation> Reservations;
public:
Tournoi(string n) : nom(n) {}
void ajouterJoueur(Joueur joueur) { joueurs.push_back(joueur); }
void creerMatch() {
for (size_t i = 0; i < joueurs.size(); i += 2) {
Match match(joueurs[i], joueurs[i + 1]);
matches.push_back(match);
}
}
void creerFinalMatch(Joueur j1, Joueur j2) {
Match finalMatch(j1, j2);
matches.push_back(finalMatch);
}
void setMatchWinner(int matchIndex, string winnerName) {
if (matchIndex >= 0 && matchIndex < matches.size()) {
matches[matchIndex].setWinner(winnerName);
}
}
void afficherMatches() const {
cout << "Tournoi : " << nom << endl;
cout << "Matches : " << endl;
for (const auto& match : matches) {
match.afficher();
}
}
void ajouterReservation(Reservation Reservation) {
Reservations.push_back(Reservation);
 }
void afficherReservations() const {
cout << "Reservations : " << endl;
for (const auto& reservation : Reservations) {
cout << "Spectateur : " << reservation.getSpectateur().getNom()
<< ", Salle : " << reservation.getRoom().getNom()
<< ", Prix : " << reservation.getPrice() << endl;
}
}
void ajouterArbitre(Arbitre arbitre) {
arbitres.push_back(arbitre);
}
};

int main() {
Tournoi tournoi("Tournoi des echecs");

Joueur joueur1("youssef", 1600);

Joueur joueur2("Kaoutar", 1550);
Joueur joueur3("Driss", 1580);
Joueur joueur4("Souhail", 1620);
tournoi.ajouterJoueur(joueur1);
tournoi.ajouterJoueur(joueur2);
tournoi.ajouterJoueur(joueur3);
tournoi.ajouterJoueur(joueur4);

tournoi.creerMatch();
tournoi.setMatchWinner(0, joueur1.getNom());
tournoi.setMatchWinner(1, joueur3.getNom());
tournoi.afficherMatches();

tournoi.creerFinalMatch(joueur1, joueur3);
tournoi.setMatchWinner(2, joueur1.getNom());
tournoi.afficherMatches();

Spectateur spectateur1("Moulay Abdelah");

Spectateur spectateur2("Sansiro");
Salle salle1("Salle 1", 50);
Salle salle2("Salle 2", 40);
Reservation reservation1(spectateur1, salle1, 25.0);
Reservation reservation2(spectateur2, salle2, 20.0);
tournoi.ajouterReservation(reservation1);
tournoi.ajouterReservation(reservation2);

tournoi.afficherReservations();

Arbitre arbitre1("Arbitre 1");

Arbitre arbitre2("Arbitre 2");
tournoi.ajouterArbitre(arbitre1);
tournoi.ajouterArbitre(arbitre2);

return 0;
}

Conclusion
Cette application de gestion de tournoi d'échecs devrait permettre aux organisateurs
de tournois de planifier, organiser et gérer efficacement leurs tournois. L'application
devrait être facile à utiliser et fournir toutes les fonctionnalités nécessaires pour un
tournoi réussi.