PETIT PROGRAMME DE GESTION DE POINTS DE TENNIS DE TABLE

// ------------- main.cpp -------------------

#include "fonctionsMenu1.h"

int main()
{
   ofstream fichier ("informations.txt", ios::app);
   fichier.close();
   
   // Créé l'objet fichier_in comme fichier texte
   ifstream fichier_in ("informations.txt");
        
   if (!fichier_in) // Teste l'ouverture du fichier
   {
      cerr << "Ouverture du fichier impossible.";
      exit (1);
   }
   
   // Ecrit le contenu du fichier dans le vector Joueurs
   vector <Joueur> Joueurs(istream_iterator<Joueur>(fichier_in), (istream_iterator<Joueur>())); 
   fichier_in.close(); // Ferme le fichier
   
   int choix; // Contient le choix de l'utilisateur
   void (* fonction [4]) (vector <Joueur> &) = {gestionJoueurs, ajouterVictoire, ajouterDefaite,
                                                cloturerMois};
   
   while ((choix = menuPrincipal (Joueurs)) != 5)
   {
      
      (* fonction [choix - 1]) (Joueurs); // Appelle la fonction correspondante
                                                             // à l'aide des pointeurs de
                                                             // fonctions
   }
  
   // Ouverture du fichier en sortie
   ofstream fichier_out ("informations.txt");
   
   if (!fichier_out) // Teste l'ouverture du fichier
   {
      cerr << "Ouverture du fichier impossible.";
      exit (1);
   }
   
   // Ecrit le contenu du vector Joueurs dans le fichier texte
   copy (Joueurs.begin(), Joueurs.end(), ostream_iterator<Joueur>(fichier_out));
   
   system("PAUSE");
   return 0;
}

// ---------------- fonctionsMenu1.h -------------

// ----------------- Définition des en-têtes ------------------------

#include <iostream>
using std::cout;
using std::cerr;
using std::cin;
using std::ios;
using std::endl;
using std::istream;
using std::ostream;

#include <string>
using std::string;

#include <fstream>
using std::ofstream;
using std::ifstream;
using std::fstream;

#include <vector>
using std::vector;

#include <iterator>
using std::istream_iterator;
using std::ostream_iterator;

#include <limits>
using std::numeric_limits;
using std::streamsize;

#include <cmath>

// --------------------- Fin de définition des en-têtes -----------------------

struct Joueur // Défini la structure Joueur
{
   string nom; // Le nom de famille du joueur
   string prenom; // Le prenom du joueur
   double pointsMensuels; // Les points mensuels du joueur
   double pointsCours; // Les points en cour
};

// -------------------- Prototypes des fonctions ---------------------------
int menuPrincipal (const vector <Joueur> &);
void gestionJoueurs (vector <Joueur> &);
void ajouterVictoire (vector <Joueur> &);
void ajouterDefaite (vector <Joueur> &);
void cloturerMois (vector <Joueur> &);
void afficherActif (const vector <Joueur> & vec);
// -------------------------------------------------------------------------

int joueurActif = 0; // Variable globale

// ----------------------- Surcharge des operateurs ------------------------
istream & operator >>(istream& is, Joueur& j)
{  
   return is >> j.nom >> j.prenom >> j.pointsMensuels >> j.pointsCours;
}

ostream & operator <<(ostream& os, const Joueur& j)
{
    return os << j.nom << ' ' << j.prenom << ' '
              << j.pointsMensuels << ' ' << j.pointsCours << endl;
}
// -------------------------------------------------------------------------

// --------------------------- Fonction gestionJoueurs --------------------------
// Fonction gestionJoueurs : permet de voir la liste des joueurs, d'ajouter un joueur, de
// supprimer un joueur et enfin de changer le joueur actif.
void gestionJoueurs (vector <Joueur> & vectorJoueurs)
{
   // Prototypes des fonctions. Ainsi, elles ne peuvent être utilisées par d'autres
   // fonctions du programme, mais seulement par gestionJoueurs ()
   void afficherListe (const vector <Joueur> &);
   void supprimerJoueur (vector <Joueur> &);
   void ajouterJoueur (vector <Joueur> &);
   void changerActif (const vector <Joueur> &);
   
   int choix;
         
   do
   {
      system ("cls");
      afficherActif (vectorJoueurs);
      
      cout << "1 - Voir la liste des joueurs"
        << "\n2 - Supprimer un joueur"
        << "\n3 - Ajouter un joueur"
        << "\n4 - Changer le joueur actif"
        << "\n5 - Revenir au menu precedent"
        << "\nVotre choix : ";
      
   // Vérifie les entrées de l'utilisateur
   while (!(cin >> choix) || choix < 1 || choix > 5)
   {
      if (cin.eof())
         cerr << "Erreur"; // Fin de fichier (^Z)
         
      else if (cin.fail() || choix < 1 || choix > 5)
      {
         cerr << "Saisie incorrecte. Recommencez : ";
         cin.clear();
         cin.ignore(numeric_limits <streamsize>::max(), '\n');
      }
   }
   
   switch (choix) // Introduit un switch
   {
      case 1:
         afficherListe (vectorJoueurs);
         break;
      case 2:
         supprimerJoueur (vectorJoueurs);
         break;
      case 3:
         ajouterJoueur (vectorJoueurs);
         break;
      case 4:
         changerActif (vectorJoueurs);
         break;
      case 5:
         return;
      default:
         cerr << "Erreur.";
         exit (1);
   }
   } while (choix != 5);
}
// -------------------------------------------------------------------------

// ------------------------  Fonction afficherListe ------------------------
void afficherListe (const vector <Joueur> & vectorJoueurs)
{
   system ("cls");
   
   afficherActif (vectorJoueurs);
   
   cout << "Les joueurs possedant une fiche sont :" << endl << endl;
   
   vector <Joueur>::const_iterator p1; // Créé un iterateur
   
   if (vectorJoueurs.empty()) // Si le vector est vide
   {
      cout << "Il n'y a pas de joueurs." << endl;
      system ("PAUSE");
      return;
   }
   
   for (p1 = vectorJoueurs.begin() ; p1 != vectorJoueurs.end() ; ++p1)
   {      
      cout << p1->nom << ' ' << p1->prenom << endl
           << "Points mensuels (base de calcul) : " << p1->pointsMensuels << endl
           << "Points en cours : " << p1->pointsCours << endl
           << "Progression : " << (p1->pointsCours) - (p1->pointsMensuels) << endl << endl
           << "--------------" << endl << endl;
   }
   
   cout << endl << endl;

   system ("PAUSE");
}
// ----------------------------------------------------------------------------

// ------------------ Fonction ajouterJoueur --------------------------------------
void ajouterJoueur (vector <Joueur> & vectorJoueurs)
{
   system ("cls"); // Purge l'affichage
   
   afficherActif (vectorJoueurs);
   
   cout << "Ajout d'un nouveau joueur)\n" << endl << endl;
   Joueur temp; // Instancie un nouveau Joueur
   
   cout << "Entrez le nom puis le prenom du joueur : ";
   cin >> temp.nom >> temp.prenom;
   cout << "Indiquez vos points mensuels : ";
   cin >> temp.pointsMensuels;
   temp.pointsCours = temp.pointsMensuels;
   
   vectorJoueurs.push_back (temp); // Ajoute le nouveau joueur dans le vector  
}
// ----------------------------------------------------------------------------

// --------------------- Fonction supprimerJoueur -------------------------------
void supprimerJoueur (vector <Joueur> & vectorJoueurs)
{
   system ("cls"); // Purge l'affichage
   
   afficherActif (vectorJoueurs);
   
   cout << "Suppression d'un joueur)\n" << endl << endl;
   
   if (vectorJoueurs.empty())
   {
      cout << "Il n'y a aucun joueurs." << endl;
      system ("PAUSE");
      return;
   }
   
   vector <Joueur>::iterator p1;
   
   int i = 1;
   
   for (p1 = vectorJoueurs.begin() ; p1 != vectorJoueurs.end() ; p1++, ++i)
   {
      cout << i << " - " << p1->nom << ' ' << p1->prenom << endl;
   }
   
   int suppr;
   cout << "\nQuel joueur souhaitez-vous supprimer ? ";
   cin >> suppr;
   suppr -= 1; // Supprime 1. Si le joueur tape 1 (le premier joueur), l'itérateur se placera
               // au deuxième élément (begin() + 1). Ainsi, si l'utilisateur tape 1 (soit le
               // premier joueur), suppr deviendra 0. Enfin bref, j'me comprends.
               
   Joueur temp = vectorJoueurs.at(suppr);
   vectorJoueurs.erase (vectorJoueurs.begin() + suppr);
   
   cout << temp.nom << ' ' << temp.prenom << " n'est plus..." << endl << endl;
   system ("PAUSE");
}
// --------------------------------------------------------------------------

void ajouterVictoire (vector <Joueur> & vectorJoueurs)
{
   system ("cls");
   
   afficherActif (vectorJoueurs);
   
   double pointsAdverses, coefficient, pointsGagnes;
   
   cout << "Le nombre de points de l'adversaire ? ";
   cin >> pointsAdverses;
   cout << "Coefficient ? ";
   cin >> coefficient;
   
   vector <Joueur>::iterator p1 = vectorJoueurs.begin() + joueurActif;
   
   pointsAdverses -= p1->pointsMensuels;
      
   if (pointsAdverses <= 0) // Victoire normale
   {
      if (pointsAdverses == 0 && pointsAdverses >= -24)
         pointsGagnes = 6;
      
      else if (pointsAdverses <= -25 && pointsAdverses >= -49)
         pointsGagnes = 5.5;
      
      else if (pointsAdverses <= -50 && pointsAdverses >= -99)
         pointsGagnes = 5.0;
      
      else if (pointsAdverses <= -100 && pointsAdverses >= -149)
         pointsGagnes = 4.0;
         
      else if (pointsAdverses <= -150 && pointsAdverses >= -199)
         pointsGagnes = 3.0;
      
      else if (pointsAdverses <= -200 && pointsAdverses >= -299)
         pointsGagnes = 2.0;
      
      else if (pointsAdverses <= -300 && pointsAdverses >= -399)
         pointsGagnes = 1.0;
      
      else if (pointsAdverses <= -400 && pointsAdverses >= -499)
         pointsGagnes = 0.5;
      
      else
         pointsGagnes = 0.0;
   }
   
   else // Victoire anormale
   {
      if (pointsAdverses > 0 && pointsAdverses <= 24)
         pointsGagnes = 6;
      
      else if (pointsAdverses >= 25 && pointsAdverses <= 49)
         pointsGagnes = 7.0;
      
      else if (pointsAdverses >= 50 && pointsAdverses <= 99)
         pointsGagnes = 8.0;
      
      else if (pointsAdverses >= 100 && pointsAdverses <= 149)
         pointsGagnes = 10.0;
         
      else if (pointsAdverses >= 150 && pointsAdverses <= 199)
         pointsGagnes = 13.0;
      
      else if (pointsAdverses >= 200 && pointsAdverses <= 299)
         pointsGagnes = 17.0;
      
      else if (pointsAdverses >= 300 && pointsAdverses <= 399)
         pointsGagnes = 22.0;
      
      else if (pointsAdverses >= 400 && pointsAdverses <= 499)
         pointsGagnes = 28.0;
      
      else
         pointsGagnes = 35.0;
   }
   
   pointsGagnes *= coefficient;
   p1->pointsCours += pointsGagnes;
   
   cout << "Points gagnes pour ce match : " << pointsGagnes << endl << endl;
   system ("PAUSE");
}

// --------------------------------

void ajouterDefaite (vector <Joueur> & vectorJoueurs)
{
   system ("cls");
   
   afficherActif (vectorJoueurs);
   
   double pointsAdverses, coefficient, pointsPerdus;
   
   cout << "Le nombre de points de l'adversaire ? ";
   cin >> pointsAdverses;
   cout << "Coefficient ? ";
   cin >> coefficient;
   
   vector <Joueur>::iterator p1 = vectorJoueurs.begin() + joueurActif;
   
   pointsAdverses -= p1->pointsMensuels;
      
   if (pointsAdverses >= 0) // Défaite normale
   {
      if (pointsAdverses == 0 && pointsAdverses <= 24)
         pointsPerdus = 5.0;
      
      else if (pointsAdverses >= 25 && pointsAdverses <= 49)
         pointsPerdus = 4.5;
      
      else if (pointsAdverses >= 50 && pointsAdverses <= 99)
         pointsPerdus = 4.0;
      
      else if (pointsAdverses >= 100 && pointsAdverses <= 149)
         pointsPerdus = 3.0;
         
      else if (pointsAdverses >= 150 && pointsAdverses <= 199)
         pointsPerdus = 2.0;
      
      else if (pointsAdverses >= 200 && pointsAdverses <= 299)
         pointsPerdus = 1.0;
      
      else if (pointsAdverses >= 300 && pointsAdverses <= 399)
         pointsPerdus = -0.5;
      
      else if (pointsAdverses >= 400 && pointsAdverses <= 499)
         pointsPerdus = 0.0;
      
      else
         pointsPerdus = 0.0;
   }
   
   else // Défaite anormale
   {
      if (pointsAdverses < 0 && pointsAdverses >= -24)
         pointsPerdus = 5.0;
      
      else if (pointsAdverses <= -25 && pointsAdverses >= -49)
         pointsPerdus = 6.0;
      
      else if (pointsAdverses <= -50 && pointsAdverses >= -99)
         pointsPerdus = 7.0;
      
      else if (pointsAdverses <= -100 && pointsAdverses >= -149)
         pointsPerdus = 8.0;
         
      else if (pointsAdverses <= -150 && pointsAdverses >= -199)
         pointsPerdus = 10.0;
      
      else if (pointsAdverses <= -200 && pointsAdverses >= -299)
         pointsPerdus = 12.5;
      
      else if (pointsAdverses <= -300 && pointsAdverses >= -399)
         pointsPerdus = 16.0;
      
      else if (pointsAdverses <= -400 && pointsAdverses >= -499)
         pointsPerdus = 20.0;
      
      else
         pointsPerdus = 25.0;
   }
   
   pointsPerdus *= coefficient;
   p1->pointsCours -= pointsPerdus;
   
   cout << "Points perdus pour ce match : " << pointsPerdus << endl << endl;
   system ("PAUSE");
}

// -----------------------------

void changerActif (const vector <Joueur> & vec)
{
   system ("cls");
   
   afficherActif (vec);
   
   vector <Joueur>::const_iterator p1;
   int i = 1;
   
   for (p1 = vec.begin() ; p1 != vec.end() ; ++p1, ++i)
   {
      cout << i << " - " << p1->nom << ' ' << p1->prenom << endl;
   }
   
   int choix;
   cout << "\nQuel joueur voulez-vous rendre actif ? ";
   cin >> choix;
   
   joueurActif = choix - 1; // Change la valeur de la variable globale
}

// ---------------------------------   

void cloturerMois (vector <Joueur> & vectorJoueurs)
{
   system ("cls");
   
   afficherActif (vectorJoueurs);
   
   cout << "Le mois va etre cloture pour le joueur : "
        << vectorJoueurs.at(joueurActif).nom << ' '
        << vectorJoueurs.at(joueurActif).prenom << endl
        << "Ses points mensuels vont etre ajustes a : "
        << vectorJoueurs.at(joueurActif).pointsCours << " (soit une progression de "
        << vectorJoueurs.at(joueurActif).pointsCours - vectorJoueurs.at(joueurActif).pointsMensuels
        << ")" << endl;
   
   char choix;
   cout << "\nVoulez-vous vraiment effectuer cette action ? (o/n) : ";
   
   cin >> choix;
   
   // Le code en commentaire ne fonctionne pas
   /*while (!(cin >> choix) || choix != 'o' || choix != 'n')
   {
      if (cin.eof())
         cerr << "Erreur";
         
      else if (cin.fail() || choix != 'o' || choix != 'n')
      {
            cerr << "Saisie incorrecte. Recommencez : ";
            cin.clear();
            cin.ignore(numeric_limits <streamsize>::max(), '\n');
      }
   }*/
   
   if (choix == 'o')
   {
      vectorJoueurs.at(joueurActif).pointsMensuels = vectorJoueurs.at(joueurActif).pointsCours;
      cout << "Points mensuels mis a jour." << endl << endl;
   }
        
   system ("PAUSE");
}

// -----------------------------

int menuPrincipal (const vector <Joueur> & vec)
{
   int rubrique;
         
   while (true)
   {
      system ("cls"); // Vide l'affichage
      
      afficherActif (vec);
      
      cout << "1 - Gestion des joueurs"
           << "\n2 - Ajouter une victoire au joueur actif"
           << "\n3 - Ajouter une defaite au joueur actif"
           << "\n4 - Cloturer le mois du joueur actif"
           << "\n5 - Quitter et sauvegarder"
           << "\nVotre choix : ";
      
      // Teste les cas d'entrée invalide.
      while (!(cin >> rubrique) || rubrique < 1 || rubrique > 5)
      {
         if (cin.eof())
            return false; // Fin de fichier (^Z)
            
         else if (cin.fail() || rubrique < 1 || rubrique > 5)
         {
            cerr << "Saisie incorrecte. Recommencez : ";
            cin.clear();
            cin.ignore(numeric_limits <streamsize>::max(), '\n');
         }
      }
      
      return rubrique;
   }
}

void afficherActif (const vector <Joueur> & vec)
{      
   if (vec.empty())
   {
      cout << "\tPas de joueurs inscrits, donc pas de joueur actif ;)" << endl << endl;
      return;
   }
   
   vector <Joueur>::const_iterator i1 = vec.begin() + joueurActif;
   
   cout << "\t------------ Joueur actif : " << i1-> nom << ' ' << i1->prenom << ' '
        << '(' << i1->pointsMensuels << " points" << ')' << " ------------" << endl << endl;
}