TP : Jeu de billard

package  
{
    public class Unite 
    {
        public static const METRE:Number = 400;
        public static const GRAMME:Number = 1;
    }
}

package  
{
    public class Constantes 
    {
        public static var restitution:Number = 0.85;
        public static var frottement:Number = 0.007;
    }
}

package  
{
    import flash.display.DisplayObject;
    /**
     * Quelques fonctions utiles.
     * @author Guillaume CHAU
     */
    public class Outils 
    {
        /**
         * Calcule et renvoie la distance (en pixels) entre deux objets.
         * @param    obj1
         * @param    obj2
         * @return    Distance en pixels
         */
        static public function distance(obj1:DisplayObject, obj2:DisplayObject):Number
        {
            return distanceNombres(obj1.x, obj1.y, obj2.x, obj2.y);
        }

        /**
         * Calcule et renvoie la distance (en pixels) entre les deux points formés par les coordonnées parssées en paramètre.
         * @param    x1
         * @param    y1
         * @param    x2
         * @param    y2
         * @return    Distance en pixels
         */
        static public function distanceNombres(x1:Number, y1:Number, x2:Number, y2:Number):Number
        {
            var X:Number = x2 - x1;
            var Y:Number = y2 - y1;
            return Math.sqrt(X * X + Y * Y);
        }

        /**
         * Calcule et renvoie l'angle (en radians) entre les deux objets.
         * @param    obj1
         * @param    obj2
         * @return    Angle en radians
         */
        static public function angle(obj1:DisplayObject, obj2:DisplayObject):Number
        {
            return angleNombres(obj1.x, obj1.y, obj2.x, obj2.y);
        }

        /**
         * Calcule et renvoie l'angle (en radians) entre les deux points formés par les coordonnées passées en paramètre.
         * @param    x1
         * @param    y1
         * @param    x2
         * @param    y2
         * @return    Angle en radians
         */
        static public function angleNombres(x1:Number, y1:Number, x2:Number, y2:Number):Number
        {
            return Math.atan2(y2 - y1, x2 - x1);
        }
    }
}

/**
 * Calcule et renvoie la distance (en pixels) entre deux objets.
 * @param    obj1
 * @param    obj2
 * @return    Distance en pixels
 */

var tableLargeur:Number = 2.34 * Unite.METRE;
var tableHauteur:Number = 1.17 * Unite.METRE;
var margeFond:Number = 0.08 * Unite.METRE;

var diametre:Number = 0.05 * Unite.METRE;
var masse:Number = 172 * Unite.GRAMME;

var couleurs:Array = [
    0xffffff, // Bille blanche
    0xfac92e, 
    0x1744c1, 
    0xee372e, 
    0x271d53, 
    0xff8d59, 
    0x189e66, 
    0x931422, 
    0x000000, // Bille 8
    0xf7af1d, 
    0x2059e8, 
    0xde291d, 
    0x2f2665, 
    0xfb8351, 
    0x0d955c, 
    0x92121d
];

filters = [
    // Ombre
    new DropShadowFilter(3, 45, 0, 0.3, 6, 6, 1, 2),
    // Volume (ombre intérieure)
    new DropShadowFilter( -10, 45, 0, 0.3, 6, 6, 1, 2, true)
];

package  
{
    /**
     * Un vecteur x;y, pour les calculs
     * @author Guillaume CHAU
     */
    public class Vecteur2D 
    {
        private var _x:Number;
        private var _y:Number;

        private var _module:Number = 0;
        private var _angle:Number = 0;

        public function Vecteur2D(x:Number = 0, y:Number = 0) 
        {
            _x = x;
            _y = y;

            _calculAngleModule();
        }

        public function toString():String 
        {
            return "[Vecteur2D x=" + x + " y=" + y + " module=" + module + " angle=" + angle + "]";
        }

        /**
         * Revoie une copie du vecteur.
         * @return
         */
        public function clone():Vecteur2D
        {
            var c:Vecteur2D = new Vecteur2D();
            c.x = _x;
            c.y = _y;
            return c;
        }

        /**
         * Ajoute le vecteur passé en paramètre au vecteur courant.
         * @param vecteur   Vecteur à ajouter.
         * @param apply     Si vrai, modifie directement le vecteur courant. Sinon, renvoie un nouveau vecteur.
         * @return          Le vecteur représentant la somme des deux premiers vecteurs.
         */
        public function ajouter(vecteur:Vecteur2D, apply:Boolean = false):Vecteur2D
        {
            var cible:Vecteur2D;
            if (apply)
            {
                cible = this;
            }
            else
            {
                cible = clone();
            }
            cible.x += vecteur.x;
            cible.y += vecteur.y;
            return cible;
        }

        /**
         * Soustrait le vecteur passé en paramètre au vecteur courant.
         * @param vecteur   Vecteur à soustraire.
         * @param apply     Si vrai, modifie directement le vecteur courant. Sinon, renvoie un nouveau vecteur.
         * @return          Le vecteur représentant la soustraction des deux premiers vecteurs.
         */
        public function soustraire(vecteur:Vecteur2D, apply:Boolean = false):Vecteur2D
        {
            var cible:Vecteur2D;
            if (apply)
            {
                cible = this;
            }
            else
            {
                cible = clone();
            }
            cible.x -= vecteur.x;
            cible.y -= vecteur.y;
            return cible;
        }

        /**
         * Multiplie le vecteur par un coefficient numérique.
         * @param coef      Coefficient numérique.
         * @param apply     Si vrai, modifie directement le vecteur courant. Sinon, renvoie un nouveau vecteur.
         * @return          Le vecteur ayant reçu la multiplication.
         */
        public function multiplier(coef:Number, apply:Boolean = false):Vecteur2D
        {
            var cible:Vecteur2D;
            if (apply)
            {
                cible = this;
            }
            else
            {
                cible = clone();
            }
            cible.x *= coef;
            cible.y *= coef;
            return cible;
        }

        /**
         * Normalise le vecteur (c'est-à-dire modifie ses coordonnées x et y telles que son module vaille 1).
         * @param apply     Si vrai, modifie directement le vecteur courant. Sinon, renvoie un nouveau vecteur.
         * @return          Le vecteur normalisé.
         */
        public function normaliser(apply:Boolean = false):Vecteur2D
        {
            var cible:Vecteur2D;
            if (apply)
            {
                cible = this;
            }
            else
            {
                cible = clone();
            }
            var m:Number = cible.module;
            if (m != 0)
            {
                cible.x /= m;
                cible.y /= m;
            }
            else
            {
                cible.x = 0;
                cible.y = 0;
            }
            return cible;
        }

        /**
         * Calcule le produit du vecteur courant avec le vecteur passé en paramètre.
         * @param vecteur       Le vecteur à multiplier avec le vecteur courant.
         * @return              Nombre résultant de la multiplication des deux vecteurs.
         */
        public function produit(vecteur:Vecteur2D):Number
        {
            return this.x * vecteur.x + this.y + vecteur.y;
        }

        /* PRIVE */

        private function _calculCoord():void
        {
            if (_module == 0)
            {
                _x = 0;
                _y = 0;
            }
            else
            {
                _x = Math.cos(angle) * _module;
                _y = Math.sin(angle) * _module;
            }
        }

        private function _calculAngleModule():void
        {
            if (_x == 0 && _y == 0)
            {
                _angle = 0;
                _module = 0;
            }
            else
            {
                _module = Outils.distanceNombres(0, 0, _x, _y);
                _angle = Outils.angleNombres(0, 0, _x, _y);
            }
        }

        /* GETTERS */

        /**
         * Coordonnée horizontale.
         */
        public function get x():Number 
        {
            return _x;
        }

        public function set x(value:Number):void 
        {
            _x = value;

            _calculAngleModule();
        }

        /**
         * Coordonnée verticale.
         */
        public function get y():Number 
        {
            return _y;
        }

        public function set y(value:Number):void 
        {
            _y = value;

            _calculAngleModule();
        }

        /**
         * Module (longeur du vecteur).
         */
        public function get module():Number 
        {
            return _module;
        }

        public function set module(value:Number):void 
        {
            _module = value;

            _calculCoord();
        }

        /**
         * Angle du vecteur par rapport à l'horizontale.
         */
        public function get angle():Number 
        {
            return _angle;
        }

        public function set angle(value:Number):void 
        {
            _angle = value;

            _calculCoord();
        }

    }
}

var taille:Number = (this.taille + bille.taille) / 2;
// Repositionnement au point de contact
// Vecteur distance entre les boules
var delta:Vecteur2D = new Vecteur2D(this.x - bille.x, this.y - bille.y);
var d:Number = delta.module;
// Distance de translation minimum pour pousser les boules
if (d == 0)
{
    d = (this.taille + bille.taille) * 0.5 - 1;
    delta = new Vecteur2D((this.taille + bille.taille) * 0.5, 0);
}
var mtd:Vecteur2D = delta.multiplier(((this.taille + bille.taille) * 0.5 - d) / d);
// Masse inverse
var im1:Number = 1 / this.masse;
var im2:Number = 1 / bille.masse;
// Repousser les balles pour éviter qu'elles se chevauchent
var correction:Vecteur2D = mtd.multiplier(im1 / (im1 + im2));
this.x += correction.x;
this.y += correction.y;
bille.x -= correction.x;
bille.y -= correction.y;
// Calcul de la base orthonormée (n,g)
// n est perpendiculaire au plan de collision, g est tangent
var nx:Number = (bille.x - this.x) / taille;
var ny:Number = (bille.y - this.y) / taille;
var gx:Number = -ny;
var gy:Number = nx;
// Calcul des vitesses dans cette base
var v1n:Number = nx * this.velocite.x + ny * this.velocite.y;
var v1g:Number = gx * this.velocite.x + gy * this.velocite.y;
var v2n:Number = nx * bille.velocite.x + ny * bille.velocite.y;
var v2g:Number = gx * bille.velocite.x + gy * bille.velocite.y;
// Permute les coordonnées n et conserve la vitesse tangentielle
// Exécute la transformation inverse (base orthonormée => matrice transposée)
this.velocite.x = nx * v2n + gx * v1g;
this.velocite.y = ny * v2n + gy * v1g;
bille.velocite.x = nx * v1n + gx * v2g;
bille.velocite.y = ny * v1n + gy * v2g;

package  
{
    import flash.display.Sprite;

    /**
     * Classe de base des objets graphiques.
     * @author Guillaume CHAU
     */
    public class Visuel extends Sprite 
    {
        // Taille "virtuelle"
        private var _width:Number = 0;
        private var _height:Number = 0;

        private var _taille:Number = 0;

        public function Visuel() 
        {

        }

        /* PRIVE */

        protected function _dessiner():void
        {
            // A implémenter dans les sous-classes
        }

        /* GETTERS */

        override public function get width():Number 
        {
            return _width;
        }

        override public function set width(value:Number):void 
        {
            _width = value;

            _dessiner();
        }

        override public function get height():Number 
        {
            return _height;
        }

        override public function set height(value:Number):void 
        {
            _height = value;

            _dessiner();
        }

        /**
         * Taille de l'objet visuel au cas où il n'a besoin que d'un nombre (exemple : diamètre).
         */
        public function get taille():Number 
        {
            return _taille;
        }

        public function set taille(value:Number):void 
        {
            _taille = value;

            _dessiner();
        }
    }
}

package  
{
    /**
     * Bille de billard.
     * @author Guillaume CHAU
     */
    public class Bille extends Visuel 
    {

    }
}

// Infos de bases
private var _couleur:uint;
private var _numero:int;
private var _masse:Number;
// Vraie si la bille est tombée dans un trou
private var _horsJeu:Boolean = false;
// Eléments visuels
private var _masque:Shape;
private var _etiquette:TextField;
// Vecteur de déplacement
private var _velocite:Vecteur2D;

/**
 * Couleur de la bille (exemple: 0xFF0055).
 */
public function get couleur():uint
{
    return _couleur;
}
/**
 * Numéro de la bille. Si le numéro est 0, la bille n'a pas d'étiquette. Si le numéro est supérieur ou égal à 9, la bille a des bandes blanches.
 */
public function get numero():int
{
    return _numero;
}
/**
 * Masse de la bille. Utiliser Unite.GRAMME.
 */
public function get masse():Number
{
    return _masse;
}
public function set masse(value:Number):void
{
    _masse = value;
}
/**
 * Vecteur géométrique représentant le déplacement de la bille par frame.
 */
public function get velocite():Vecteur2D 
{
    return _velocite;
}
public function set velocite(value:Vecteur2D):void 
{
    _velocite = value;
}
/**
 * Indique si la bille est hors-jeu (ex: tombée dans un trou).
 */
public function get horsJeu():Boolean 
{
    return _horsJeu;
}
public function set horsJeu(value:Boolean):void 
{
    _horsJeu = value;
}

public function Bille(couleur:uint, numero:int, taille:Number, masse:Number)
{
    // Etiquette affichant le numéro de la bille
    _etiquette = new TextField();
    _etiquette.selectable = false;
    _etiquette.autoSize = TextFieldAutoSize.LEFT;
    _etiquette.defaultTextFormat = new TextFormat('arial', 10, 0x000000);
    _etiquette.embedFonts = true;
    addChild(_etiquette);

    // Effets spéciaux
    filters = [
        // Ombre
        new DropShadowFilter(3, 45, 0, 0.3, 6, 6, 1, 2),
        // Volume (ombre intérieure)
        new DropShadowFilter( -10, 45, 0, 0.3, 6, 6, 1, 2, true)
    ];

    // Vecteur géométrique à deux dimensions représentant le déplacement de la bille pour chaque frame
    _velocite = new Vecteur2D();

    // Autres attributs
    _couleur = couleur;
    _numero = numero;
    this.taille = taille;
    _masse = masse;
}

override protected function _dessiner():void
{
    super._dessiner();

    // Bille
    graphics.clear();
    graphics.lineStyle(1, _couleur);
    graphics.beginFill(_couleur);
    graphics.drawCircle(0, 0, taille * 0.5 - 1);

    // Bandes
    if (_numero >= 9)
    {
        // Rectangles blancs
        graphics.lineStyle();
        graphics.beginFill(0xffffff);
        graphics.drawRect( -taille / 2, -taille / 2 , taille, 3);
        graphics.drawRect( -taille / 2, taille / 2 - 3, taille, 3);
        graphics.endFill();

        // Masque circulaire
        _masque = new Shape();
        _masque.graphics.beginFill(0);
        _masque.graphics.drawCircle(0, 0, taille * 0.5 - 1);
        addChild(_masque);
        mask = _masque;
    }

    // Numéro
    _etiquette.visible = (_numero > 0);

    if (_etiquette.visible)
    {
        _etiquette.text = _numero.toString();
        _etiquette.x = -_etiquette.width * 0.5;
        _etiquette.y = -_etiquette.height * 0.5;

        graphics.beginFill(0xffffff);
        graphics.drawCircle(0, 0, _etiquette.height * 0.4);
    }
}

private function _dectecterCollision(bille:Bille):Boolean
{
    var dX:Number = this.x - bille.x;
    var dY:Number = this.y - bille.y;

    var racineRayons:Number = (this.taille + bille.taille) * 0.5;
    racineRayons = racineRayons * racineRayons;

    var racineDistance:Number = (dX * dX) + (dY * dY);

    return racineDistance <= racineRayons;
}

private function _calculerChocElastique(bille:Bille):void
{
    var taille:Number = (this.taille + bille.taille) / 2;

    // Repositionnement au point de contact
    // Vecteur distance entre les boules
    var delta:Vecteur2D = new Vecteur2D(this.x - bille.x, this.y - bille.y);
    var d:Number = delta.module;
    // Distance de translation minimum pour pousser les boules
    if (d == 0)
    {
        d = (this.taille + bille.taille) * 0.5 - 1;
        delta = new Vecteur2D((this.taille + bille.taille) * 0.5, 0);
    }
    var mtd:Vecteur2D = delta.multiplier(((this.taille + bille.taille) * 0.5 - d) / d);

    // Masse inverse
    var im1:Number = 1 / this.masse;
    var im2:Number = 1 / bille.masse;

    // Repousser les balles pour éviter qu'elles se chevauchent
    var correction:Vecteur2D = mtd.multiplier(im1 / (im1 + im2));
    this.x += correction.x;
    this.y += correction.y;
    bille.x -= correction.x;
    bille.y -= correction.y;

    // Calcul de la base orthonormée (n,g)
    // n est perpendiculaire au plan de collision, g est tangent
    var nx:Number = (bille.x - this.x) / taille;
    var ny:Number = (bille.y - this.y) / taille;
    var gx:Number = -ny;
    var gy:Number = nx;

    // Calcul des vitesses dans cette base
    var v1n:Number = nx * this.velocite.x + ny * this.velocite.y;
    var v1g:Number = gx * this.velocite.x + gy * this.velocite.y;
    var v2n:Number = nx * bille.velocite.x + ny * bille.velocite.y;
    var v2g:Number = gx * bille.velocite.x + gy * bille.velocite.y;

    // Permute les coordonnées n et conserve la vitesse tangentielle
    // Exécute la transformation inverse (base orthonormée => matrice transposée)
    this.velocite.x = nx * v2n + gx * v1g;
    this.velocite.y = ny * v2n + gy * v1g;
    bille.velocite.x = nx * v1n + gx * v2g;
    bille.velocite.y = ny * v1n + gy * v2g;
}

/**
 * Teste la collision avec une autre bille, et applique le choc élastique le cas échéant.
 * @param bille
 */
public function testerCollision(bille:Bille):void
{
    if (_dectecterCollision(bille))
    {
        _calculerChocElastique(bille);
    }
}

/**
 * Déplace la bille d'une frame avec application de la décélération.
 * @param multiplieur
 */
public function deplacer(multiplicateur:Number = 1):void
{
    x += _velocite.x * multiplicateur;
    y += _velocite.y * multiplicateur;

    rotation += _velocite.module * 3 * multiplicateur;

    if (_velocite.module > 0.03)
    {
        _velocite.module -= (_velocite.module * Constantes.frottement + 0.03) * multiplicateur;
    }
    else
    {
        _velocite.module = 0;
    }
}

// Eléments visuels
private var _fond:Shape;
private var _dessin:Shape;

public function Table() 
{
    _fond = new Shape();
    // Ombre portée
    _fond.filters = [new DropShadowFilter(10, 45, 0, 0.6, 10, 10, 1, 2)];
    addChild(_fond);

    _dessin = new Shape();
    // Ombre intérieure
    _dessin.filters = [new DropShadowFilter(4, 45, 0, 0.3, 20, 20, 1, 2, true)];
    addChild(_dessin);
}

override protected function _dessiner():void 
{
    super._dessiner();

    // Fond
    var margeFond:Number = 0.08 * Unite.METRE;
    _fond.graphics.clear();
    _fond.graphics.lineStyle(5, 0x432e0e, 1, true);
    _fond.graphics.beginFill(0x0c351e);
    _fond.graphics.drawRoundRect( -margeFond, -margeFond, width + 2 * margeFond, height + 2 * margeFond, 32);

    // Zone de jeu
    _dessin.graphics.clear();
    _dessin.graphics.beginFill(0x006029);
    _dessin.graphics.drawRoundRect(0, 0, width, height, 10);
    _dessin.graphics.endFill();

    // Lignes et points centraux
    for (var i:int = 1; i <= 3; i++)
    {
        // Ligne
        _dessin.graphics.lineStyle(4, 0xffffff, 0.15);
        _dessin.graphics.moveTo(width * 0.25 * i, 0);
        _dessin.graphics.lineTo(width * 0.25 * i, height);

        // Point
        _dessin.graphics.lineStyle();
        _dessin.graphics.beginFill(0xffffff, 0.3);
        _dessin.graphics.drawCircle(width * 0.25 * i, height * 0.5, 3);
    }
}

/**
 * Teste la collision de la bille avec les bords de la zone de jeu et applique la collision le cas échéant.
 * @param bille
 */
public function testerCollision(bille:Bille):void
{
    var taille:Number = bille.taille * 0.5;
    // Bord gauche
    if (bille.x - taille <= 0)
    {
        bille.x = taille;
        bille.velocite.x *= -1;
    }
    // Bord droit
    else if (bille.x + taille >= width)
    {
        bille.x = width - taille;
        bille.velocite.x *= -1;
    }

    // Bord haut
    if (bille.y - taille <= 0)
    {
        bille.y = taille;
        bille.velocite.y *= -1;
    }
    // Bord bas
    else if (bille.y + taille >= height)
    {
        bille.y = height - taille;
        bille.velocite.y *= -1;
    }
}

// Infos de base
private var _numero:int;
// Billes tombées dans le trou
private var _billes:Vector.<Bille>;
// Eléments visuels
private var _dessin:Shape;
private var _poche:Shape;

public function Trou(numero:int) 
{
    super();

    _billes = new Vector.<Bille>();

    _dessin = new Shape();
    addChild(_dessin);

    _poche = new Shape();
    _poche.alpha = 0;
    // Ombre intérieure de la poche
    _poche.filters = [new GlowFilter(0x000000, 0.5, 6, 6, 2, 2, true)];
    addChild(_poche);

    _numero = numero;
}

override protected function _dessiner():void 
{
    super._dessiner();

    // Trou
    _dessin.graphics.clear();
    _dessin.graphics.beginFill(0);
    _dessin.graphics.drawCircle(0, 0, taille * 0.5);
}

/**
 * Teste la collision de la bille avec le trou courant.
 * @param bille
 * @return      Vrai si la bille est entrée en collision avec le trou.
 */
public function testerCollision(bille:Bille):Boolean
{
    return _dessin.hitTestObject(bille);
}

/**
 * Ajoute une bille dans le trou. Elle sera affichée dans une poche.
 * @param bille
 */
public function ajouterBille(bille:Bille):void
{
    // Index de la bille dans la liste des billes tombées dans le trou
    var index:int = _billes.length;

    // Bille
    bille.alpha = 1;
    bille.rotation = 0;
    bille.x = x + ((index % 5) - 2) * bille.taille;
    bille.y = y + Math.floor(index / 5) * bille.taille;
    _billes.push(bille);

    // Ajustement de la position de la bille en fonction de l'enplacement de la poche
    if (numero <= 3)
    {
        // Poche au dessus du trou
        bille.y -= bille.taille * 6;
    }
    else
    {
        // Poche en dessous du trou
        bille.y += bille.taille * 4;
    }

    // Animation bille
    TweenMax.fromTo(bille, 0.8, { scaleX:0, scaleY:0 }, { scaleX:1, scaleY:1, ease:Bounce.easeOut, delay:0.3 } );

    // Poche
    _poche.graphics.clear();
    _poche.graphics.beginFill(0x888888, 1);
    _poche.graphics.drawRoundRect(0, 0, 5 * bille.taille + 20, 3 * bille.taille + 20, 20);
    _poche.x = -_poche.width * 0.5;
    _poche.y = -_poche.height;

    // Dessin du triangle de la poche (façon bulle de BD)
    if (numero <= 3)
    {
        // Triangle en bas de la bulle
        _poche.y -= bille.taille * 3;
        _poche.graphics.moveTo(_poche.width * 0.5 - bille.taille, _poche.height);
        _poche.graphics.lineTo(_poche.width * 0.5 + bille.taille, _poche.height);
        _poche.graphics.lineTo(_poche.width * 0.5, _poche.height + bille.taille);
        _poche.graphics.endFill();
    }
    else
    {
        // Tirangle en haut de la bulle
        _poche.y += bille.taille * 3 + _poche.height;
        _poche.graphics.moveTo(_poche.width * 0.5 - bille.taille, 0);
        _poche.graphics.lineTo(_poche.width * 0.5 + bille.taille, 0);
        _poche.graphics.lineTo(_poche.width * 0.5, - bille.taille);
        _poche.graphics.endFill();
    }

    // Animation poche
    TweenMax.to(_poche, 0.25, { alpha:1 } );
}

/**
 * Retire les billes du trou.
 */
public function enleverBilles():void
{
    _billes = new Vector.<Bille>();

    // On cache la poche
    TweenMax.to(_poche, 0.25, { alpha:0, onComplete:_poche.graphics.clear } );
}

// Infos de base
private var _distance:Number;
private var _puissance:Number;
// Indique si les indicateurs visuels sont actifs
private var _indicateursActifs:Boolean = true;
// Eléments visuels
private var _etiquette:TextField;
private var _dessin:Shape;

public function Queue() 
{
    super();

    // Dessin de la queue de billard
    _dessin = new Shape();
    _dessin.filters = [new DropShadowFilter(12, 45, 0, 0.3, 6, 6, 1, 2)];
    addChild(_dessin);

    // Etiquette indiquant la puissance du coup
    _etiquette = new TextField();
    _etiquette.autoSize = TextFieldAutoSize.LEFT;
    _etiquette.embedFonts = true;
    _etiquette.selectable = false;
    _etiquette.defaultTextFormat = new TextFormat('arial', 22, 0xffffff, true);
    _etiquette.filters = [new GlowFilter(0x000000, 0.5, 2, 2, 2, 1), new DropShadowFilter(12, 45, 0, 0.3, 6, 6, 1, 2)];
    addChild(_etiquette);
}

override protected function _dessiner():void 
{
    super._dessiner();

    // Queue
    _dessin.graphics.clear();
    _dessin.graphics.beginFill(0x000000);
    _dessin.graphics.drawRect(-width, -height * 0.5, width * 0.4, height);
    _dessin.graphics.beginFill(0x3e2317);
    _dessin.graphics.drawRect( -width * 0.6, -height * 0.6 * 0.5, width * 0.6, height * 0.6);

    // Viseur
    if (_indicateursActifs)
    {
        graphics.clear();
        graphics.lineStyle(3, 0xffffff, 0.5);
        graphics.moveTo(25, 0);
        graphics.lineTo(45, 0);
    }

    // Etiquette de puissance
    _etiquette.visible = _indicateursActifs;
}

private function _majEtiquette():void
{
    _etiquette.text = Math.round(_puissance * 100) + '%';

    if (rotation < - 90 || rotation > 90)
    {
        _etiquette.rotation = 180;
        _etiquette.x = - _distance;
        _etiquette.y = _etiquette.height;
    }
    else
    {
        _etiquette.rotation = 0;
        _etiquette.x = - _distance - _etiquette.width;
        _etiquette.y = - _etiquette.height;
    }
}

/**
 * Distance du bout de la queue par rapport à la bille de tir.
 */
public function get distance():Number 
{
    return _distance;
}
public function set distance(value:Number):void 
{
    _distance = value;

    // On déplace le dessin de la queue en fonction de la distance par rapport à la bille de tir
    _dessin.x = -_distance;
}
/**
 * Puissance du tir délivré par la queue.
 */
public function get puissance():Number 
{
    return _puissance;
}
public function set puissance(value:Number):void 
{
    _puissance = value;

    _majEtiquette();
}
/**
 * Indique si les indicateurs visuels sont visibles ou non.
 */
public function get indicateursActifs():Boolean 
{
    return _indicateursActifs;
}
public function set indicateursActifs(value:Boolean):void 
{
    _indicateursActifs = value;

    _dessiner();
}

// Eléments visuels
private var _table:Table;
private var _billes:Vector.<Bille>;
private var _billeDeTir:Bille;
private var _queue:Queue;
private var _trous:Vector.<Trou>;
// Configuration de la queue de billard
private var _distanceMinimum:Number = 25;
private var _distanceMaximum:Number = 250;
private var _puissanceMinimum:Number = 1;
private var _puissanceMaximum:Number = 35;
// Distance de la souris par rapport à la pointe de la queue
private var _distanceSouris:Number = 200;
// Vitesse actuelle de l'animation (1 = vitesse normale)
private var _vitesseAnimation:Number = 1;
// Indicateurs
private var _simulationEnCours:Boolean = false;
private var _phaseDeTir:Boolean = false;
// Indique si le billard est en train d'être déplacé
private var _tableDrag:Boolean = false;

// Table
_table = new Table();
// Taille standard
_table.width = 2.34 * Unite.METRE;
_table.height = 1.17 * Unite.METRE;
addChild(_table);

// Trous
_trous = new Vector.<Trou>();
// Marge entre les trous et les bords de la table
var margeTrou:Number = 0.015 * Unite.METRE;
var i:int;
for (i = 0; i < 6; i++)
{
    var trou:Trou = new Trou(i + 1);
    trou.taille = 0.069 * Unite.METRE;
    // Lignes de trois colonnes de trous
    trou.x = (i % 3) * (_table.width + 2 * margeTrou) / 2 - margeTrou;
    trou.y = Math.floor(i / 3) * (_table.height + 2 * margeTrou) - margeTrou;
    _table.addChild(trou);
    _trous.push(trou);
}

// Billes
// Couleurs réglementaires
var couleurs:Array = [
    0xffffff, // Bille blanche
    0xfac92e, 
    0x1744c1, 
    0xee372e, 
    0x271d53, 
    0xff8d59, 
    0x189e66, 
    0x931422, 
    0x000000, // Bille 8
    0xf7af1d, 
    0x2059e8, 
    0xde291d, 
    0x2f2665, 
    0xfb8351, 
    0x0d955c, 
    0x92121d
];

// Liste des billes
_billes = new Vector.<Bille>();
// Création des 15 billes
for (i = 0; i <= 15; i++)
{
    var bille:Bille = new Bille(couleurs[i], i, 0.05 * Unite.METRE, 172 * Unite.GRAMME);
    _table.addChild(bille);
    _billes.push(bille);

    if (i == 0)
    {
        _billeDeTir = bille;
    }
}

// On remet la bille de tir au premier plan
_table.setChildIndex(_billeDeTir, _table.numChildren - 1);

// Queue
_queue = new Queue();
_queue.width = 1.5 * Unite.METRE;
_queue.height = 0.025 * Unite.METRE;
_table.addChild(_queue);

// Lorsque le billard est ajouté à la scène, nous ajoutons les autres écouteurs d'événements
addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);

private function onAddedToStage(event:Event):void
{
    // Déplacement de la table de billard
    stage.addEventListener(MouseEvent.RIGHT_MOUSE_DOWN, onMouseRightDown);
    stage.addEventListener(MouseEvent.RIGHT_MOUSE_UP, onMouseRightUp);

    // Ralenti
    stage.addEventListener(MouseEvent.MIDDLE_CLICK, onMiddleClick);
}

/* Déplacement de la table de billard */
private function onMouseRightDown(event:MouseEvent):void
{
    if (_phaseDeTir || _simulationEnCours)
    {
        _table.startDrag();
        _tableDrag = true;
    }
}

private function onMouseRightUp(event:MouseEvent):void
{
    if (_tableDrag)
    {
        _table.stopDrag();
    }
}

/* Ralenti */
private function onMiddleClick(event:MouseEvent):void
{
    ralenti();
}

/**
 * Active ou désactive le ralenti.
 */
public function ralenti():void
{
    if (_vitesseAnimation != 0.15)
    {
        _vitesseAnimation = 0.15; // Ralenti à 15% de la vitesse normale !
    }
    else
    {
        _vitesseAnimation = 1;
    }
}

private function _placerBilles():void
{
    // Vider les trous
    for each(var trou:Trou in _trous)
    {
        trou.enleverBilles();
    }

    // Triangle
    var bille:Bille;
    var l:int = _billes.length;
    var triangleLignes:int = 1;
    var triangleLigne:int = 0;
    var triangleX:Number = _table.width * 0.75 - _billeDeTir.taille * 2.5;
    var order:Array = [0, 9, 7, 12, 15, 8, 1, 6, 10, 3, 14, 11, 2, 13, 4, 5];
    for (var i:int = 0; i < l; i++)
    {
        bille = _billes[order[i]];

        // Initialisation des billes
        bille.alpha = 1;
        bille.scaleX = 1;
        bille.scaleY = 1;
        bille.velocite.x = 0;
        bille.velocite.y = 0;

        bille.horsJeu = false;
        if (i > 0)
        {
            bille.x = triangleX;
            bille.y = _table.height * 0.5 + (triangleLigne - triangleLignes * 0.5 ) * _billeDeTir.taille + _billeDeTir.taille * 0.5;

            triangleLigne ++;
            if (triangleLigne == triangleLignes)
            {
                triangleLigne = 0;
                triangleLignes ++;
                triangleX += _billeDeTir.taille;
            }
        }
    }
}

private function _lancerPhaseBilleDeTir():void
{
    _arreterPhaseDeTir();
    _arreterPhaseSimulation();

    _table.stopDrag();
    _tableDrag = false;

    // On annule d'éventuelles animations sur les propriétés de la bille de tir pour éviter les conflits avec le "drag"
    TweenMax.killTweensOf(_billeDeTir);

    // Réinitialisation de la bille
    _billeDeTir.horsJeu = false;
    _billeDeTir.scaleX = 1;
    _billeDeTir.scaleY = 1;
    _billeDeTir.velocite.x = 0;
    _billeDeTir.velocite.y = 0;

    // On fait réapparaître la bille de tir
    TweenMax.to(_billeDeTir, 0.2, { alpha:1 } );

    // On active le "drag" :
    // Lorsque la souris du joueur va se déplacer, la bille de tir se positionnera en dessous, dans les limites de la zone de jeu.
    _billeDeTir.startDrag(true, new Rectangle(_billeDeTir.taille * 0.5, _billeDeTir.taille * 0.5, _table.width - _billeDeTir.taille, _table.height - _billeDeTir.taille));

    addEventListener(MouseEvent.MOUSE_UP, onPhaseBilleDeTirClick);
}

private function onPhaseBilleDeTirClick(event:MouseEvent):void
{
    // On empêche la propagation de l'événement pour éviter que le tir ne se déclenche tout de suite
    event.stopImmediatePropagation();

    _lancerPhaseDeTir();
}

private function _arreterPhaseBilleDeTir():void
{
    _billeDeTir.stopDrag();

    removeEventListener(MouseEvent.MOUSE_UP, onPhaseBilleDeTirClick);
}

private function _lancerPhaseDeTir():void
{
    _arreterPhaseBilleDeTir();
    _arreterPhaseSimulation();

    // Gestion de la souris
    stage.addEventListener(MouseEvent.MOUSE_MOVE, onPhaseDeTirMouseMove);
    stage.addEventListener(MouseEvent.MOUSE_UP, onPhaseDeTirClick);

    _phaseDeTir = true;
    _queue.indicateursActifs = true;
    _queue.visible = true;

    _deplacerQueue();
}

private function onPhaseDeTirMouseMove(event:MouseEvent):void
{
    _deplacerQueue();
}
private function onPhaseDeTirClick(event:MouseEvent):void
{
    _tirer();
}

private function _arreterPhaseDeTir():void
{
    // Fin de la gestion de la souris
    stage.removeEventListener(MouseEvent.MOUSE_MOVE, onPhaseDeTirMouseMove);
    stage.removeEventListener(MouseEvent.MOUSE_UP, onPhaseDeTirClick);

    _phaseDeTir = false;
    _queue.visible = false;
}

private function _deplacerQueue():void
{
    // On centre la queue sur la bille de tir
    _queue.x = _billeDeTir.x;
    _queue.y = _billeDeTir.y;

    // Distance entre la souris et la bille de tir
    var distance:Number = Outils.distanceNombres(_table.mouseX, _table.mouseY, _billeDeTir.x, _billeDeTir.y) - _distanceSouris;
    if (distance > _distanceMaximum)
    {
        distance = _distanceMaximum;
    }
    else if (distance < _distanceMinimum)
    {
        distance = _distanceMinimum;
    }

    // Angle entre la souris et la bille de tir (radians)
    var angle:Number = Outils.angleNombres(_table.mouseX, _table.mouseY, _billeDeTir.x, _billeDeTir.y);

    // Aplication des modifications sur la queue de billard
    _queue.rotation = angle / Math.PI * 180;
    _queue.distance = distance - 10;
    _queue.puissance = (distance - _distanceMinimum) / (_distanceMaximum - _distanceMinimum);
}

private function _tirer():void
{
    // On arrête la phase de tir
    _arreterPhaseDeTir();
    _queue.indicateursActifs = false;
    _queue.visible = true;

    // Distance entre la souris et la bille de tir
    var distance:Number = Outils.distanceNombres(_table.mouseX, _table.mouseY, _billeDeTir.x, _billeDeTir.y) - _distanceSouris;
    if (distance > _distanceMaximum)
    {
        distance = _distanceMaximum;
    }
    else if (distance < _distanceMinimum)
    {
        distance = _distanceMinimum;
    }

    // Angle entre la souris et la bille de tir (radians)
    var angle:Number = Outils.angleNombres(_table.mouseX, _table.mouseY, _billeDeTir.x, _billeDeTir.y);
    var module:Number = (distance - _distanceMinimum) / (_distanceMaximum - _distanceMinimum) * (_puissanceMaximum - _puissanceMinimum) + _puissanceMinimum;

    // Coup sur la bille
    _billeDeTir.velocite.angle = angle;
    _billeDeTir.velocite.module = module;

    // Animation de la queue
    TweenMax.to(_queue, 0.1, { distance:10, onComplete:_lancerPhaseSimulation } );
}

private function _lancerPhaseSimulation():void
{
    _table.stopDrag();
    _arreterPhaseBilleDeTir();
    _arreterPhaseDeTir();

    addEventListener(Event.ENTER_FRAME, onPhaseSimulationEnterFrame);

    _simulationEnCours = true;
}

private function onPhaseSimulationEnterFrame(event:Event):void
{
    _deplacerBilles();
}

private function _arreterPhaseSimulation():void
{
    removeEventListener(Event.ENTER_FRAME, onPhaseSimulationEnterFrame);

    _simulationEnCours = false;
}

private function _deplacerBilles():void
{
    var toutesLesBillesSontImmobiles:Boolean = true;

    // Détection des collisions entre les billes
    var l:int = _billes.length;
    var bille1:Bille, bille2:Bille;
    for (var i:int = 0; i < l; i++)
    {
        bille1 = _billes[i];

        // Si la bille courante est hors-jeu, on passe à la suivante
        if (bille1.horsJeu)
        {
            continue;
        }

        // Si la bille courante se déplace
        if (bille1.velocite.module > 0)
        {
            toutesLesBillesSontImmobiles = false;
        }

        // Tests des collisions de la bille courante avec les autres billes
        for (var j:int = i + 1; j < l; j++)
        {
            bille2 = _billes[j];

            // Bille hors-jeu : on passe à la suivante
            if (bille2.horsJeu)
            {
                continue;
            }

            // Test de collition
            bille1.testerCollision(bille2);
        }

        // Déplacement de la bille courante
        _deplacerBille(bille1);
    }

    // Toutes les billes sont immobiles et la bille de tir n'est pas dans un trou, il faut relancer la phase de tir
    if (toutesLesBillesSontImmobiles)
    {
        if (_billeDeTir.horsJeu)
        {
            setTimeout(_lancerPhaseBilleDeTir, 400); // Laisse du temps pour l'animation de chute de la bille dans le trou
        }
        else
        {
            _lancerPhaseDeTir();
        }
    }
}

private function _deplacerBille(bille:Bille):void
{
    // Mouvement de la bille (avec multiplicateur pour le ralenti)
    bille.deplacer(_vitesseAnimation);

    // Détection des collisions de la bille avec les trous de la table de billard
    _detecterCollisionTrou(bille);

    // Détextion des collisions de la bille avec les bords de la table
    if (!bille.horsJeu)
    {
        _table.testerCollision(bille);
    }
}

private function _detecterCollisionTrou(bille:Bille):void
{
    // On teste la collision de la bille avec chaque trou
    for each(var trou:Trou in _trous)
    {
        if (trou.testerCollision(bille))
        {
            // La bille est sortie -> hors-jeu
            bille.horsJeu = true;

            // Paramètres de l'animation
            var params:Object = { x: trou.x, y: trou.y, scaleX:0.7, scaleY:0.7, alpha:0 };

            if (bille != _billeDeTir)
            {
                // Si la bille n'est pas la bille de tir, on l'ajoute à la réserve du trou à la fin de l'animation
                params.onComplete = trou.ajouterBille;
                params.onCompleteParams = [bille];
            }

            // Animation de chute dans le trou
            TweenMax.to(bille, 0.4, params);
        }
    }
}

/**
 * Remet le billard à zéro et lance une nouvelle partie.
 */
public function nouvellePartie():void
{
    // Arrêt de l'éventuelle partie ne cours
    _arreterPhaseBilleDeTir();
    _arreterPhaseSimulation();
    _arreterPhaseDeTir();

    // Triangle des billes
    _placerBilles();

    // Bille de tir
    _lancerPhaseBilleDeTir();
}

/* On remplace le fonctionnement habituel des accesseurs de la taille du billard pour ne prendre en compte que la taille de la table. */
override public function get width():Number 
{
    return _table.width;
}
override public function get height():Number 
{
    return _table.height;
}

// Configuration de la scène
stage.align = StageAlign.TOP_LEFT;
stage.scaleMode = StageScaleMode.NO_SCALE;
// Polices embarquées
EmbedFonts.init();

package 
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageDisplayState;
    import flash.display.StageQuality;
    import flash.display.StageScaleMode;
    import flash.events.Event;

    /**
     * Classe principale
     * @author Guillaume CHAU
     */
    public class Main extends Sprite 
    {
        public function Main():void 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }

        private function init(e:Event = null):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);
            // entry point

            // Configuration de la scène
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.quality = StageQuality.BEST;

            // Polices embarquées
            EmbedFonts.init();

            // Commencer à coder ici
        }
    }

}

[Embed(source = "../lib/img/fond.png")]
private var Fond:Class;
private var _fond:Sprite;
private var _texture:BitmapData;

// Fond
_fond = new Sprite();
addChild(_fond);
// Texture du fond
var bmp:Bitmap = new Fond();
_texture = bmp.bitmapData;

private var _billard:Billard;

// Billard
_billard = new Billard();
addChild(_billard);
_billard.nouvellePartie();

private function _rafraichir():void
{
    // Fond
    _fond.graphics.clear();
    _fond.graphics.beginBitmapFill(_texture);
    _fond.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);

    // Billard
    _billard.x = (stage.stageWidth - _billard.width) * 0.5;
    _billard.y = (stage.stageHeight - _billard.height) * 0.5;
}

// On met à jour la position du billard et la texture de fond pour la première fois
_rafraichir();

private function onStageResize(event:Event):void
{
    _rafraichir();
}

// Lorsque la scène est redimensionnée
stage.addEventListener(Event.RESIZE, onStageResize);

// Gestion du clavier
stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp);

private function onKeyUp(event:KeyboardEvent):void
{
    if (event.keyCode == Keyboard.SPACE)
    {
        _billard.nouvellePartie();
    }
}