Import source code from old project

.gitignore

@@ -0,0 +1,40 @@
+# Created by https://www.toptal.com/developers/gitignore/api/c++
+# Edit at https://www.toptal.com/developers/gitignore?templates=c++
+
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# End of https://www.toptal.com/developers/gitignore/api/c++
+
+bin/

Balle.cpp

@@ -0,0 +1,96 @@
+#include "Balle.h"
+
+Balle::Balle(int nbRqt)
+:m_nbRqt(nbRqt),
+m_point(RAYON_BALLE,BLEU), m_position(RAYON_FENETRE, RAYON_FENETRE),
+ m_trajectoire(rand()-RAND_MAX/2, rand()-RAND_MAX/2), m_vitesse((float)VITESSE_MAX/4), m_centre(RAYON_FENETRE, RAYON_FENETRE)
+
+{
+    //[1] Renplit le tableau de pointeurs
+    for (int i(0); i<NB_JOUEURS_MAX; i++)
+        m_tableauRqt[i]=0;
+
+    //[2] Met la valeur de la trajectoire à 1
+    m_trajectoire.normaliser();
+}///Constructeur
+
+
+void Balle::ajouterRaquette(unsigned int slot, Raquette *ajoutRqt)
+{
+    if (slot >= 0 && slot<NB_JOUEURS_MAX)
+        m_tableauRqt[slot] = ajoutRqt;
+}///ajouterRaquette
+
+bool Balle::bouger(SDL_Surface* screen)
+{
+    //[1] On bouge
+    m_position += m_trajectoire*m_vitesse;
+    if((m_position-m_centre).norme()<=RAYON_TERRAIN)//(m_position-m_centre).norme() est égal à la distance par rapport au centre
+        return true;
+    else
+    //[2] ça sort ou pas ?
+    {
+        //[2.1] Position sur limite
+        m_position = m_centre+(m_position-m_centre).normalise()*(RAYON_TERRAIN-RAYON_BALLE);
+        float angleEcart;
+        bool droite;
+
+        //[2.2] Hum... y a t'il une raquette ?
+        for (int i(0); i<NB_JOUEURS_MAX; i++)
+            if (m_tableauRqt[i]!=0)
+            {
+                angleEcart = (m_position-m_centre).scalair(m_tableauRqt[i]->getAngleActuel());
+                Vecteur tmp(m_position-m_centre);
+                tmp.rotate(5);
+                droite = (tmp.scalair(m_tableauRqt[i]->getAngleActuel())<angleEcart);
+                if (angleEcart<=ANGLE_ECART_RQT)
+                {
+                    m_trajectoire = (m_centre-m_position).normalise();
+                    if (m_vitesse<VITESSE_MAX)
+                        m_vitesse *= ACCELERATEUR;
+                    if(droite)
+                        m_trajectoire.rotate(angleEcart/ANGLE_ECART_RQT*30);
+                    else
+                        m_trajectoire.rotate(-angleEcart/ANGLE_ECART_RQT*30);
+
+                    return true;
+                }
+            }
+
+        //[2.3] Pas raquette... hors zone !
+        camenbertPerdant(screen);
+        m_position = m_centre;
+        m_trajectoire = Vecteur(rand()-RAND_MAX/2, rand()-RAND_MAX/2).normalise();
+        m_vitesse = (float)VITESSE_MAX/4;
+        return false;
+    }
+}///bouger
+
+void Balle::afficher(SDL_Surface* screen)
+{
+    m_point.afficherPoint(screen,m_position.getX(),m_position.getY());
+}///afficher
+
+void Balle::camenbertPerdant(SDL_Surface* screen)
+{
+    SDL_Surface *pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
+    SDL_FillRect(pixel,0,SDL_MapRGB(pixel->format, 255, 0, 0));
+    SDL_Rect pos;
+    for(int y = -RAYON_TERRAIN;y < RAYON_TERRAIN; y++)
+        for(int x = -RAYON_TERRAIN;x < RAYON_TERRAIN; x++)
+        {
+            if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN &&
+               ((m_nbRqt == 2 && y*((m_position.getY()-RAYON_TERRAIN<0)*2-1)<0) ||
+                (m_nbRqt == 3 && ((x-(y*1.75)<0 && ((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN)*1.75<0) && x+(y*1.75)>0 && ((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN)*1.75>0)) ||
+                                  (x*(m_position.getX()-RAYON_FENETRE)>0 && ((x-(y*1.75)>0 && ((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN)*1.75>0) && m_position.getX()-RAYON_FENETRE>0) || (x+(y*1.75)<0 && ((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN)*1.75<0) && m_position.getX()-RAYON_FENETRE<0))))) || // <- n'est pas fini
+                (m_nbRqt == 4 && (x-y)*((((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN))<0)*2-1)<0 && (x+y)*-((((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN))<0)*2-1)>0)))
+            {
+                pos.x = x+RAYON_FENETRE;
+                pos.y = y+RAYON_FENETRE;
+                SDL_BlitSurface(pixel, 0, screen, &pos);
+            }
+        }
+    SDL_Flip(screen);
+    SDL_Delay(200);
+}
+

Balle.h

@@ -0,0 +1,43 @@
+#ifndef BALLE_H_INCLUDED
+#define BALLE_H_INCLUDED
+
+#define ACCELERATEUR 1.1
+#define VITESSE_MAX (COTE/80)
+#define BLEU 2016
+#define NB_JOUEURS_MAX 4
+#define RAYON_BALLE (COTE/80)
+
+///Dernière modif: 25/06/2013 debug angle de frappe
+///Objet: amélioration de la trajectoire aléatoire
+///A faire: Variation d'angle lors de la frappe
+
+#include "main.h"
+
+#include "Raquette.h"
+
+class Balle
+{
+public:
+    Balle(int nbRqt);
+
+    void ajouterRaquette(unsigned int slot, Raquette *ajoutRqt);
+    bool bouger(SDL_Surface* screen);//rebon potentiel, renvoie true quand Ok, false quand hors zone
+    void afficher(SDL_Surface* screen);
+    void camenbertPerdant(SDL_Surface* screen);
+
+protected:
+    //Attributs vectoriels
+    Vecteur m_position;
+    Vecteur m_trajectoire;
+    Vecteur m_centre;
+    float m_vitesse;
+
+    //Attributs images
+    Point m_point;
+
+    //Attributs spécifiques
+    Raquette* m_tableauRqt[NB_JOUEURS_MAX];
+    int const m_nbRqt;
+};
+
+#endif // BALLE_H_INCLUDED

Raquette.cpp

@@ -0,0 +1,84 @@
+#include "Raquette.h"
+
+Raquette::Raquette(int identifiant, int nbJoueursTotal, Uint32 couleur):
+    m_identifiant(identifiant),m_centre(COTE/2,COTE/2),
+    m_angleOrigine(0,COTE/2-COTE/36),m_angleEcartMax(180/nbJoueursTotal-(asin((float)RAYON_RQT/RAYON_TERRAIN)*180/M_PI))
+{
+    m_angleOrigine.rotate(360.0/nbJoueursTotal*identifiant);
+    m_angleActuel = m_angleOrigine;
+
+    m_pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
+    SDL_FillRect(m_pixel,0,couleur);
+    m_position = m_centre+m_angleActuel;
+
+}///Constructeur
+
+Raquette::~Raquette()
+{
+    SDL_FreeSurface(m_pixel);
+}///Destructeur
+
+void Raquette::afficher(SDL_Surface* screen)
+{
+    // [1] Balayage des positions
+    SDL_Rect pos;
+    float distanceCentre;
+    for(int y(-RAYON_RQT);y<RAYON_RQT;y++)
+        for(int x(-RAYON_RQT);x<RAYON_RQT;x++)
+        {
+            // [2] Position du point en balayage
+            pos.x = m_position.getX()+x;
+            pos.y = m_position.getY()+y;
+            distanceCentre = (Vecteur(pos.x, pos.y)-m_centre).norme();
+            // [3] Arrondi
+            if(distanceCentre < RAYON_FENETRE && distanceCentre > RAYON_TERRAIN &&
+               x*x+y*y < (RAYON_RQT)*(RAYON_RQT))
+                SDL_BlitSurface(m_pixel, 0, screen, &pos);
+        }
+}///afficher
+
+void Raquette::deplacer(bool droite)
+{
+    // [1] Teste si la raquette a le droit de bouger
+    bool ecart = m_angleActuel.scalair(m_angleOrigine)<=m_angleEcartMax;
+    // [2] On bouge
+    //[2.1] Vers la droite
+    if(droite && ecart)
+    {
+        //[2.1.1]Mouvement
+        m_angleActuel.rotate(VITESSE);
+        //[2.1.2]Pas trop loin !
+        if (m_angleActuel.scalair(m_angleOrigine)>m_angleEcartMax)
+        {
+            Vecteur tmp(m_angleOrigine);
+            tmp.rotate(m_angleEcartMax-0.05);
+            m_angleActuel = tmp;
+        }
+
+    }
+    //[2.2] Ou vers la gauche
+    else if (ecart)
+    {
+        m_angleActuel.rotate(-VITESSE);
+        if (m_angleActuel.scalair(m_angleOrigine)>m_angleEcartMax)
+        {
+            Vecteur tmp(m_angleOrigine);
+            tmp.rotate(-m_angleEcartMax+0.05);
+            m_angleActuel = tmp;
+        }
+    }
+    else
+    {
+        Vecteur tmp(m_angleOrigine);
+        tmp.rotate(-m_angleEcartMax);
+        m_angleActuel = tmp;
+    }
+    // [END]
+    m_position = m_centre+m_angleActuel;
+}///deplacer
+
+Vecteur Raquette::getAngleActuel()
+{
+    return m_angleActuel;
+}///getAngleActuel
+

Raquette.h

@@ -0,0 +1,37 @@
+#ifndef RAQUETTE_H_INCLUDED
+#define RAQUETTE_H_INCLUDED
+
+#include "main.h"
+
+#define VITESSE 1.5
+#define RAYON_FENETRE (COTE/2)
+#define RAYON_TERRAIN (RAYON_FENETRE-COTE/36)
+#define RAYON_RQT (COTE/12)
+#define ANGLE_ECART_RQT (asin((float)RAYON_RQT/RAYON_TERRAIN)*180/M_PI+1)
+
+class Raquette
+{
+public:
+    Raquette(int identifiant, int nbJoueursTotal, Uint32 couleur);
+    ~Raquette();
+
+    void afficher(SDL_Surface* screen);
+    void deplacer(bool droite);
+    Vecteur getAngleActuel();
+
+private:
+    //Attributs vectoriels
+    Vecteur m_angleActuel;
+    Vecteur m_angleOrigine;
+    Vecteur m_centre;
+    Vecteur m_position;
+
+    //Autres
+    float const m_angleEcartMax;
+    unsigned short m_identifiant;
+
+    //Attributs SDL
+    SDL_Surface *m_pixel;
+};
+
+#endif // RAQUETTE_H_INCLUDED

include/Input.h

@@ -0,0 +1,127 @@
+#ifndef INPUT_H_INCLUDED
+#define INPUT_H_INCLUDED
+
+#include <SDL/SDL.h>
+#undef main
+
+class Input
+{
+public:
+    Input(): m_x(0), m_y(0), m_xRel(0), m_yRel(0), m_continuer(true)
+    {
+        for(int i = 0;i<323;i++)
+            m_touches[i] = false;
+
+        for(int i = 0;i<8;i++)
+            m_boutonsSouris[i] = false;
+    }
+    ~Input()
+    {
+
+    }
+
+    void updateEvenement()
+    {
+        m_xRel = 0;
+        m_yRel = 0;
+
+        while(SDL_PollEvent(&m_evenement))
+        {
+            switch(m_evenement.type)
+            {
+            case SDL_QUIT:
+                m_continuer = false;
+                break;
+
+            case SDL_KEYDOWN:
+                m_touches[m_evenement.key.keysym.sym] = true;
+                break;
+
+            case SDL_KEYUP:
+                m_touches[m_evenement.key.keysym.sym] = false;
+                break;
+
+            case SDL_MOUSEBUTTONDOWN:
+                m_boutonsSouris[m_evenement.button.button] = true;
+                break;
+
+            case SDL_MOUSEBUTTONUP:
+                m_boutonsSouris[m_evenement.button.button] = false;
+                break;
+
+            case SDL_MOUSEMOTION:
+                m_x = m_evenement.motion.x;
+                m_y = m_evenement.motion.y;
+
+                m_xRel = m_evenement.motion.xrel;
+                m_yRel = m_evenement.motion.yrel;
+                break;
+
+            default:
+                break;
+            }
+        }
+    }
+    bool continuer() const
+    {
+        return m_continuer;
+    }
+    bool getTouches(const SDLKey touche) const
+    {
+        return m_touches[touche];
+    }
+    bool getBoutonSouris(const Uint8 bouton) const
+    {
+        return m_boutonsSouris[bouton];
+    }
+    bool mouvementSouris() const
+    {
+        if(m_xRel == 0 && m_yRel == 0)
+            return false;
+
+        else
+            return true;
+    }
+    int getX() const
+    {
+        return m_x;
+    }
+    int getY() const
+    {
+        return m_y;
+    }
+    int getXRel() const
+    {
+        return m_xRel;
+    }
+    int getYRel() const
+    {
+       return m_yRel;
+    }
+    void afficherPointeur(bool reponse) const
+    {
+        if(reponse)
+            SDL_ShowCursor(SDL_ENABLE);
+        else
+            SDL_ShowCursor(SDL_DISABLE);
+    }
+    /*void capturerPointeur(bool reponse) const
+    {
+        if(reponse)
+            SDL_SetRelativeMouseMode(SDL_TRUE);
+        else
+            SDL_SetRelativeMouseMode(SDL_FALSE);
+    }*/
+
+private:
+    SDL_Event m_evenement;
+    bool m_touches[323];
+    bool m_boutonsSouris[8];
+
+    int m_x, m_y;
+    int m_xRel, m_yRel;
+
+    bool m_continuer;
+};
+
+#endif // INPUT_H_INCLUDED

include/Point.cpp

@@ -0,0 +1,56 @@
+#include "Point.h"
+
+Point::Point(int rayon,Uint32 couleur)
+:m_rayon(rayon)
+{
+    m_pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
+    SDL_FillRect(m_pixel,NULL,couleur);
+    if (!m_pixel)
+    {
+        std::cout << "Impossible de créer la surface dans l'objet Point " << SDL_GetError() << std::endl;
+    }
+}///Constructeur standard
+
+Point::Point(int rayon,Uint32 couleur,int transparence)
+:m_rayon(rayon)
+{
+    m_pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
+    SDL_FillRect(m_pixel,NULL,couleur);
+    if (!m_pixel)
+    {
+        std::cout << "Impossible de créer la surface dans l'objet Point " << SDL_GetError() << std::endl;
+    }
+}///Constructeur +transparence
+
+Point::~Point()
+{
+    SDL_FreeSurface(m_pixel);
+    m_pixel=0;
+    std::cout << "Destruction du point effective. " << std::endl;
+}///Destructeur
+
+int Point::getRayon()
+{
+    return m_rayon;
+}///getRayon
+
+void Point::afficherPoint(SDL_Surface *screen,int const x, int const y)
+{
+    int distance(0);
+    SDL_Rect position;
+    for (int i(x-m_rayon); i<=x+m_rayon; i++)
+    {
+        for (int j(y-m_rayon); j<=y+m_rayon; j++)
+        {
+            distance = pow(i-x,2)+pow(j-y,2);
+            if (distance <= pow(m_rayon,2))
+            {
+                position.x=i;
+                position.y=j;
+                SDL_BlitSurface(m_pixel, 0, screen, &position);
+            }//test blit
+        }//for j
+    }//for i
+}///afficherPoint
+
+

include/Point.h

@@ -0,0 +1,42 @@
+#ifndef POINT_H_INCLUDED
+#define POINT_H_INCLUDED
+
+///Modifié le: 10/06/2013
+///Objet: débuggage, mise en fonction
+
+#include <iostream>
+#include <SDL/SDL.h>
+#include <cmath>
+
+/*
+===La classe Point===
+    +Définition:
+        La classe Point permet de créer un  point.
+    +Fonctions:
+        -Constructeur standard:
+            Ne prend que le rayon et la couleur en paramètre, mesure en nb de pixels.
+        -Constructeur amélioré:
+            Permet de définir en plus du rayon et de la couleur
+            le coefficient de transparence. (0=visible à 255=invsible)
+        -getRayon:
+            Permet d'obtenir le rayon.
+
+*/
+
+class Point
+{
+    public:
+    Point(int rayon,Uint32 couleur);
+    Point(int rayon,Uint32 couleur,int transparence);
+    ~Point();
+    int getRayon();
+    void afficherPoint(SDL_Surface *screen,int const x, int const y);
+
+    private:
+    //Attributs standards:
+    int const m_rayon;
+
+    //Attributs SDL:
+    SDL_Surface *m_pixel;
+};
+#endif // POINT_H_INCLUDED

include/Vecteur.h

@@ -0,0 +1,263 @@
+#ifndef VECTEUR_H_INCLUDED
+#define VECTEUR_H_INCLUDED
+
+#include <cmath>
+
+class Vecteur
+{
+    public:
+
+    Vecteur() : m_x(0.0), m_y(0.0), m_z(0.0)
+    {
+
+    }
+    Vecteur(float x, float y, float z = 0) : m_x(x), m_y(y), m_z(z)
+    {
+
+    }
+    Vecteur(const Vecteur &vecteur) : m_x(vecteur.getX()), m_y(vecteur.getY()), m_z(vecteur.getZ())
+    {
+
+    }
+    ~Vecteur()
+    {
+
+    }
+    float getX() const
+    {
+        return m_x;
+    }
+
+    float getY() const
+    {
+        return m_y;
+    }
+
+    float getZ() const
+    {
+        return m_z;
+    }
+
+
+    // Setters
+
+    void setVecteur(float x, float y, float z)
+    {
+        m_x = x;
+        m_y = y;
+        m_z = z;
+    }
+
+    void setX(float x)
+    {
+        m_x = x;
+    }
+
+    void setY(float y)
+    {
+        m_y = y;
+    }
+
+    void setZ(float z)
+    {
+        m_z = z;
+    }
+    void normaliser()
+    {
+        // La fonction sqrt() permet de trouver la racine carré d'un nombre
+
+        float longueur (sqrt(m_x * m_x + m_y * m_y + m_z * m_z));
+
+
+        // Normalisation du vecteur
+
+        if(longueur != 0.0)
+        {
+            m_x /= longueur;
+            m_y /= longueur;
+            m_z /= longueur;
+        }
+    }
+    Vecteur normalise()
+    {
+        // La fonction sqrt() permet de trouver la racine carré d'un nombre
+        Vecteur resultat;
+        float longueur (sqrt(m_x * m_x + m_y * m_y + m_z * m_z));
+
+
+        // Normalisation du vecteur
+
+        if(longueur != 0.0)
+        {
+            resultat.setX(m_x/longueur);
+            resultat.setY(m_y/longueur);
+            resultat.setZ(m_z/longueur);
+        }
+        return resultat;
+    }
+    Vecteur& operator=(const Vecteur &vecteur)
+    {
+        // Copie des valeurs
+
+        m_x = vecteur.m_x;
+        m_y = vecteur.m_y;
+        m_z = vecteur.m_z;
+
+
+        // Retour de l'objet
+
+        return *this;
+    }
+    Vecteur operator+(const Vecteur &vecteur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Addition des coordonnées
+
+        resultat.m_x = m_x + vecteur.m_x;
+        resultat.m_y = m_y + vecteur.m_y;
+        resultat.m_z = m_z + vecteur.m_z;
+
+
+        // Retour de résultat
+
+        return resultat;
+    }
+    Vecteur operator-(const Vecteur &vecteur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Soustraction des coordonnées
+
+        resultat.m_x = m_x - vecteur.m_x;
+        resultat.m_y = m_y - vecteur.m_y;
+        resultat.m_z = m_z - vecteur.m_z;
+
+
+        // Retour de résultat
+
+        return resultat;
+    }
+    Vecteur operator*(float multiplicateur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Multiplication des coordonnées
+
+        resultat.m_x = m_x * multiplicateur;
+        resultat.m_y = m_y * multiplicateur;
+        resultat.m_z = m_z * multiplicateur;
+
+
+        // Retour du résultat
+
+        return resultat;
+    }
+    Vecteur operator/(float diviseur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Multiplication des coordonnées
+
+        resultat.m_x = m_x / diviseur;
+        resultat.m_y = m_y / diviseur;
+        resultat.m_z = m_z / diviseur;
+
+
+        // Retour du résultat
+
+        return resultat;
+    }
+    Vecteur operator*(const Vecteur &vecteur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Produit Vectoriel
+
+        resultat.m_x = (m_y * vecteur.m_z) - (m_z * vecteur.m_y);
+        resultat.m_y = (m_z * vecteur.m_x) - (m_x * vecteur.m_z);
+        resultat.m_z = (m_x * vecteur.m_y) - (m_y * vecteur.m_x);
+
+
+        // Retour de l'objet
+
+        return resultat;
+    }
+    void operator*=(const Vecteur &vecteur)
+    {
+        *this = *this * vecteur;
+    }
+    void operator-=(const Vecteur &vecteur)
+    {
+        *this = *this - vecteur;
+    }
+    void operator+=(const Vecteur &vecteur)
+    {
+        *this = *this + vecteur;
+    }
+    void operator*=(float multiplicateur)
+    {
+        *this = *this * multiplicateur;
+    }
+    void operator/=(float multiplicateur)
+    {
+        *this = *this * multiplicateur;
+    }
+    float scalair(const Vecteur &vecteur)
+    {
+        Vecteur v1(*this), v2(vecteur);
+        v1.normaliser();
+        v2.normaliser();
+        float produitScalair = v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
+        if(produitScalair>1)
+            produitScalair = 1;
+        return acos(produitScalair)*180/M_PI;
+    }
+    bool operator==(const Vecteur &vecteur)
+    {
+        if(m_x == vecteur.getX() && m_y == vecteur.getY() && m_z == vecteur.getZ())
+            return true;
+        else
+            return false;
+    }
+    bool operator!=(const Vecteur &vecteur)
+    {
+        if(*this == vecteur)
+            return false;
+        else
+            return true;
+    }
+    double norme()
+    {
+        return sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
+    }
+    void rotate(float angle)
+    {
+        float _angle = angle*M_PI/180;
+        float tmp = m_x;
+        m_x = cos(_angle)*m_x-sin(_angle)*m_y;
+        m_y = sin(_angle)*tmp+cos(_angle)*m_y;
+    }
+
+private:
+    float m_x;
+    float m_y;
+    float m_z;
+};
+
+#endif // VECTEUR_H_INCLUDED

jeu.cpp

@@ -0,0 +1,171 @@
+#include "jeu.h"
+void tracerLigne(SDL_Surface *screen, int nbJoueurs)
+{
+    SDL_Rect pos;
+    SDL_Surface* pixel;
+    pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
+    SDL_FillRect(pixel, 0, SDL_MapRGB(pixel->format, 255, 255, 255));
+    for(int y = -RAYON_FENETRE; y<RAYON_FENETRE; y++)
+    {
+        for(int x = -RAYON_FENETRE; x<RAYON_FENETRE; x++)
+        {
+            pos.x = x+RAYON_FENETRE;
+            pos.y = y+RAYON_FENETRE;
+            if(nbJoueurs == 2)
+            {
+                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && y>-LARGEUR_LIGNE && y<LARGEUR_LIGNE)
+                    SDL_BlitSurface(pixel, 0, screen, &pos);
+            }
+            else if(nbJoueurs == 3)
+            {
+                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && ((y<0 && x>-LARGEUR_LIGNE && x<LARGEUR_LIGNE) || (y>-COTE/400 && abs(1.75*y)-abs(x)>-LARGEUR_LIGNE*2 && abs(1.75*y)-abs(x)<LARGEUR_LIGNE*2)))
+                    SDL_BlitSurface(pixel, 0, screen, &pos);
+            }
+            else if(nbJoueurs == 4)
+            {
+                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && abs(y)-abs(x)>-LARGEUR_LIGNE && abs(y)-abs(x)<LARGEUR_LIGNE)
+                    SDL_BlitSurface(pixel, 0, screen, &pos);
+            }
+        }
+    }
+}
+int jeu(SDL_Surface *screen,int const nbJoueurs)
+{
+    // [1] Préparation des composants
+    //[1.1] Objets pratiques
+    Uint32 tempsPrecedent(0);
+    bool continuer(true);
+
+    //[1.2] La surface point
+    SDL_Surface* arene(0);
+    arene = SDL_CreateRGBSurface(SDL_HWSURFACE, COTE, COTE, 32, 0, 0, 0, 0);
+    Point point(COTE/2,SDL_MapRGB(screen->format,0,0,255));
+    Point point2(COTE/2-COTE/36,SDL_MapRGB(screen->format,30,200,10));
+    point.afficherPoint(arene, COTE/2, COTE/2);
+    point2.afficherPoint(arene, COTE/2, COTE/2);
+    tracerLigne(arene, nbJoueurs);
+
+    //[1.2] Raquettes
+    Raquette *tabRaquette[nbJoueurs];
+    for(int i(0); i<nbJoueurs; i++)
+        tabRaquette[i] = new Raquette(i, nbJoueurs, SDL_MapRGB(screen->format, 255, 0, 0));
+
+    //[1.3] La balle
+    Balle baballe(nbJoueurs);
+    Balle baballe2(nbJoueurs);
+    for (int i(0); i<nbJoueurs; i++)
+        baballe.ajouterRaquette(i,tabRaquette[i]);
+    if(nbJoueurs == 4)
+        for (int i(0); i<nbJoueurs; i++)
+            baballe2.ajouterRaquette(i,tabRaquette[i]);
+
+    // [2] Program main loop
+    Input input;
+    bool pause = true, p = true;
+    while (continuer && !input.getTouches(SDLK_ESCAPE))
+    {
+        //baballe.camenbertPerdant(screen);
+        // [2.1] Gestion des evenement
+        input.updateEvenement();
+        continuer = input.continuer();
+        if(nbJoueurs == 2)
+        {
+            if (input.getTouches(SDLK_v))
+                tabRaquette[0]->deplacer(false);
+            if (input.getTouches(SDLK_x))
+                tabRaquette[0]->deplacer(true);
+            if (input.getTouches(SDLK_RIGHT))
+                tabRaquette[1]->deplacer(true);
+            if (input.getTouches(SDLK_LEFT))
+                tabRaquette[1]->deplacer(false);
+        }
+        if(nbJoueurs == 3)
+        {
+            if (input.getTouches(SDLK_v))
+                tabRaquette[0]->deplacer(false);
+            if (input.getTouches(SDLK_x))
+                tabRaquette[0]->deplacer(true);
+            if (input.getTouches(SDLK_q))
+                tabRaquette[1]->deplacer(true);
+            if (input.getTouches(SDLK_a))
+                tabRaquette[1]->deplacer(false);
+            if (input.getTouches(SDLK_KP3))
+                tabRaquette[2]->deplacer(true);
+            if (input.getTouches(SDLK_KP6))
+                tabRaquette[2]->deplacer(false);
+        }
+        if(nbJoueurs == 4)
+        {
+            if (input.getTouches(SDLK_v))
+                tabRaquette[0]->deplacer(false);
+            if (input.getTouches(SDLK_x))
+                tabRaquette[0]->deplacer(true);
+            if (input.getTouches(SDLK_q))
+                tabRaquette[1]->deplacer(true);
+            if (input.getTouches(SDLK_a))
+                tabRaquette[1]->deplacer(false);
+            if (input.getTouches(SDLK_RIGHT))
+                tabRaquette[2]->deplacer(true);
+            if (input.getTouches(SDLK_LEFT))
+                tabRaquette[2]->deplacer(false);
+            if (input.getTouches(SDLK_KP3))
+                tabRaquette[3]->deplacer(true);
+            if (input.getTouches(SDLK_KP6))
+                tabRaquette[3]->deplacer(false);
+        }
+
+        if(input.getTouches(SDLK_SPACE) && p)
+        {
+            pause = true;
+            p = false;
+        }
+        else if(!input.getTouches(SDLK_SPACE))
+            p = true;
+
+        // [3] Calcul
+        baballe.bouger(screen);
+        //if(nbJoueurs == 4)
+            //baballe2.bouger(screen);
+
+        // [4] Dessin
+        SDL_BlitSurface(arene, 0, screen, 0);
+        for(int i(0); i<nbJoueurs; i++)
+            tabRaquette[i]->afficher(screen);
+        baballe.afficher(screen);
+        if(nbJoueurs == 4)
+            baballe2.afficher(screen);
+
+        SDL_Flip(screen);
+
+        //[5] Gestion du temps
+        while (15>SDL_GetTicks()-tempsPrecedent || pause)
+        {
+            //ça bloque pendant 30 ms moins le temps de calcul
+            if(pause)
+            {
+                input.updateEvenement();
+                if(input.getTouches(SDLK_SPACE) && p)
+                {
+                    pause = false;
+                    p = false;
+                }
+                else if(!input.getTouches(SDLK_SPACE))
+                    p = true;
+                if(!input.continuer() || input.getTouches(SDLK_ESCAPE))
+                {
+                    continuer = false;
+                    break;
+                }
+            }
+        }
+        tempsPrecedent=SDL_GetTicks();
+
+    } ///Boucle évenementielle
+
+    // [6] Nettoyage
+    for(int i(0); i<nbJoueurs; i++)
+        delete tabRaquette[i];
+
+    // [END] Renvoi
+    return 0;
+}

jeu.h

@@ -0,0 +1,16 @@
+#ifndef JEU_H_INCLUDED
+#define JEU_H_INCLUDED
+
+///Dernière modif:
+///Objet:
+
+#include "main.h"
+
+#include "Raquette.h"
+#include "Balle.h"
+
+#define LARGEUR_LIGNE COTE/160
+
+int jeu(SDL_Surface *screen,int const nbJoueurs);
+
+#endif // JEU_H_INCLUDED

main.cpp

@@ -0,0 +1,59 @@
+#include "main.h"
+
+#include "jeu.h"
+
+
+int main ( int argc, char** argv )
+{
+    std::cout << "-+°, PONG CIRCLE ,°+-" << std::endl;
+    std::cout << "plain ecran? ( 1 oui / 0 non ) : ";
+    bool fullScreen;
+    std::cin >> fullScreen;
+    int nbJoueurs;
+    std::cout << "Entrez le nombre de joueurs (2/3/4) : ";
+    std::cin >> nbJoueurs;
+    if(nbJoueurs < 2)
+        nbJoueurs = 2;
+    if(nbJoueurs > 4)
+        nbJoueurs = 4;
+    std::cout << "pause : espace ( le jeu demarre en pause )" << std::endl;
+    if(nbJoueurs == 2)
+        std::cout << "joueur1 (BAS) : x/v\njoueur2 (HAUT): " << char(27) << "/" << char(26) << std::endl;
+    if(nbJoueurs == 3)
+        std::cout << "joueur1 (BAS)   : x/v\njoueur2 (GAUCHE): a/q\njoueur3 (DROITE): 6/3" << std::endl;
+    if(nbJoueurs == 4)
+        std::cout << "joueur1 (BAS)   : x/v\njoueur2 (GAUCHE): a/q\njoueur3 (HAUT)  : " << char(27) << "/" << char(26) << "\njoueur4 (DROITE): 6/3" << std::endl;
+
+    system("PAUSE");
+
+    // [1] Initialisation de la SDL
+    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
+    {
+        std::cout << "Immpossible de démarrer la SDL: "<< SDL_GetError() << std::endl;
+        return 1;
+    }
+    atexit(SDL_Quit);
+    SDL_Surface *screen;
+    if(fullScreen)
+        screen = SDL_SetVideoMode(COTE, COTE, 32,SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);
+    else
+        screen = SDL_SetVideoMode(COTE, COTE, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);
+
+    if ( !screen )
+    {
+        std::cout << "Unable to set LGxHT video: "<< SDL_GetError() << std::endl;
+        return 1;
+    }
+    SDL_WM_SetCaption("Pong Circle !!!",NULL);
+    SDL_ShowCursor(SDL_DISABLE);
+
+    srand(time(0));
+
+    // [2] Appel de la fonction jeu
+    int erreur;
+    erreur = jeu(screen,nbJoueurs);
+
+    // all is well ;)
+    std::cout << "Pas d'erreur detectee." << std::endl;
+    return erreur;
+}///main

main.h

@@ -0,0 +1,25 @@
+#ifndef MAIN_H_INCLUDED
+#define MAIN_H_INCLUDED
+
+#include <iostream>
+#include <SDL/SDL.h>
+#include <cstdlib>
+#include <ctime>
+
+#include "include/Input.h"
+#include "include/Point.h"
+#include "include/Vecteur.h"
+
+
+
+///Dernière modification: 25/06/2013
+///Objet: déplacement des includes spécifiques
+
+#define COTE 640
+
+/*
+Programmeurs:
+Jovian et Nathan
+*/
+
+#endif // MAIN_H_INCLUDED