PING BONG, MON PREMIER JEU DE PONG

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Drawing2D;
using Microsoft.DirectX;
using Microsoft.DirectX.DirectSound;
using Microsoft.DirectX.AudioVideoPlayback;
using System.Reflection;


namespace PingBong
{
    public partial class PingBong : Form
    {
     

        private int hits = 0;

        public bool humanPlayer, // la raquette est-elle gérer par une personne?
                    pause = false, // mise en pause
                    colliCpu = false, // collision balle/raquette gérer par ordinateur (IA)
                    collision = false; // collision balle/raquette

        float cpuSkill; // force de l'ordinateur (IA)

        private bool ingame = false;

        public bool? directionX = true, // -> ? pour permettre a bool davoir des valeurs null
                     directionY = true; // direction de la balle en X ou Y, si X = true direction droite, Y = true -> direction bas


        public float rectification, // rectification de l'angle Y pour colision balle / raquette
                      facteur;      // facteur a attribuer à la rectification

        Timer t = new Timer(); // timer rafraichissement image (Invalidate() = repaint)
        Timer tMessage = new Timer(); // timer clignotement du text
      
                                            // les sons et musique
        public sound sonRaquette = null;
                sound ambianceSonore = null;
        public sound sonBut = null;
                                        // les raquettes
        Paddle humanPaddle = null;
        Paddle cpuPaddle = null; // ordinateur (IA)
            
        Balle balle = null; // la balle

        Terrain terrain = null; // le terrain
    

        public PingBong() //Constructeur
        {
            InitializeComponent(); // initialisation des composant du form
           
            initialize(); // initialisation des parametre du jeu

            
        }
        private void initialize()
        {
            // charge et initialise les sons
            sonRaquette = new sound(this);
            sonRaquette.loadWave("raquette.wav");
            ambianceSonore = new sound(this);
            ambianceSonore.loadMP3("ambiance.mp3");
            sonBut = new sound(this);
            sonBut.loadWave("but.wav");

            terrain = new Terrain(this);  // Initialise le terrain

            int lab1X = (int)terrain.Width / 4 - 10; // placement des libelle score
            scoreJ1.Location = new Point(lab1X, 30);
            int lab2X = (int)(terrain.Width / 4 * 3) - 10;
            scoreJ2.Location = new Point(lab2X, 30);

            balle = new Balle(this); // Initialise la balle
            balle.BalleY = new Random().Next(10, Convert.ToInt16(terrain.Height));
            balle.BalleX = terrain.Width / 2 + 10;
            balle.BalleSize = 20;

            humanPaddle = new Paddle(this, true, balle); // Initialise la raquette humaine par défaut
            cpuPaddle = new Paddle(this, false, balle); // Initialise la raquette ordintateurs par défaut
           
            humanPaddle.PaddleHeight = 80; // hauteur raquettes
            cpuPaddle.PaddleHeight = 80;
            
            

           
       
            // le menu difficulté de base
            facileToolStripMenuItem.Checked = true;
            moyenToolStripMenuItem.Checked = false;
            difficileToolStripMenuItem.Checked = false;
            maîtreJediToolStripMenuItem.Checked = false;
    
            balle.BalleSpeed = selectMode(); // vitesse de la balle

            //initialise le timer de rafraichissement dimage
            t.Interval = 5;
            t.Tick += new EventHandler(t_Tick);
            t.Enabled = true;
            t.Start();
            t.Stop();

            tMessage.Interval = 500;
            tMessage.Tick += new EventHandler(tMessage_Tick);
          
            //Initialise double buffering
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
        }

        public float CpuSkill  
        {
            get
            { 
                return cpuSkill; 
            }
            set
            {
                cpuSkill = value;
            }
        }
      

        private void Form1_MouseMove(object sender, MouseEventArgs e)
        {
            humanPaddle.mouvementPaddle(e);  // mouvement de la raquette selon la souris

            if (pause == false)  // debloque le mouvement de la raquette apres une pause
            { 
                Invalidate(); 
            }

        }
                                                    // methode qui permet de passer ces parametre a une autre classe
        public float TerrainHeight
        {

            get
            {
                return terrain.Height;
            }  

        }

        public float TerrainWidth
        {

            get
            {
                return terrain.Width;
            }

        }
       
        private bool collisionPaddleJ1() //colision raquette J1 (gauche) et balle
        {
            if ((directionX == false) && (balle.BalleY + (balle.BalleSize / 3 * 2)) >= (humanPaddle.PaddleY) && (balle.BalleY + (balle.BalleSize / 3)) <= (humanPaddle.PaddleY + humanPaddle.PaddleHeight) && (balle.BalleX - balle.BalleSize / 2) <= (humanPaddle.PaddleWidth + 14))
            {
                collision = true;
                sonRaquette.lireWave();
                directionX = true;
                colliCpu = false;

                float coorMillieu;

                coorMillieu = (humanPaddle.PaddleHeight / 2) + humanPaddle.PaddleY;


                facteur = ((humanPaddle.PaddleHeight / 2) / 200);


                rectification = Math.Abs(facteur * (coorMillieu - (balle.BalleY + balle.BalleSize / 2)));

                if (balle.BalleY + (balle.BalleSize / 2) < coorMillieu)
                {
                    directionY = false;

                }
                if (balle.BalleY + (balle.BalleSize / 2) > coorMillieu)
                {
                    directionY = true;

                }
                if (balle.BalleY + (balle.BalleSize / 2) == coorMillieu)
                {
                    directionY = null;
                }


                hits += 1;
                return true;
            }
            else
            {
                return false;
            }
        }

        private bool collisionPaddleJ2()
        {


            if (directionX == true && (balle.BalleY + (balle.BalleSize / 3 * 2)) >= (cpuPaddle.PaddleY) && (balle.BalleY + (balle.BalleSize / 3)) <= (cpuPaddle.PaddleY + cpuPaddle.PaddleHeight) && balle.BalleX + (balle.BalleSize / 2) >= terrain.Width + 6) //collision cpu/balle
            {
                colliCpu = true;
                sonRaquette.lireWave();
                directionX = false;
                collision = true;
                hits += 1;



                float coorMillieu;

                coorMillieu = (cpuPaddle.PaddleHeight / 2) + cpuPaddle.PaddleY;



                facteur = ((cpuPaddle.PaddleHeight / 2) / 200);



                rectification = Math.Abs(facteur * (coorMillieu - (balle.BalleY + balle.BalleSize / 2)));

                if (balle.BalleY + balle.BalleSize / 2 < coorMillieu)
                {
                    directionY = false;

                }
                if (balle.BalleY + balle.BalleSize / 2 > coorMillieu)
                {
                    directionY = true;

                }

                if (balle.BalleY + (balle.BalleSize / 2) == coorMillieu)
                {
                    directionY = null;
                }


                return true;
            }
            else { return false; }
        }

        public void but()
        {
            
                if ((balle.BalleX - (balle.BalleSize / 2)) <= 9)  //J2 (droite) marque
                {

                    sonBut.lireWave();              
                    score(scoreJ2);
                    t.Stop();
                    menuStrip.Visible = true;
                    hits = 0;


                    colliCpu = false;
                    balle.BalleSpeed = selectMode();
                    directionX = true;
                    directionY = true;
                    collision = false;
                    if (Convert.ToInt16(scoreJ2.Text) < 10)
                    {

                        message.Text = "Clic ou Espace pour continuer";
                        message.Location = new Point(this.Width / 2 - message.Width / 2, this.Height / 2 - message.Height / 2);
                        message.Refresh();
                        tMessage.Start();

                    }
                    else
                    {

                   
                        message.Text = "Vous avez perdu !! \r\n \r\n Clic ou espace pour réessayer";
                        message.Location = new Point(this.Width / 2 - message.Width / 2, this.Height / 2 - message.Height / 2);
                        message.Refresh();   
                        tMessage.Start();
                      
                    }
                   

                
            }
            else if (balle.BalleX + (balle.BalleSize / 2) >= (this.Width - 10)) // J1(gauche) marque
            {
                sonBut.lireWave();
                score(scoreJ1);
                t.Stop();

                menuStrip.Visible = true;
                hits = 0;
                balle.BalleSpeed = selectMode();

                colliCpu = false;

                directionX = true;
                directionY = true;
                collision = false;
                if (Convert.ToInt16(scoreJ1.Text) < 10 )
                {

                    message.Text = "Clic ou Espace pour continuer";

                    message.Location = new Point(this.Width / 2 - message.Width / 2, this.Height / 2 - message.Height / 2);
                    message.Refresh();
                    tMessage.Start();
                }
                else
                {

                    
                        message.Text = "Vous avez gagnez ! Bravo ! \r\n \r\n Clic ou espace pour recommencer";
                        message.Location = new Point(this.Width / 2 - message.Width / 2, this.Height / 2 - message.Height / 2);
                        message.Refresh();   
                         tMessage.Start();
                        
                 
                }
            }
        }



        private void t_Tick(object sender, EventArgs e)  // a chaque fin du timer t 
        {

           balle.rebondMur();

           if (collision == false)
           {
               balle.mouvementBalle();
           }
           if (collision == true)
           {
               balle.mouvementBalle(rectification);
           }
                 cpuPaddle.IAordinateur();

            if (collisionPaddleJ1() == false)           // evite que pour des vitesse trop grande il yest but mm si joueur touche la balle
            {
                if (collisionPaddleJ2() == false)
                {
                    but();
                }
            }
           

            
                            // augmentation de la vitesse de la balle pendant le jeu
            if (hits == 4)
            {
            balle.BalleSpeed += 0.01f;
            
            }
            if (hits == 8)
            {
                balle.BalleSpeed += 0.01f;
            }
            if (hits == 12)
            {
                balle.BalleSpeed += 0.01f;
            }
            if (hits > 16)
            {
                balle.BalleSpeed += .05f;
            }

            Invalidate(); // force le repaint de la fenetre -> onPaint

           
        }


        private void score(Label joueur) //incremente le score a chaque but
        {
            int score = Convert.ToInt16(joueur.Text) + 1;
            joueur.Text = score.ToString();
        }


        protected override void OnPaint(PaintEventArgs e) // surchaarge de la methode onPaint
        {
          
                terrain.Paint(e);
                balle.Paint(e);
                humanPaddle.Paint(e);
                cpuPaddle.Paint(e);
              
         
            if (ingame == false)// fin du jeu
            {   
                t.Stop(); // on stop le timer limage est figé
            } 

         }

        private void remiseAzero() // remise a zero des parametres, et debu dune nouvelle partie
        {
            scoreJ1.Text = "0";
            scoreJ2.Text = "0";
            balle.BalleSpeed = selectMode(); // choi de la dificulté
            ingame = false;
            pause = false;
            menuStrip.Visible = false;
            balle.BalleY = new Random().Next(1, 280);
            balle.BalleX = terrain.Width / 2 + 10;
            message.Text = "Clic ou Espace pour commencer";
            message.Location = new Point(this.Width / 2 - message.Width / 2, this.Height / 2 - message.Height / 2);
            message.Refresh();
            ambianceSonore.lireMP3();
            ambianceSonore.loopMP3();
            tMessage.Start();
           
        }


        // si la fenetre est agrandie ou repaint les les composants avec les nouvelles taille
        private void Form1_SizeChanged(object sender, EventArgs e)
        {
           
            terrain.Width = this.Width - 30;
            terrain.Height = this.Height - 60;
            terrain.LigneX = terrain.Width / 2 + 10;
            terrain.LigneY = terrain.Height + 10;

            terrain.RondSize = terrain.LigneY / 5;
            terrain.RondX = terrain.Width / 2 + 10 - terrain.RondSize / 2;
            terrain.RondY = terrain.Height / 2 + 10 - terrain.RondSize / 2;

            int scoreJ1X = (int)terrain.Width / 4 - 10;
            scoreJ1.Location = new Point(scoreJ1X, 30);
            int scoreJ2X = (int)(terrain.Width / 4 * 3) - 10;
            scoreJ2.Location = new Point(scoreJ2X, 30);
            scoreJ1.Refresh();
            scoreJ2.Refresh();

            message.Location = new Point(this.Width / 2 - message.Width / 2, this.Height / 2 - message.Height / 2);
            message.Refresh();
            Invalidate();
        }

        // nouvelle partie
        private void nouvellePartieToolStripMenuItem_Click(object sender, EventArgs e)
        {
            remiseAzero();
        }




        private void Form1_Click(object sender, EventArgs e) // pour les action defini ds les message a lutilisateur
        {
            if (scoreJ1.Text == "10" || scoreJ2.Text == "10") // fin dune partie
            {
                remiseAzero();
            }
            else if (ingame == false && menuStrip.Visible == false) // debu dune partie apres clic sur nouvelle partie
            {
                tMessage.Stop();
                ingame = true;
                t.Start();
            }
            else if (ingame == true && menuStrip.Visible == true && pause == false) // debut dune partie apres une fin 
            {
                menuStrip.Visible = false;
                directionX = true;
                balle.BalleSpeed = selectMode();
                balle.BalleY = new Random().Next(1, 280);
                balle.BalleX = terrain.Width / 2 + 10;
                tMessage.Stop();
                message.Visible = false;
                t.Start();
            }
        }

       private void tMessage_Tick(object sender, EventArgs e)  // message clignotant
        {
            
            if (message.Visible == true)
            { message.Visible = false; }
            else if (message.Visible == false)
            { message.Visible = true; }
        }


        private void toolStripMenuItem2_Click(object sender, EventArgs e) // fonction reprendre apres uen pause
        {
            Pause();
        }



        private void Form1_KeyPress(object sender, KeyPressEventArgs e)  // gestion clavier
        {
            switch (e.KeyChar)
            {
                case (char)27: //ESC  Met en pause le jeu
                Pause();
                break;

                case 'p': // Met en pause le jeu
               Pause();
                break;
                
                case ' ':
                if (scoreJ1.Text == "10" || scoreJ2.Text == "10")
                {
                    remiseAzero();
                }
                else if (ingame == false && menuStrip.Visible == false)
                {
                    tMessage.Stop();
                    ingame = true;
                    t.Start();
                }
                else if (ingame == true && menuStrip.Visible == true && pause == false)
                {
                    menuStrip.Visible = false;
                    directionX = true;
                    balle.BalleSpeed = selectMode();
                    balle.BalleY = new Random().Next(1, 280);
                    balle.BalleX = terrain.Width/2 +10;
                    tMessage.Stop();
                    message.Visible = false;
                    t.Start();
                }
              
                break;
            }
        }


        private void Pause()
        {
            if (ingame == true && pause == false && menuStrip.Visible == false)
            {
                ambianceSonore.pauseMP3();
                pause = true;
                menuStrip.Visible = true;
                reprendreToolStripMenuItem2.Enabled = true;
                message.Text = "Pause";
                message.Location = new Point(this.Width / 2 - message.Width / 2, this.Height / 2 - message.Height / 2);
                message.Refresh();
                tMessage.Start();
                t.Stop();
            }
            else if (ingame == true && pause == true)
            {
                ambianceSonore.lireMP3();
                ambianceSonore.loopMP3();
                pause = false;

                message.Visible = false;
                menuStrip.Visible = false;
                reprendreToolStripMenuItem2.Enabled = false;
                tMessage.Stop();
                t.Start();
            }
        }

        // le menu
     
        private void facileToolStripMenuItem_Click(object sender, EventArgs e)
        {
            facileToolStripMenuItem.Checked = true;
            moyenToolStripMenuItem.Checked = false;
            difficileToolStripMenuItem.Checked = false;
            maîtreJediToolStripMenuItem.Checked = false;
            humanPaddle.PaddleHeight = 80;
            cpuPaddle.PaddleHeight = 80;
            balle.BalleSpeed = 6f;
            cpuSkill = 5f;
        }

        private void moyenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            facileToolStripMenuItem.Checked = false;
            moyenToolStripMenuItem.Checked = true;
            difficileToolStripMenuItem.Checked = false;
            maîtreJediToolStripMenuItem.Checked = false;
     

            humanPaddle.PaddleHeight = 80;
            cpuPaddle.PaddleHeight = 80;
            balle.BalleSpeed = 8f;
            cpuSkill = 8f;
        }

        private void difficileToolStripMenuItem_Click(object sender, EventArgs e)
        {
            facileToolStripMenuItem.Checked = false;
            moyenToolStripMenuItem.Checked = false;
            difficileToolStripMenuItem.Checked = true;
            maîtreJediToolStripMenuItem.Checked = false;
          

            humanPaddle.PaddleHeight =80;
            cpuPaddle.PaddleHeight = 80;
            balle.BalleSpeed = 10f;
            cpuSkill = 11.5f;
        }

        private void maîtreJediToolStripMenuItem_Click(object sender, EventArgs e)
        {
            facileToolStripMenuItem.Checked = false;
            moyenToolStripMenuItem.Checked = false;
            difficileToolStripMenuItem.Checked = false;
            maîtreJediToolStripMenuItem.Checked = true;

            humanPaddle.PaddleHeight = 80;
            cpuPaddle.PaddleHeight = 80;
            balle.BalleSpeed = 12f;
            cpuSkill = 14f;
           
        }

        private float selectMode()
        {

            if (facileToolStripMenuItem.Checked == true)
            {
                cpuSkill = 6f;
                return 6.5f;
            }
            else if (moyenToolStripMenuItem.Checked == true)
            {
                cpuSkill = 7f;
                return 7f;
            }
            else if (difficileToolStripMenuItem.Checked == true)
            {
                cpuSkill = 9f;
                return 7.5f;
            }
            else if (maîtreJediToolStripMenuItem.Checked == true)
            {
                cpuSkill = 12f;
                
                return 12f;
            }

            else return 5f;
        }

        private void configurationToolStripMenu_click(object sender, EventArgs e)
        {
            Configuration panneauConfig = new Configuration(this);
            panneauConfig.ShowDialog();
        }

        public sound AmbianceSonore
        {
            get
            { 
                return ambianceSonore;
            }
            set
            {
                ambianceSonore = value;
            }

        }

        public sound SonMur
        {
            get
            {
                return balle.sonMur;
            }
            set
            {
                balle.sonMur = value;
            }
        }

        public Color HumandPaddleColor
        {
            get
            {
                return humanPaddle.Couleur;
            }
            set
            {
                humanPaddle.Couleur = value;
            }
        }

        public Color CpuPaddleColor
        {
            get
            {
                return cpuPaddle.Couleur;
            }
            set
            {
                cpuPaddle.Couleur = value;
            }
        }

        public Color BalleColor
        {
            get
            {
                return balle.Couleur;
            }
            set
            {
                balle.Couleur = value;
            }
        }

        private void fermerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    }
}












using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing.Drawing2D;
using System.Drawing;
using System.Windows.Forms;

namespace PingBong
{
    class Balle
    {
        PingBong parent; // référence à l'interface principale

        private float X = 255,
                      Y,
                      balleSize, // diametre
                      balleSpeed;

        private Color couleur = Color.Orange;
       
        public sound sonMur = null;
    
        public Balle(PingBong parent) //Constructeur
        {
            this.parent = parent; // référence à l'interface principale

            sonMur = new sound(parent);
            sonMur.loadWave("mur.wav");
        }

                        // accesseurs
         public float BalleX
         {
             get
             {
                 return X;
             }
             set
             {
                 X = value;
             }

         }

         public float BalleY
         {
             get
             {
                 return Y;
             }
             set
             {
                 Y = value;
             }

         }

         public float BalleSize
         {
             get
             {
                 return balleSize;
             }
             set
             {
                 balleSize = value;
             }

         }

         public float BalleSpeed
         {
             get
             {
                 return balleSpeed;
             }
             set
             {
                 balleSpeed = value;
             }

         }

         public Color Couleur
         {
             get
             {
                 return couleur;
             }
             set
             {
                 couleur = value;
             }

         }

         public void rebondMur()
         {
             if (BalleY + (BalleSize / 2) >= parent.TerrainHeight + (BalleSize / 2)) //rebond mur bas
             {
                 sonMur.lireWave();
                 parent.directionY = false;
                 parent.collision = false;
             }
             else if (BalleY - (BalleSize / 2) <= (BalleSize / 2)) //rebond mur haut
             {
                 sonMur.lireWave();
                 parent.directionY = true;
                 parent.collision = false;
             }
         }

         public void mouvementBalle() //control du mouvement de la balle selon la direction de celle ci
         {
            
                 if (parent.directionX == true)             //la balle avance vers la droite
                 { BalleX += BalleSpeed; }
                 if (parent.directionY == true)             //la balle avance vers le bas
                 { BalleY += BalleSpeed; }

                 if (parent.directionX == false)            //la balle avance vers la gauche
                 { BalleX -= BalleSpeed; }
                 if (parent.directionY == false)            //la balle avance vers le haut
                 { BalleY -= BalleSpeed; }

                 if (parent.directionY == null) // droit devant
                 { BalleY = BalleY; parent.directionY = null; }
           
         }

         public void mouvementBalle(float rectification) //mouvement de la balle apres une colision sur la raquette (trajectoire modifié)
         {
         
             
                 float X;

                 if (rectification > 2 * BalleSpeed)    // evite que la vitesse de la balle change de vitesse pour des Y et X different
                 {
                     rectification = 2 * BalleSpeed;
                     X = 1;
                 }
                 else
                 {
                     X = 2 * BalleSpeed - rectification;
                 }


                 if (parent.directionX == true)             //la balle avance vers la droite
                 { BalleX += X; }
                 if (parent.directionY == true)             //la balle avance vers le bas
                 { BalleY += rectification; }

                 if (parent.directionX == false)            //la balle avance vers la gauche
                 { BalleX -= X; }
                 if (parent.directionY == false)            //la balle avance vers le haut
                 { BalleY -= rectification; }

                 if (rectification == 0) // droit devant
                 {
                     BalleY = BalleY;


                 }


             
         }

         // Desssin de la balle
         public void Paint(PaintEventArgs e)
         {
             Graphics g = e.Graphics;

             g.SmoothingMode = SmoothingMode.AntiAlias;
             g.PixelOffsetMode = PixelOffsetMode.HighQuality;
             Pen p = new Pen(Color.Black);
             SolidBrush b = new SolidBrush(couleur);
             p.Width = 2;

       
             g.DrawEllipse(p, X - (balleSize / 2), Y , balleSize, balleSize);
             g.FillEllipse(b, X - (balleSize / 2), Y, balleSize, balleSize);

         }

        
    }
}





using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing.Drawing2D;
using System.Drawing;
using System.Windows.Forms;

namespace PingBong
{
    
    class Paddle
    {
        PingBong parent; // référence à l'interface principale
        Balle balle;
        private float paddleWidth = 10, // Caractéristique de la raquette
                      paddleHeight = 80,
                      paddleY;

        private bool humanPlayer; // type de joueur

        private Color couleur = Color.Blue;

        public Paddle(PingBong parent, bool humanPlayer, Balle balle) //Constructeur
        {
            this.parent = parent; // référence à l'interface principale
            this.humanPlayer = humanPlayer;
            this.balle = balle;
            paddleY = paddleHeight;
        }

                            // accesseurs
        public float PaddleWidth
        {
            get
            {
                return paddleWidth;
            }
            set
            {
                paddleWidth = value;
            }

        }

        public float PaddleHeight
        {
            get
            {
                return paddleHeight;
            }
            set
            {
                paddleHeight = value;
            }

        }

        public float PaddleY
        {
            get
            {
                return paddleY;
            }
            set
            {
                paddleY = value;
            }

        }

        public Color Couleur
        {
            get
            {
                return couleur;
            }
            set
            {
                couleur = value;
            }

        }
        


        public void mouvementPaddle(MouseEventArgs e) // mouvement selon souris
        {

           PaddleY = e.Y - (PaddleHeight / 2);
        }

        public void IAordinateur() // mouvement par ordinateur, Intelligence artificielle primitive
        {

            // rectification > 2.3 -> en dessou le traitement est différent
            if ((parent.rectification > 2.3 && parent.collision == true) || parent.collision == false)
            {

                if ((parent.directionY == true || parent.directionY == null) && balle.BalleX >= (parent.TerrainWidth / 2 - 20) && PaddleY + (PaddleHeight / 2) < balle.BalleY)
                {

                    PaddleY += parent.CpuSkill;

                    double rand = new Random().NextDouble();

                    PaddleY -= Convert.ToInt32(rand);

                }
                else if ((parent.directionY == false || parent.directionY == null) && balle.BalleX + (balle.BalleSize / 2) >= (parent.TerrainWidth / 2 - 20) && PaddleY + (PaddleHeight / 2) > balle.BalleY)
                {

                    PaddleY -= parent.CpuSkill;
                    double rand = new Random().NextDouble();

                    double rand1 = new Random().NextDouble();
                    PaddleY += Convert.ToInt32(rand);
                }
            }


                // rectification < 2.3 -->   En dessous de cette valeur (aproximative) la raquette a tendance a ne pas bouger car elle ne detecte pas le mouvement de la balle
            else if ((parent.rectification < 2.3 && parent.collision == true) && parent.colliCpu == false)
            {
                if ((parent.directionY == true || parent.directionY == null) && balle.BalleX >= (parent.TerrainWidth / 2 - 20) && PaddleY + (PaddleHeight / 2) < balle.BalleY)
                {

                    PaddleY += parent.CpuSkill;


                }
                if ((parent.directionY == false || parent.directionY == null) && balle.BalleX >= (parent.TerrainWidth / 2 - 20) && PaddleY + (PaddleHeight / 2) < balle.BalleY)
                {

                    PaddleY += parent.CpuSkill;


                }
                if ((parent.directionY == false || parent.directionY == null) && balle.BalleX + (balle.BalleSize / 2) >= (parent.TerrainWidth / 2 - 20) && PaddleY + (PaddleHeight / 2) > balle.BalleY)
                {

                    PaddleY -= parent.CpuSkill;

                }
                if ((parent.directionY == true || parent.directionY == null) && balle.BalleX + (balle.BalleSize / 2) >= (parent.TerrainWidth / 2 - 20) && PaddleY + (PaddleHeight / 2) > balle.BalleY)
                {

                    PaddleY -= parent.CpuSkill;



                }
            }
        }
                    // Desssin des raquettes
        public void Paint(PaintEventArgs e)
        {
            Graphics g = e.Graphics;



            g.SmoothingMode = SmoothingMode.AntiAlias;
            g.PixelOffsetMode = PixelOffsetMode.HighQuality;
            Pen p = new Pen(Color.Black);
            p.Width = 2;
            SolidBrush b = new SolidBrush(couleur);

            if (humanPlayer == true)
            {
                g.DrawRectangle(p, 10, paddleY, paddleWidth, paddleHeight);
                
                g.FillRectangle(b, 10, paddleY, paddleWidth, paddleHeight);
               
            }
            if (humanPlayer == false)
            {
                g.DrawRectangle(p, parent.Width - 20 - paddleWidth, paddleY, paddleWidth, paddleHeight);
               
                g.FillRectangle(b, parent.Width - 20 - paddleWidth, paddleY, paddleWidth, paddleHeight);
            }
        }

    }
}














using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing.Drawing2D;
using System.Drawing;
using System.Windows.Forms;

namespace PingBong
{
    class Terrain
    {
        PingBong parent; // référence à l'interface principale

        private static float width,
                      height,
                      ligneX,
                      ligneY,
                      rondX,
                      rondY,
                      rondSize;
        
        
         public Terrain(PingBong parent) //Constructeur
        {
            this.parent = parent; // référence à l'interface principale

            width = parent.Width - 30;
            height = parent.Height - 60;
            ligneX = width / 2 + 10;
            ligneY = height + 10;
            rondSize = ligneY / 5;
            rondX = width / 2 + 10 - rondSize / 2;
            rondY = height / 2 + 10 - rondSize / 2;
        }

                // accesseur
         public float Width
         {
             get
             {
                 return width;
             }
             set
             {
                 width = value;
             }
         }

         public float Height
         {
             get
             {
                 return height;
             }
             set
             {
                 height = value;
             }
         }

         public float LigneX
         {
             get
             {
                 return ligneX;
             }
             set
             {
                 ligneX = value;
             }
         }

         public float LigneY
         {
             get
             {
                 return ligneY;
             }
             set
             {
                 ligneY = value;
             }
         }

         public float RondSize
         {
             get
             {
                 return rondSize;
             }
             set
             {
                 rondSize = value;
             }
         }

         public float RondX
         {
             get
             {
                 return rondX;
             }
             set
             {
                 rondX = value;
             }
         }

         public float RondY
         {
             get
             {
                 return rondY;
             }
             set
             {
                 rondY = value;
             }
         }

         // Desssin du terrain
         public void Paint(PaintEventArgs e)
         {
             Graphics g = e.Graphics;


             g.SmoothingMode = SmoothingMode.AntiAlias;
             g.PixelOffsetMode = PixelOffsetMode.HighQuality;
             Pen p = new Pen(Color.Black);
             p.Width = 2;         

             g.DrawRectangle(p, 10, 10, width, height);
             g.DrawEllipse(p, rondX, rondY, rondSize, rondSize);
             g.DrawLine(p, ligneX, 10, ligneX, ligneY);
         }
    }
}





using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.DirectX;
using Microsoft.DirectX.DirectSound;
using Microsoft.DirectX.AudioVideoPlayback;
using System.Reflection;


namespace PingBong
{
    public class sound
    {
       
        
        
        PingBong parent;
              //Code pour jouer les effets Wav

         //Création du future device sonore
        public Device Dev = null;
         //Création d'un buffer spécial pour le son
        public SecondaryBuffer Buffer = null;

        public Audio audio = null; 



        public sound(PingBong parent)  // constructeur avec appel du parent (form1)
        {
        this.parent = parent;
     
        }

            
       
        public void loadWave(string fichier)
        {
              //Création du device
         Dev = new Device();
         //Quel priorité faut-il donner au son ???
         Dev.SetCooperativeLevel(parent, CooperativeLevel.Priority);
            
         Assembly a = Assembly.GetExecutingAssembly(); 
             //On met le fichier son dans le buffer
             try{Buffer = new SecondaryBuffer(a.GetManifestResourceStream(string.Format("PingBong.{0}.{1}","Resources" , fichier)),Dev);}
            catch{}
             Buffer.Volume = -1000;
        }

        public void lireWave()
        {
            Buffer.Play(0, BufferPlayFlags.Default);
        }


        public void loadMP3(string fichier)
        {
           string exepath = Environment.GetCommandLineArgs()[0];


           string exedir = exepath.Substring(0, exepath.LastIndexOf('\\'));

           audio = new Audio(exedir + "\\Resources\\"+fichier);
           audio.Volume = -1000 ;
        }

        public void lireMP3()
        {
            audio.Play();
            
        }
        public void stopMP3()
        {
            audio.Stop();
        }

        public void pauseMP3()
        {
            audio.Pause();
        }
        public void loopMP3()
        {
            audio.Ending += new EventHandler(finMP3);
        }

        public void stopLoopMP3()
        {
            audio.Ending -= new EventHandler(finMP3);
        }
        public void finMP3(object sender, EventArgs e)
        {
            audio.CurrentPosition = 0;
        }
    }
}