Rapidité et stratégie : Don't Click

?package
{
        import com.greensock.plugins.ShortRotationPlugin;
        import com.greensock.plugins.TweenPlugin;
        import com.greensock.TweenMax;
        import flash.display.Loader;
        import flash.display.MovieClip;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.net.navigateToURL;
        import flash.net.sendToURL;
        import flash.net.URLRequest;
        import flash.system.LoaderContext;
        import flash.ui.Mouse;
        import flash.utils.getTimer;
        import mochi.as3.*;
        import Niveaux.Level;
        import Niveaux.*;
        import Niveaux.LevelLost;
       
        /**
         * Jeu DontClick.
         * Nécessite la présence de trois fichiers pour compiler : Sun.svg, Labyrinthe.svg et Curseur.png
         *
         * Développé en décembre 2009, sans grandes prétentions.
         * @author Neamar
         */
        public class Main extends Sprite
        {
                public static var Sponsor:Loader = new Loader();
               
                private var ListeNiveaux:Array = new Array(Level_1, Level_2, Level_3, Level_4, Level_5, Level_6, Level_7, Level_8, Level_9, Level_10, Level_11, Level_12, Level_13, Level_14, Level_15,Level_16,Level_17,Level_18,Level_19,Level_20);
               
                private var AncienLevel:Level;
                private var AncienneArrivee:Point = new Point(0,0);
                private var LevelActuel:Level=null;
                private var NumLevelActuel:int = 1;
               
                private var HeureDepart:int;
               
               
               
                public static const ARRIVEE:int = 0x052366; //Couleur du nueage autour de l'arrivée
                public static const OBSTACLE:int = 0x043463; //Couleur de l'intérieur des briques
                public static const BORDS_OBSTACLE:int = 0; // 0x422879; //COuleur du bord d'un obstacle
                public static const FLOU_OBSTACLE:int = 0x250569; //Flou autour des obstacles qui devient plus en plus gros
                public static const LEVEL_PERDU:int = 0x2f0101; // Couleur du fond d'un niveau perdu
               

                public var Pub:MovieClip = new MovieClip();

               
               
                public function Main():void
                {
                       
                        //Pour des rotations claires avec TweenMax
                        TweenPlugin.activate([ShortRotationPlugin]);
                       
                        //Enregistrer le nouveau joueur :
                        sendToURL(new URLRequest("http://neamar.fr/Res/DontClick/Player.php"));
                       
                        addChild(Pub);
                        MochiServices.connect("360e8f10af8dce7d", Pub);
                       
                        //Quand ça commence, on affiche la pub
                        afficherPub();
                       
                        graphics.beginFill(0);
                        graphics.drawRect(0, 0, 640, 480);
                       
                        Sponsor.load(new URLRequest("http://neamar.fr/Res/CoinStack/Images/MiniJeu.png"), new LoaderContext(true));
                        Sponsor.addEventListener(MouseEvent.CLICK, visiterSponsor);
                }
               
                public function afficherPub():void
                {
                        function lancerJeu():void
                        {
                                //La pub s'est terminée, allons-y !
                                HeureDepart = getTimer();
                                nouveauNiveau();
                        }
                       
                        //addChild(Pub);
                        MochiAd.showInterLevelAd( { clip:Pub, id:"360e8f10af8dce7d", res:"640x480", no_bg:true, ad_started:new Function(), ad_finished: lancerJeu } );
                        //lancerJeu();
                }
               
                ////////////////////////////////////////////////////////////////////////////////////
                //CHANGEMENTS DE NIVEAUX
               
                /**
                 * Créer un nouveau niveau, supprimer l'ancien et augmenter le numéro du niveau en cours
                 */
                public function nouveauNiveau(e:Event=null):void
                {
                        if (NumLevelActuel > ListeNiveaux.length)
                        {
                                enleverAncienNiveau(LevelActuel);
                                LevelActuel = null;
                                NumLevelActuel = 1;
                                var o:Object = { n: [14, 0, 6, 1, 11, 10, 10, 2, 5, 15, 3, 5, 13, 4, 11, 0], f: function (i:Number,s:String):String { if (s.length == 16) return s; return this.f(i+1,s + this.n[i].toString(16));}};
                                var boardID:String = o.f(0,"");
                                MochiScores.showLeaderboard( { boardID: boardID, onClose: afficherPub, score:getTimer()-HeureDepart, res:"640x480" } );
                        }
                        else
                        {                      
                                Mouse.show();
                                changerNiveauActuel(new ListeNiveaux[NumLevelActuel-1](new Point(mouseX,mouseY)));
                                NumLevelActuel++;
                        }
                }
                       
                public function recommencerNiveau(e:Event=null):void
                {
                        NumLevelActuel--;
                        Mouse.show();
                        changerNiveauActuel(new LevelLost(new Point(mouseX,mouseY),AncienneArrivee))
                }
               
                ////////////////////////////////////////////////////////////////////////////////////
                //TRANSITION ENTRE DEUX NIVEAUX
               
                /**
                 * Faire apparaitre le nouveau niveau et disparaitre l'ancien
                 * @param New Le nouveau niveau à afficher.
                 */
                public function changerNiveauActuel(New:Level):void
                {
                        AncienLevel = LevelActuel;

                        if (AncienLevel != null)
                        {
                                AncienneArrivee = AncienLevel.PointArrivee;
                                AncienLevel.removeEventListener(Level.LEVEL_GAGNE, nouveauNiveau);
                                AncienLevel.removeEventListener(Level.LEVEL_PERDU, recommencerNiveau);
                        }
                       
                        New.addEventListener(Level.LEVEL_GAGNE, nouveauNiveau);
                        New.addEventListener(Level.LEVEL_PERDU, recommencerNiveau);
                        New.alpha = 0;
                        addChild(New);
                       
                        LevelActuel = New;
                       
                        TweenMax.to(LevelActuel, 1, { alpha:1 } );
                       
                        if(AncienLevel!=null)
                                TweenMax.to(AncienLevel, 1, { alpha:0, onComplete:enleverAncienNiveau, onCompleteParams:new Array(AncienLevel) } );
                }
               
                /**
                 * Supprime l'ancien niveau à la fin du tween.
                 * On ne peut pas se fier à AncienLevel qui peut avoir changé entre temps
                 */
                public function enleverAncienNiveau(LevelASupprimer:Level):void
                {
                        removeChild(LevelASupprimer);
                        LevelASupprimer.destroy();
                }
               
                /**
                 * Envoie le joueur vers la page du sponsor.
                 */
                private function visiterSponsor(e:MouseEvent):void
                {
                        navigateToURL(new URLRequest("http://www.mini-jeu-gratuit.fr/vip/neamar/"));
                }
        }
       
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.display.Sprite;
       
        /**
         * Un anneau, utilisé dans beaucoup de niveaux.
         * Cercle légérement entrouvert, type Circlip.
         * @author Neamar
         */
        public class Ring extends Sprite
        {
                public var RayonOut:int = 15;
               
                private var _rotation:Number = 0;
               
                public function Ring(x:int,y:int,Rayon:int=50, Angle:Number=(Math.PI/6))
                {
                        RayonOut += Rayon;
                       
                        super();
                        this.x = x;
                        this.y = y;
                       
                        //Diviser l'angle par 2 pour travailler avec plus facilement
                        Angle = Angle / 2;
                       
                        this.graphics.lineStyle(5, 0);
                       
                        //this.graphics.drawCircle(0, 0, Rayon);
                       
                        this.graphics.moveTo(RayonOut * Math.cos(Angle), RayonOut * Math.sin(Angle));
                        this.graphics.lineTo(Rayon * Math.cos(Angle), Rayon * Math.sin(Angle));
                        for (var teta:Number = Angle; teta < 2 * Math.PI - Angle; teta += Math.PI / 30)
                                this.graphics.lineTo(Rayon * Math.cos(teta), Rayon * Math.sin(teta));
                        this.graphics.lineTo(RayonOut * Math.cos(-Angle), RayonOut * Math.sin(-Angle));
                }
               
                public function destroy():void
                {
                        this.graphics.clear();
                        TweenMax.killTweensOf(this);
                }
               
                public function tournerVersRelatif(Angle:Number):void
                {
                        if(Angle!=0)
                                tournerVers(_rotation + Angle);
                }
               
                public function tournerVers(Angle:Number):void
                {
                        Angle = Angle % 360;
                               
                        _rotation = Angle;
                       
                        TweenMax.to(this, .5, { shortRotation:{rotation:Angle} } );
                }
        }
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.display.GradientType;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.filters.BevelFilter;
        import flash.filters.BlurFilter;
        import flash.filters.GlowFilter;
        import flash.geom.Point;
       
        /**
         * Un niveau de jeu. Type abstrait.
         * @author Neamar
         */
        public class Level extends Sprite
        {
                /**
                 * Liste des évenements dispatchés
                 */
                public static var LEVEL_GAGNE:String = "levelGagne";
                public static var LEVEL_PERDU:String = "levelPerdu";
               
                public static var RAYON_ARRIVEE:int = 20;
               
               
                public static var FiltreArrivee:GlowFilter = new GlowFilter(Main.ARRIVEE);
                public static var FiltreArriveeTab:Array = new Array(FiltreArrivee,new BevelFilter(6));
                public var AngleIntensite:Number = 0;
                public var IntensiteMax:int = 50;
                public var IntensiteMin:int = 20;
                public var AngleCouleur:Number = 0;
               
                protected var Depart:Sprite = new Sprite();
                protected var Arrivee:Sprite = new Sprite();
               
                protected var CurseurVirtuel:Point = new Point();
               
                public function Level(Depart:Point, Arrivee:Point=null)
                {
                        this.graphics.lineStyle(1,0xAAAAAA);
                        this.graphics.beginFill(0x000000);
                        this.graphics.drawRect(0, 0, 640, 480);
                       
                        //Le cercle de départ
                        this.Depart.graphics.lineStyle(2, 0xAAAAAA);
                        this.Depart.graphics.drawCircle(0, 0, RAYON_ARRIVEE);
                        this.Depart.x = Depart.x;
                        this.Depart.y = Depart.y;
                        addChild(this.Depart);
                        TweenMax.to(this.Depart,3, { alpha:0,onComplete:removeDepart } );

                        //Le cercle de l'arrivée
                        this.Arrivee.graphics.lineStyle(2, 0x000080);
                        this.Arrivee.graphics.beginFill(FiltreArrivee.color);// GradientType.RADIAL, new Array(0xFFFFFF, 0), new Array(1, 1), new Array(0, 255));
                        this.Arrivee.x = Arrivee.x;
                        this.Arrivee.y = Arrivee.y;
                       
                        this.Arrivee.graphics.drawCircle(0, 0 , RAYON_ARRIVEE);
                       
                        addChild(this.Arrivee);
                       
                        addEventListener(MouseEvent.MOUSE_MOVE, deplacementSouris);
                       
                        addEventListener(Event.ENTER_FRAME, brillerArrivee);
                        addEventListener(Event.ENTER_FRAME,brillerDepart);
                }
               
                /**
                 * Détruit entièrement le niveau. Overridé par chacun des niveaux qui occupe de la mémoire supplémentaire.
                 * Cela permet de faciliter le travail du garbage collecotr, et aussi de s'assurer que tout est bien détruit et qu'aucun listener ne reste.
                 */
                public function destroy():void
                {
                        Depart = null;
                        Arrivee.filters = null;
                        Arrivee = null;
                        this.graphics.clear();
                        removeEventListener(MouseEvent.MOUSE_MOVE, deplacementSouris);
                        removeEventListener(Event.ENTER_FRAME, brillerArrivee);
                        removeEventListener(Event.ENTER_FRAME,brillerDepart);
                        CurseurVirtuel = null;
                }
               
                /**
                 * Accesseurs faciles pour des propriétés souvent utilisées
                 * @param
                 */
                public function get PointArrivee():Point
                {
                        return new Point(Arrivee.x, Arrivee.y);
                }
                public function get PointDepart():Point
                {
                        return new Point(Depart.x, Depart.y);
                }
               
                /**
                 * Trigerré par un mouvement de la souris.
                 * Met à jour la position, et vérifie si on a gagné ou non.
                 * @param
                 */
                protected function majCoordonneesSouris(e:MouseEvent):void
                {
                        CurseurVirtuel.x = e.stageX;
                        CurseurVirtuel.y = e.stageY;
                }
               
                /**
                 * Appellé à chaque mouvement de la souris.
                 * Overridé dans presque toutes les classes
                 * @param e Les coordonnées souris
                 */
                protected function deplacementSouris(e:MouseEvent):void
                {
                        majCoordonneesSouris(e);
                        if (Arrivee.visible && Point.distance(CurseurVirtuel, PointArrivee) < RAYON_ARRIVEE)
                        {
                                this.dispatchEvent(new Event(LEVEL_GAGNE));
                                this.removeEventListener(MouseEvent.MOUSE_MOVE, deplacementSouris);
                        }
                }
               
                /**
                 * Graphismes
                 */
                protected function brillerArrivee(e:Event):void
                {
                        AngleIntensite = (AngleIntensite+Math.PI / 200) % Math.PI;
                        AngleCouleur = (AngleCouleur + Math.PI / 33) % Math.PI;
                       
                        FiltreArrivee.blurX = FiltreArrivee.blurY = IntensiteMin + (IntensiteMax - IntensiteMin) * Math.sin(AngleIntensite);
                        //FiltreArrivee.color = 0x2e0094 + 0x00FF00 * Math.abs(Math.sin(AngleIntensite));
                        Arrivee.filters = FiltreArriveeTab;
                }
               
                protected function brillerDepart(e:Event):void
                {
                        FiltreArrivee.blurX = FiltreArrivee.blurY = IntensiteMin + (IntensiteMax - IntensiteMin) * Math.sin(Math.PI - AngleIntensite);
                        Depart.filters = FiltreArriveeTab;
                }
               
                protected function removeDepart():void
                {
                        if(Depart!=null)
                                removeChild(Depart);
                        removeEventListener(Event.ENTER_FRAME,brillerDepart);
                }
        }
       
}

?package Niveaux
{
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.filters.BevelFilter;
        import flash.filters.GlowFilter;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un niveau avec des obstacles.
         * Tous les obstacles sont regroupés et addChildés dans le Sprite Obstacles, un hitTest permet de trouve rles collisions.
         * On interpole les points manquants si l'ordi rame pour éviter la triche en déplaçant très vite la souris.
         * On fait aussi le test sur enterframe pour éviter de rester immobile sur un niveau qui bouge (sans enterframe, on ne perd pas puisque que mousemove n'est pas lancé).
         *
         * Hérité par la quasi totalité des niveaux du jeu.
         * @author Neamar
         */
        public class HitLevel extends Level
        {
                protected var Obstacles:Sprite = new Sprite();
                protected var DoitEviterObstacles:Boolean = true;
               
                public static var FiltreObstacles:GlowFilter = new GlowFilter(Main.FLOU_OBSTACLE);
                public static var FiltreObstaclesTab:Array = new Array(FiltreObstacles,new BevelFilter(4,45,0xFFFFFF,1,Main.FLOU_OBSTACLE));
               
                //Enregistrer pour l'interpolation
                protected var DernierPoint:Point;
               
                public function HitLevel(Depart:Point,Arrivee:Point=null)
                {
                        DernierPoint = new Point(mouseX, mouseY);
                        super(Depart, Arrivee);
                       
                        addChild(Obstacles);
                        setChildIndex(Obstacles,0);
                        prepareFill();
                       
                        addEventListener(Event.ENTER_FRAME, verifierTriche);
                       
                        Obstacles.filters = FiltreObstaclesTab;
                }
               
                public override function destroy():void
                {
                        Obstacles = null;
                        removeEventListener(Event.ENTER_FRAME, verifierTriche);
                        super.destroy();
                }
               
                public function prepareFill():void
                {
                        Obstacles.graphics.lineStyle(3,Main.BORDS_OBSTACLE);
                        //Obstacles.graphics.beginFill(Main.OBSTACLE);
                }
               
                protected override function deplacementSouris(e:MouseEvent):void
                {      
                        majCoordonneesSouris(e);
                       
                        var Distance:Number = Point.distance(DernierPoint, CurseurVirtuel)
                       
                        //Faire un hittest sur tous les points pour s'assurer qu'il ne tirhce pas en déplaçant rapidement la souris
                        for (var i:int = 0; i < Distance; i++)
                        {
                                var PointVirtuel:Point = Point.interpolate(DernierPoint, CurseurVirtuel, i / Distance);
                                if (Obstacles.hitTestPoint(PointVirtuel.x, PointVirtuel.y, true)==DoitEviterObstacles)
                                        dispatchEvent(new Event(Level.LEVEL_PERDU));
                        }
                       
                        super.deplacementSouris(e);
                       
                        //Enregister le dernier point si le level n'est pas détruit
                        if (DernierPoint != null)
                        {
                                DernierPoint.x = CurseurVirtuel.x;
                                DernierPoint.y = CurseurVirtuel.y;
                        }
                }
               
                private function verifierTriche(e:Event):void
                {
                        if(Obstacles.hitTestPoint(CurseurVirtuel.x, CurseurVirtuel.y, true)==DoitEviterObstacles)
                                        dispatchEvent(new Event(Level.LEVEL_PERDU));
                }
        }
       
}

?package Niveaux
{
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.ui.Mouse;
        import Niveaux.HitLevel;
       
        /**
         * Masque le curseur en dehore du point de départ. Hérité par les niveaux sans curseurs.
         * @author Neamar
         */
        public class HiddenLevel extends HitLevel
        {
               
                public function HiddenLevel(Depart:Point, Arrivee:Point = null)
                {
                        super(Depart, Arrivee);
                }
               
                public override function destroy():void
                {
                        Mouse.show();
                        super.destroy();
                }
               
                protected override function deplacementSouris(e:MouseEvent):void
                {
                        if (Point.distance(CurseurVirtuel, PointDepart) < RAYON_ARRIVEE)
                                Mouse.show();
                        else
                                Mouse.hide();
                               
                        super.deplacementSouris(e);
                }
        }

}

?package Niveaux
{
        import flash.display.Bitmap;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.ui.Mouse;
        import Niveaux.Level;
       
        /**
         * Classe de base pour les niveaux à curseur spécial (qui ne se déplace pas avec la souris)
         * @author Neamar
         */
        public class SpecialCursor extends Level
        {
                [Embed(source="../../assets/Curseur.png")]
                private static var Curseur:Class;
               
                protected var Souris:Bitmap = new SpecialCursor.Curseur();
               
                public function SpecialCursor(Depart:Point, Arrivee:Point=null)
                {
                        super(Depart, Arrivee);
                        addChild(Souris);
                        Mouse.hide();
                }
               
                public override function destroy():void
                {
                        Souris = null;
                        super.destroy();
                }

                protected override function majCoordonneesSouris(e:MouseEvent):void
                {      
                        Souris.x = CurseurVirtuel.x;
                        Souris.y = CurseurVirtuel.y;
                       
                        //PAS d'APPEL à super !
                }
        }
       
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.display.Bitmap;
        import flash.display.DisplayObject;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.filters.BevelFilter;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un niveau qui utilise le labyrinthe.
         * Initialise un sprite, le positionne et le fait tourner.
         * @author Neamar
         */
        public class LabyLevel extends HitLevel
        {
                [Embed(source="../../assets/Labyrinthe.svg")]
                public static var Labyrinthe:Class;
               
                protected var Revolution:int = 75;
                protected var Laby:DisplayObject = new Labyrinthe();
               
                public function LabyLevel(Depart:Point, Arrivee:Point=null)
                {
                        super(Depart, Arrivee);
                        Obstacles.addChild(Laby);

                        Laby.x = 59 - 320;
                        Laby.y = -34 - 240;
                       
                        Obstacles.x = 320;
                        Obstacles.y = 240;
                        Obstacles.rotation = 135;
                       
                        TweenMax.to(Obstacles, Revolution, { delay:2, rotation:360+90} );
                }
               
                public override function destroy():void
                {
                        TweenMax.killTweensOf(Obstacles);
                        Obstacles.removeChild(Laby);
                        Laby = null;
                       
                        super.destroy();
                }
        }
}

?package Niveaux
{
        import flash.geom.Point;
        import Niveaux.Level;
        import Utilitaires.DirectShape;
       
        /**
         * Un "Level perdu" qui oblige l'utilisateur à recommencer le niveau
         * @author Neamar
         */
        public class LevelLost extends Level
        {
                public function LevelLost(Depart:Point, Arrivee:Point)
                {
                        super(Depart, Arrivee);
                        this.graphics.clear();
                        this.graphics.lineStyle(1,0xAAAAAA);
                        this.graphics.beginFill(Main.LEVEL_PERDU);
                        this.graphics.drawRect(0, 0, 640, 480);
                }
        }

}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un niveau de jeu. Arrivée cachée sous la pub de mochiads
         * @author Neamar
         */
        public class Level_1 extends Level
        {
                public function Level_1(Depart:Point,Arrivee:Point=null)
                {
                        Arrivee = new Point(320, 240);
                        super(Depart, Arrivee);
                        this.Arrivee.visible = false;
                       
                        addChild(Main.Sponsor);
                        Main.Sponsor.x = 320 - Main.Sponsor.width / 2;
                        Main.Sponsor.y = 240 - Main.Sponsor.height / 2;
                       
                        TweenMax.to(Main.Sponsor, 1, {delay:4, alpha:0, onComplete:enleverSponsor } );
                }
               
                private function enleverSponsor():void
                {
                        removeChild(Main.Sponsor);
                        Arrivee.visible = true;
                        Arrivee.alpha = 0;
                        TweenMax.to(Arrivee, 1, { alpha:1 } );
                }
        }
}

?package Niveaux
{
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un niveau de jeu. Aucune difficulté, permet de comprendre le principe.
         * @author Neamar
         */
        public class Level_2 extends Level
        {
                public function Level_2(Depart:Point,Arrivee:Point=null)
                {
                        Arrivee = new Point(600, 40);
                        super(Depart, Arrivee);
                }
        }
       
}

?package Niveaux
{
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un niveau de jeu. Ne pas toucher les bords pour le finir.
         * @author Neamar
         */
        public class Level_3 extends HitLevel
        {
                public function Level_3(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(40, 460);
                        super(Depart,Arrivee);
                       
                        //Cercle inférieur
                        Obstacles.graphics.drawCircle(630, 630, 570);
                        Obstacles.graphics.endFill();
                       
                        //Cercle supérieur
                        prepareFill();
                        Obstacles.graphics.moveTo(0, 480);
                        var Rayon:int = 640;
                        var CentreX:int = 600;
                        var CentreY:int = 640;
                        for (var i:int = 12; i < 42; i++)
                        {
                                var teta:Number = Math.PI/2 + i * Math.PI / 60 + Math.PI/3;
                                Obstacles.graphics.lineTo(CentreX + Rayon * Math.cos(teta), CentreY + Rayon * Math.sin(teta));
                        }
                        //Obstacles.graphics.lineTo(0, 0);
                        //Obstacles.graphics.lineTo(0, 480);

                }
               
        }
       
}

?package Niveaux
{
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un niveau de jeu. Le curseur est invisible.
         * @author Neamar
         */
        public class Level_4 extends HiddenLevel
        {
                public function Level_4(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(620, 460);
                       
                        super(Depart, Arrivee);
                }
        }
       
}

?package Niveaux
{
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.ui.Mouse;
        import Niveaux.Level;
       
        /**
         * Un niveau de jeu. Curseur visible uniquement par le déplacement des petites bulles, y aller doucement sinon elles s'affolent et cela devient injouable.
         * @author Neamar
         */
        public class Level_5 extends HiddenLevel
        {
                private const NbBilles:int = 10;
                private var Billes:Array = new Array(NbBilles);
                private var Forces:Array = new Array(NbBilles);
               
                public function Level_5(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(20, 15);
                       
                        super(Depart, Arrivee);
                       
                        //Partie du bas
                        Obstacles.graphics.moveTo(600, 480);
                        Obstacles.graphics.lineTo(0, 270);
                        //Obstacles.graphics.lineTo(0, 480);
                        Obstacles.graphics.endFill();
                       
                        //Partie du haut
                        prepareFill();
                        Obstacles.graphics.moveTo(60, 0);
                        Obstacles.graphics.lineTo(640, 200);
                        //Obstacles.graphics.lineTo(640, 0);
                        Obstacles.graphics.endFill();
                       
                        //Triangle de droite, en bas
                        prepareFill();
                        Obstacles.graphics.moveTo(640, 380);
                        Obstacles.graphics.lineTo(150, 270);
                        Obstacles.graphics.lineTo(640, 270);
                        Obstacles.graphics.endFill();
                       
                        //Triangle de gauche, en haut
                        prepareFill();
                        Obstacles.graphics.moveTo(0, 40);
                        Obstacles.graphics.lineTo(520, 220);
                        Obstacles.graphics.lineTo(0, 220);
                        Obstacles.graphics.endFill();
                       
                        for (var i:int = 0; i < NbBilles; i++)
                        {
                                var Bille:Sprite = new Sprite();
                                Bille.graphics.lineStyle(1, 0xFFFFFF * Math.random());
                                Bille.graphics.drawCircle(0, 0, 10 * Math.random() + 2);
                                Bille.x = Depart.x; Bille.y = Depart.y;
                               
                                while (Bille.x == Depart.x || Bille.y == Depart.y)
                                {
                                        Bille.x = Depart.x - 10 + 20 * Math.random();
                                        Bille.y = Depart.y - 10 + 20 * Math.random();
                                }
                                addChild(Bille);
                                Bille.filters = FiltreObstaclesTab;
                                Billes[i]=Bille;
                                Forces[i] = new Point(-10 + 20 * Math.random(), -10 + 20 * Math.random());
                        }
                       
                        CurseurVirtuel = new Point(mouseX, mouseY);
                        addEventListener(Event.ENTER_FRAME, deplacerBille);
                }
                public final override function destroy():void
                {
                        removeEventListener(Event.ENTER_FRAME, deplacerBille);
                        super.destroy();
                }
               
                private final function deplacerBille(e:Event):void
                {
                        for (var i:int = 0; i < NbBilles; i++)
                        {
                                var Force:Point = Forces[i];
                                var Bille:Sprite = Billes[i];
                               
                                var Distance:int = Point.distance(new Point(CurseurVirtuel.x, CurseurVirtuel.y), new Point(Bille.x, Bille.y));
                                var Attraction:Number = Distance/5;
                                var Angle:Number = Math.atan2(CurseurVirtuel.y - Bille.y, CurseurVirtuel.x -Bille.x);
                                Force.x += Attraction * Math.cos(Angle);
                                Force.y += Attraction * Math.sin(Angle);
                                Bille.x += Force.x
                                Bille.y += Force.y;
                        }
                }
        }
       
}

?package Niveaux
{
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un niveau de jeu. Une spirale, il faut rester dans le rond qui rétércit au fur et à mesure.
         * @author Neamar
         */
        public class Level_6 extends HitLevel
        {
                private var Rayon:int;
                private var Angle:Number;
               
                private var Masque:Sprite;
               
                public function Level_6(Depart:Point, Arrivee:Point=null)
                {
                        Rayon = Point.distance(new Point(320, 240), Depart);
                        Angle = Math.atan2(Depart.y - 240, Depart.x - 320);
                       
                        Arrivee = new Point(320,240);
                       
                        super(Depart, Arrivee);
                       
                        Obstacles.graphics.beginFill(Main.OBSTACLE);
                        Obstacles.graphics.drawCircle(0, 0, RAYON_ARRIVEE * 2);
                        deplacement();
                       
                        setChildIndex(Obstacles, 0);

                        addEventListener(Event.ENTER_FRAME, deplacement)
                       
                        DoitEviterObstacles = false;//Indiquer que on doit rester sur obstacles, et pas l'éviter.
                }
               
                public final override function destroy():void
                {
                        removeEventListener(Event.ENTER_FRAME, deplacement);
                        super.destroy();
                }
               
                private function deplacement(e:Event=null):void
                {
                        Obstacles.x = 320 + Rayon * Math.cos(-Math.abs(Angle));
                        Obstacles.y = 240 + Rayon * Math.sin(-Math.abs(Angle));
                       
                        if(Rayon>0)
                                Rayon--;
                               
                        if(Rayon<240)
                                Angle += Math.PI / 150;
                       
                        Obstacles.scaleX = Obstacles.scaleY = Math.max(.3,Rayon / 240);
                }
        }
       
}

?package Niveaux
{
        import flash.display.Bitmap;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.ui.Mouse;
        import Niveaux.Level;
       
        /**
         * Un niveau de jeu. Les mouvements de la souris sont inversés.
         * @author Neamar
         */
        public class Level_7 extends SpecialCursor
        {
                public function Level_7(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(20,20);
                        super(Depart, Arrivee);
                }

                protected final override function majCoordonneesSouris(e:MouseEvent):void
                {
                        //Symétrie par rapport au centre
                        CurseurVirtuel.x = -(e.stageX - 320) + 320;
                        CurseurVirtuel.y = -(e.stageY - 240) + 240;
                       
                        super.majCoordonneesSouris(e);
                }
        }
       
}

?package Niveaux
{
        import flash.display.Bitmap;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.ui.Mouse;
        import Niveaux.Level;
       
        /**
         * Un niveau de jeu. Les mouvements de la souris sont ralentis, il faut passer par l'extérieur du flash pour s'en sortir.
         * @author Neamar
         */
        public class Level_8 extends SpecialCursor
        {
                private var DernierePositionSouris:Point = new Point();
                private const RALENTISSEUR:int = 4;
               
                public function Level_8(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(620,460);
                        super(Depart, Arrivee);
                }

                protected final override function majCoordonneesSouris(e:MouseEvent):void
                {
                        //Ralentir les mvmts souris, et éviter les sauts
                        if (Point.distance(new Point(e.stageX, e.stageY), DernierePositionSouris) < 150)
                        {
                                CurseurVirtuel.x += (e.stageX - DernierePositionSouris.x) / RALENTISSEUR;
                                CurseurVirtuel.y += (e.stageY - DernierePositionSouris.y) / RALENTISSEUR;
                               
                                CurseurVirtuel.x = Math.min(640, Math.max(0, CurseurVirtuel.x));
                                CurseurVirtuel.y = Math.min(480, Math.max(0, CurseurVirtuel.y));
                        }
                       
                        DernierePositionSouris.x = e.stageX;
                        DernierePositionSouris.y = e.stageY;
                       
                        super.majCoordonneesSouris(e);
                }
        }
       
}

?package Niveaux
{
        import flash.display.Bitmap;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.ui.Mouse;
        import Niveaux.Level;
       
        /**
         * Inversion des coordonnées x et y
         * @author Neamar
         */
        public class Level_9 extends SpecialCursor
        {      
                public function Level_9(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(320,30);
                        super(Depart, Arrivee);
                }

                protected final override function majCoordonneesSouris(e:MouseEvent):void
                {
                        //Inverser X et Y
                        CurseurVirtuel.x = 640/480 *e.stageY;
                        CurseurVirtuel.y = 480/640 *e.stageX;
                       
                        super.majCoordonneesSouris(e);
                }
        }
       
}

?package Niveaux
{
        import flash.display.Bitmap;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.ui.Mouse;
        import Niveaux.Level;
       
        /**
         * Éviter les cercles qui poppent un peu partout.
         * @author Neamar
         */
        public class Level_10 extends HitLevel
        {      
                private var NbIteration:int = 0;
               
                public function Level_10(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(320, 440);
                       
                        super(Depart, Arrivee);
                       
                        addEventListener(Event.ENTER_FRAME, deplacerObstacles);
                       
                        addEventListener(MouseEvent.MOUSE_OUT, SortieSouris);
                       
                        Obstacles.graphics.moveTo(50, 240);
                        Obstacles.graphics.lineTo(590, 240);
                       
                        Obstacles.addChild(new Cercle(25, 240));
                        Obstacles.addChild(new Cercle(615, 240));

                }

                public final override function destroy():void
                {
                        removeEventListener(MouseEvent.MOUSE_OUT, SortieSouris);
                        removeEventListener(Event.ENTER_FRAME, deplacerObstacles);
                       
                        for (var i:int = 0; i < Obstacles.numChildren; i++)
                        {
                                (Obstacles.getChildAt(i) as Cercle).destroy();
                        }
                        super.destroy();
                }
               
                private final function deplacerObstacles(e:Event):void
                {
                        NbIteration++;
                       
                        if (NbIteration % 5 ==0)
                                Obstacles.addChild(new Cercle(640 * Math.random(), 480 * Math.random()));
                               
                        if (NbIteration == 150)
                        {
                                Obstacles.addChild(new Cercle(300, 420));
                                Obstacles.addChild(new Cercle(300, 460));
                                Obstacles.addChild(new Cercle(340, 420));
                                Obstacles.addChild(new Cercle(340, 460));
                        }
                               
                }
               
                private function SortieSouris(e:Event):void
                {
                        dispatchEvent(new Event(LEVEL_PERDU));
                }
        }
}

//Classe Helper pour les cercles
import com.greensock.easing.Elastic;
import com.greensock.TweenMax;
import flash.display.Sprite;
import flash.filters.GlowFilter;
import Niveaux.Level;

class Cercle extends Sprite
{
        public function Cercle(x:int, y:int)
        {
                super();
                this.x = x;
                this.y = y;
                this.graphics.lineStyle(3,Main.BORDS_OBSTACLE);
                //this.graphics.beginFill(Main.OBSTACLE);
                this.graphics.drawCircle(0, 0, 20);
                this.graphics.endFill();
                this.scaleX = this.scaleY = 0;
                this.filters = Level.FiltreArriveeTab;
                TweenMax.to(this, 1, { scaleX:.1, scaleY:.1, onComplete:enleverFiltre} );
                TweenMax.to(this, 2, { delay:1, scaleX:2, scaleY:2, ease:Elastic.easeOut } );
                TweenMax.to(this, 2, { delay:3, scaleX:1, scaleY:1 } );
                TweenMax.to(this, 1, { delay:4, alpha:.2, onComplete:destroy } );
        }
       
        public function destroy():void
        {
                this.graphics.clear();
                if(parent!=null)
                        parent.removeChild(this);
        }
       
        private function enleverFiltre():void
        {
                this.filters = null;
        }
}

?package Niveaux
{
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * L'anneau tourne à chaque fois que la souris bouge, d'un angle proportionnel au déplacement. Il faut donc jouer subtil pour profiter de la rotation en entrant dans l'anneau.
         * @author Neamar
         */
        public class Level_11 extends HitLevel
        {
                private var Anneau:Ring;
               
                public function Level_11(Depart:Point, Arrivee:Point=null)
                {
                        Anneau = new Ring(60, 60);
                        Arrivee = new Point(60, 60);
                                               
                        super(Depart, Arrivee);
                       
                        Obstacles.addChild(Anneau);

                }


                public final override function destroy():void
                {
                        Anneau.destroy();
                        super.destroy();
                }
               
                protected final override function majCoordonneesSouris(e:MouseEvent):void
                {
                        super.majCoordonneesSouris(e);
                       
                        Anneau.tournerVersRelatif(Point.distance(DernierPoint, CurseurVirtuel));
                }
        }
       
}

?package Niveaux
{
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * L'angle de l'anneau est égal à la distance de la souris au centre  - 90°.
         * Si on reste à une même distance, l'anneau ne tourne pas.
         * @author Neamar
         */
        public class Level_12 extends HitLevel
        {
                private var Anneau:Ring;
                private var Help:Sprite;
               
                public function Level_12(Depart:Point, Arrivee:Point=null)
                {
                        Anneau = new Ring(640 - 60, 480 - 60);
                        Arrivee = new Point(640 - 60, 480 - 60);
                       
                        Help = new Sprite();
                        addChild(Help);
                        super(Depart, Arrivee);
                       
                        Obstacles.addChild(Anneau);
                }


                public final override function destroy():void
                {
                        removeChild(Help);
                        Help.graphics.clear();
                        Help = null;
                        Anneau.destroy();
                        super.destroy();
                }
               
                protected final override function majCoordonneesSouris(e:MouseEvent):void
                {                      
                        super.majCoordonneesSouris(e);
                       
                        Anneau.tournerVers(- 90 + Point.distance(new Point(320, 240), CurseurVirtuel));
                       
                        Help.graphics.clear();
                        Help.graphics.lineStyle(1, 0xCCDDCC);
                        Help.graphics.moveTo(320, 240);
                        Help.graphics.lineTo(CurseurVirtuel.x, CurseurVirtuel.y);
                }
        }
       
}

?package Niveaux
{
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Des anneaux qui tournent sans changer de taille.
         * @author Neamar
         */
        public class Level_13 extends HitLevel
        {
                private var Anneaux:Array = new Array();
                private const NB_ANNEAUX:int = 5;
               
                public function Level_13(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(320,240);
                       
                        super(Depart, Arrivee);
                       
                        for (var i:int = 0; i < NB_ANNEAUX; i++)
                        {
                                var Anneau:Ring = new Ring(320, 240, 50 +  200 * (i / NB_ANNEAUX));
                                Anneau.rotation = 360 * (i / NB_ANNEAUX);
                                Obstacles.addChild(Anneau);
                                Anneaux.push(Anneau);
                        }
                       
                        addEventListener(Event.ENTER_FRAME, rotationAnneaux)
                }


                public final override function destroy():void
                {
                        removeEventListener(Event.ENTER_FRAME, rotationAnneaux);
                        for each(var Anneau:Ring in Anneaux)
                                Anneau.destroy();
                        super.destroy();
                }
               
                protected final function rotationAnneaux(e:Event):void
                {                      
                        for (var i:int = 0; i < NB_ANNEAUX; i++)
                        {
                                (Anneaux[i] as Ring).tournerVersRelatif(2 * Math.pow( -1, i));
                        }
                }
        }
       
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.display.Sprite;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un "nuage" qui dissimule l'arrivée. Il faut la chercher à tâtons !
         * @author Neamar
         */
        public class Level_14 extends Level
        {
                public var Nuage:Sprite;
                public function Level_14(Depart:Point,Arrivee:Point=null)
                {
                        Arrivee = new Point(610, 240);
                        super(Depart, Arrivee);
                       
                        Nuage = new Sprite();
                        Nuage.graphics.lineStyle(1,0xAAAAAA);
                        Nuage.graphics.beginFill(0xFFFFFF);
                        Nuage.graphics.drawRect(0, 0, 640, 480);
                        addChild(Nuage);
                        swapChildren(Nuage, this.Depart);
                        setChildIndex(this.Arrivee, 0);
                       
                        this.Arrivee.alpha = 0;
                        TweenMax.to(this.Arrivee, 1, { delay:2, alpha:1 });
                }
               
                protected final override function deplacementSouris(e:MouseEvent):void
                {
                        super.deplacementSouris(e);
                }
        }
}

?package Niveaux
{
        import flash.display.Bitmap;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import flash.ui.Mouse;
        import Niveaux.Level;
       
        /**
         * Une sorte de vent repousse en permanence la souris vers la droite, il faut faire plusieurs tours à l'exétrieur du jeu pour s'en sortir.
         * @author Neamar
         */
        public class Level_15 extends SpecialCursor
        {
                private var DernierePositionX:int;
               
                private var AngleArrivee:Number=0;
               
                public function Level_15(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(20,240);
                        super(Depart, Arrivee);
                       
                        DernierePositionX = CurseurVirtuel.x = mouseX;
                        addEventListener(Event.ENTER_FRAME, decalerCurseur);
                }
               
                public final override function destroy():void
                {
                        removeEventListener(Event.ENTER_FRAME, decalerCurseur);
                        super.destroy();
                }
               
                private function decalerCurseur(e:Event):void
                {
               
                        CurseurVirtuel.x += 7*(640 - CurseurVirtuel.x)/640;
                       
                        Souris.x = CurseurVirtuel.x;
                       
                        AngleArrivee = (AngleArrivee + Math.PI / 40) % (2*Math.PI);
                        Arrivee.y = 240 + 200 * Math.sin(AngleArrivee);
                }

               
                protected final override function majCoordonneesSouris(e:MouseEvent):void
                {
                        if (Math.abs(DernierePositionX - e.stageX) < 50)
                                CurseurVirtuel.x -= (DernierePositionX - e.stageX);
                               
                        CurseurVirtuel.x = Math.max(0, CurseurVirtuel.x);
                        CurseurVirtuel.y = e.stageY;
                       
                        DernierePositionX = e.stageX;
                       
                        super.majCoordonneesSouris(e);
                }
        }
       
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.display.Sprite;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Une boussole indique la direction du prochain checkpoint par rapport à la psition souris.
         * Il faut valider tous les checkpoints pour s'en sortir.
         * @author Neamar
         */
        public class Level_16 extends Level
        {
                private var Points:Array = new Array(
                        new Point(20, 240),
                        new Point(160, 120),
                        new Point(20, 60),
                        new Point(620, 60),
                        new Point(640 - 160, 120),
                        new Point(620, 240),
                        new Point(320, 120),
                        new Point(320, 360),
                        new Point(20, 420),
                        new Point(320, 240));
                       
                private var IndexObjectif:int = 1;
               
                private var Boussole:Sprite = new Sprite();
               
                private var CheckPoint:Sprite = new Sprite();
               
                public function Level_16(Depart:Point,Arrivee:Point=null)
                {
                        Arrivee = new Point(800, 240);
                       
                        super(Depart, Arrivee);
                       
                        this.Arrivee.visible = false;
                       
                        Boussole.graphics.lineStyle(2, 0xAA0000);
                        Boussole.graphics.moveTo(0, 0);
                        Boussole.graphics.lineTo(50, 0);
                        Boussole.graphics.moveTo(0, -10);
                        Boussole.graphics.lineTo(0, 10);
                       
                        Boussole.graphics.lineStyle(1, 0xBBBBBB);
                        Boussole.graphics.drawCircle(0, 0, 50);
                       
                        CheckPoint.graphics.lineStyle(2, 0xAAFF55);
                        CheckPoint.graphics.drawCircle(0, 0, 3);
                       
                        Boussole.x = 320;
                        Boussole.y = 240;
                        addChild(Boussole);
                       
                        CheckPoint.x = Points[0].x;
                        CheckPoint.y = Points[0].y;
                        addChild(CheckPoint);
                }
               
                public final override function destroy():void
                {
                        Boussole = null;
                        CheckPoint = null;
                       
                        super.destroy();
                }
               
                protected final override function deplacementSouris(e:MouseEvent):void
                {
                        var Obj:Point = Points[Math.min(Points.length-1,IndexObjectif)];
                       
                        TweenMax.to(Boussole, .5, {rotation: 360 * Math.atan2(Obj.y - e.stageY, Obj.x - e.stageX) / (2 * Math.PI)});
                       
                        super.deplacementSouris(e);
                       
                        if (Point.distance(Obj, CurseurVirtuel) < 10)
                        {
                                TweenMax.to(CheckPoint, 1.5, { x:Obj.x, y:Obj.y } );
                                IndexObjectif++;
                               
                                if (IndexObjectif == Points.length - 1)
                                {
                                        Arrivee.visible = true;
                                        Arrivee.alpha = 0;
                                        TweenMax.to(Arrivee, 2, { x:320, alpha:1 } );
                                        TweenMax.to(Boussole, 2, { alpha:0 } );
                                        TweenMax.to(CheckPoint, 2, {alpha:0 } );
                                }
                        }
                               
                        CheckPoint.filters = FiltreArriveeTab;
                }
        }
       
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Des anneaux qui tournent et se réduisent.
         * @author Neamar
         */
        public class Level_17 extends HitLevel
        {
                private var Anneaux:Array = new Array();
               
                private var FrameID:int = 0;
               
                public function Level_17(Depart:Point,Arrivee:Point=null)
                {
                        Arrivee = new Point(30,30);
                        super(Depart, Arrivee);
                       
                        for (var i:int = 2; i <= 5; i++)
                        {
                                var Anneau:Ring = new Ring(0, 0, 100*i);
                                Anneau.x = 320;
                                Anneau.y = 240;
                                Obstacles.addChild(Anneau);
                                TweenMax.to(Anneau, 2*i, { scaleX:0, scaleY:0, rotation:360*Math.random(), onComplete:enleverAnneau } );
                                Anneaux.push(Anneau)
                        }
                       
                        addEventListener(Event.ENTER_FRAME, ajouterAnneau);
                }
               
                public final override function destroy():void
                {
                        removeEventListener(Event.ENTER_FRAME, ajouterAnneau);
                        for each(var Anneau:Ring in Anneaux)
                                Anneau.destroy();
                        super.destroy();
                }
               
                public function ajouterAnneau(e:Event):void
                {
                        if (FrameID % 20 == 0)
                        {
                                var Anneau:Ring = new Ring(0, 0, 600);
                                Anneau.x = 320;
                                Anneau.y = 240;
                                Obstacles.addChild(Anneau);
                                TweenMax.to(Anneau, 12, { scaleX:0, scaleY:0, shortRotation:{rotation:360*Math.random()}, onComplete:enleverAnneau } );
                                Anneaux.push(Anneau);
                        }
                       
                        FrameID++;
                }
               
                private function enleverAnneau():void
                {
                        (Anneaux.shift() as Ring).destroy();
                }
        }
       
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.events.MouseEvent;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * L'arrivée apparait toute seule après quelques secondes
         * @author Neamar
         */
        public class Level_18 extends Level
        {
                public function Level_18(Depart:Point,Arrivee:Point=null)
                {
                        Arrivee = new Point(620, 460);
                        super(Depart, Arrivee);
                       
                        this.Arrivee.visible = false;
                        this.Arrivee.alpha = 0;
                        TweenMax.to(this.Arrivee, 1, { delay:5, onStart:afficherArrivee, alpha:1 } );
                }
               
                private function afficherArrivee():void
                {
                        Arrivee.visible = true;
                }
        }
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.display.Bitmap;
        import flash.display.DisplayObject;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.filters.BevelFilter;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Un labyrinthe qui tourne
         * @author Neamar
         */
        public class Level_19 extends LabyLevel
        {
                public function Level_19(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(320, 240);
                        super(Depart,Arrivee);
                       
                        this.Arrivee.scaleX = this.Arrivee.scaleY = .5;
                }
               
        }
       
}

?package Niveaux
{
        import com.greensock.TweenMax;
        import flash.display.Bitmap;
        import flash.display.DisplayObject;
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.MouseEvent;
        import flash.filters.BevelFilter;
        import flash.geom.Point;
        import Niveaux.Level;
       
        /**
         * Le même labyrinthe que dans le niveau précédent, mais dans une partie de un deux trois soleil.
         * Chaque fois que le soleil apparait, il faut arrêter de bouger la souris.
         * @author Neamar
         */
        public class Level_20 extends LabyLevel
        {              
                [Embed(source="../../assets/Sun.svg")]
                public static var Sun:Class;
               
                private static var Duree:int = 1;
               
                private var Un:Sprite = new Sprite();
                private var Deux:Sprite = new Sprite();
                private var Trois:Sprite = new Sprite();
                private var Soleil:Sprite = new Sprite();
               
                public function Level_20(Depart:Point, Arrivee:Point=null)
                {
                        Arrivee = new Point(620, 20);
                        super(Depart, Arrivee);
                       
                        Un.graphics.lineStyle(3, Main.BORDS_OBSTACLE);
                        Un.graphics.beginFill(Main.LEVEL_PERDU);
                        Un.graphics.drawCircle(0, 0, 15);
                        Un.filters = FiltreArriveeTab;
                       
                        Deux.graphics.lineStyle(3, Main.BORDS_OBSTACLE);
                        Deux.graphics.beginFill(Main.LEVEL_PERDU);
                        Deux.graphics.drawCircle(-22, 0, 15);
                        Deux.graphics.drawCircle(22, 0, 15);
                        Deux.filters = FiltreArriveeTab;
                                               
                        Trois.graphics.lineStyle(3, Main.BORDS_OBSTACLE);
                        Trois.graphics.beginFill(Main.LEVEL_PERDU);
                        Trois.graphics.drawCircle(0, 0, 15);
                        Trois.graphics.drawCircle(-45, 0, 15);
                        Trois.graphics.drawCircle(45, 0, 15);
                        Trois.filters = FiltreArriveeTab;
                       
                        var ContenuSoleil:DisplayObject = new Sun();
                        ContenuSoleil.x = -ContenuSoleil.width / 2;
                        ContenuSoleil.y = -ContenuSoleil.height / 2;
                        Soleil.addChild(ContenuSoleil);
                        Soleil.filters = FiltreArriveeTab;
                       
                        //Lancer le jeu
                        soleil_un();
                }
       
                public final override function destroy():void
                {
                        TweenMax.killTweensOf(Un);
                        TweenMax.killTweensOf(Deux);
                        TweenMax.killTweensOf(Trois);
                        TweenMax.killTweensOf(Soleil);
                        removeEventListener(MouseEvent.MOUSE_MOVE, perdu_soleil);
                        Soleil.removeChild(Soleil.getChildAt(0));
                        Soleil = Un = Deux = Trois = null;
                        super.destroy();
                }
               
               
                private function soleil_un():void
                {
                        TweenMax.resumeAll();
                        removeEventListener(MouseEvent.MOUSE_MOVE, perdu_soleil);
                        deplacement(Un,Soleil,soleil_deux);
                }
               
               
                private function soleil_deux():void
                {
                        deplacement(Deux,Un,soleil_trois);
                }

                private function soleil_trois():void
                {
                        deplacement(Trois,Deux,soleil_soleil);
                }

                private function soleil_soleil():void
                {
                        addEventListener(MouseEvent.MOUSE_MOVE, perdu_soleil);
                        TweenMax.pauseAll();
                        deplacement(Soleil,Trois,soleil_un,2.5);
                }
               
                private function deplacement(Obj:Sprite, Ancien:Sprite,onComplete:Function,scaleIntermediaire:Number=.5):void
                {
                        if (contains(Ancien))
                                removeChild(Ancien);
                               
                        addChild(Obj);
                        Obj.y = 240;
                        Obj.x = -Obj.width;
                        TweenMax.to(Obj,Duree,{x:320,scaleX:scaleIntermediaire,scaleY:scaleIntermediaire});
                        TweenMax.to(Obj,Duree,{delay:Duree+1,x:640+Obj.width,scaleX:1,scaleY:1, onComplete:onComplete});
                }
               
                private function perdu_soleil(e:Event):void
                {
                        dispatchEvent(new Event(LEVEL_PERDU));
                }
        }      
}