Rapidité et stratégie : Don't Click

Ce jeu flash a été développé à l'aide de FlashDevelop, un puissant IDE gratuit pour Flash, mais malheureusement non disponible sous Linux.
Le jeu a donc été développé sous un Windows XP virtualisé par VirtualBox OSE (Wine ne fonctionnant pas pour FlashDevelop, ou plutôt : Wine ne supportant pas le framework .NET2.0 nécessaire à l'utilisation de FlashDevelop).

Licence

Ce code est fourni sous une licence CC-By (cf. fin de page).
De plus, il est interdit de recompiler le jeu "tel quel" en supprimant le lien «Plus de jeux», la mention «tel quel» restant à l'appréciation de l'auteur original du code source (copie, plagiat...).

À propos du code

Vous pouvez générer la documentation du code via l'outil asdoc distribué par défaut avec le Flex SDK.

Ressources enchâssées

J'utilise l'excellent TweenMax de Greensock pour la gestion des animations.

Classes de Don't Click

Fichiers de bases :

Main

Code source : Main.as
  • Langage : actionscript3
  • ΔT : 0.090s
  • Taille :5609 caractères
?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/"));
                }
        }
       
}

Anneaux

Code source : Niveaux/Ring.as
  • Langage : actionscript3
  • ΔT : 0.025s
  • Taille :1516 caractères
?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} } );
                }
        }
}

Niveaux

Niveaux spéciaux

Il s'agit des niveaux "mère" dont tous les autres peuvent hériter.

Code source : Niveaux/Level.as
  • Langage : actionscript3
  • ΔT : 0.076s
  • Taille :4748 caractères
?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);
                }
        }
       
}

Tous les niveaux "à obstacle" héritent de HitLevel.

Code source : Niveaux/HitLevel.as
  • Langage : actionscript3
  • ΔT : 0.034s
  • Taille :2930 caractères
?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));
                }
        }
       
}

Tous les niveaux "sans curseur" héritent de HiddenLevel.

Code source : Niveaux/HiddenLevel.as
  • Langage : actionscript3
  • ΔT : 0.011s
  • Taille :763 caractères
?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);
                }
        }

}

Tous les niveaux "à curseur spécial" héritent de SpecialCursor.

Code source : Niveaux/SpecialCursor.as
  • Langage : actionscript3
  • ΔT : 0.023s
  • Taille :990 caractères
?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 !
                }
        }
       
}

Les deux niveaux labyrinthe à la fin héritent de LabyLevel.

Code source : Niveaux/LabyLevel.as
  • Langage : actionscript3
  • ΔT : 0.026s
  • Taille :1161 caractères
?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();
                }
        }
}

Le niveau qui s'affiche quand on perd.

Code source : Niveaux/LevelLost.as
  • Langage : actionscript3
  • ΔT : 0.027s
  • Taille :522 caractères
?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);
                }
        }

}

Liste des niveaux

Code source : Niveaux/Level_1.as
  • Langage : actionscript3
  • ΔT : 0.013s
  • Taille :858 caractères
?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 } );
                }
        }
}
Code source : Niveaux/Level_2.as
  • Langage : actionscript3
  • ΔT : 0.013s
  • Taille :401 caractères
?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);
                }
        }
       
}
Code source : Niveaux/Level_3.as
  • Langage : actionscript3
  • ΔT : 0.034s
  • Taille :999 caractères
?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);

                }
               
        }
       
}
Code source : Niveaux/Level_4.as
  • Langage : actionscript3
  • ΔT : 0.014s
  • Taille :352 caractères
?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);
                }
        }
       
}
Code source : Niveaux/Level_5.as
  • Langage : actionscript3
  • ΔT : 0.089s
  • Taille :2968 caractères
?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;
                        }
                }
        }
       
}
Code source : Niveaux/Level_6.as
  • Langage : actionscript3
  • ΔT : 0.044s
  • Taille :1483 caractères
?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);
                }
        }
       
}
Code source : Niveaux/Level_7.as
  • Langage : actionscript3
  • ΔT : 0.025s
  • Taille :777 caractères
?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);
                }
        }
       
}
Code source : Niveaux/Level_8.as
  • Langage : actionscript3
  • ΔT : 0.029s
  • Taille :1347 caractères
?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);
                }
        }
       
}
Code source : Niveaux/Level_9.as
  • Langage : actionscript3
  • ΔT : 0.013s
  • Taille :723 caractères
?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);
                }
        }
       
}
Code source : Niveaux/Level_10.as
  • Langage : actionscript3
  • ΔT : 0.090s
  • Taille :2773 caractères
?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;
        }
}
Code source : Niveaux/Level_11.as
  • Langage : actionscript3
  • ΔT : 0.022s
  • Taille :962 caractères
?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));
                }
        }
       
}
Code source : Niveaux/Level_12.as
  • Langage : actionscript3
  • ΔT : 0.019s
  • Taille :1300 caractères
?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);
                }
        }
       
}
Code source : Niveaux/Level_13.as
  • Langage : actionscript3
  • ΔT : 0.032s
  • Taille :1247 caractères
?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));
                        }
                }
        }
       
}
Code source : Niveaux/Level_14.as
  • Langage : actionscript3
  • ΔT : 0.016s
  • Taille :953 caractères
?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);
                }
        }
}
Code source : Niveaux/Level_15.as
  • Langage : actionscript3
  • ΔT : 0.024s
  • Taille :1591 caractères
?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);
                }
        }
       
}
Code source : Niveaux/Level_16.as
  • Langage : actionscript3
  • ΔT : 0.063s
  • Taille :2501 caractères
?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;
                }
        }
       
}
Code source : Niveaux/Level_17.as
  • Langage : actionscript3
  • ΔT : 0.058s
  • Taille :1587 caractères
?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();
                }
        }
       
}
Code source : Niveaux/Level_18.as
  • Langage : actionscript3
  • ΔT : 0.022s
  • Taille :653 caractères
?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;
                }
        }
}
Code source : Niveaux/Level_19.as
  • Langage : actionscript3
  • ΔT : 0.009s
  • Taille :589 caractères
?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;
                }
               
        }
       
}
Code source : Niveaux/Level_20.as
  • Langage : actionscript3
  • ΔT : 0.049s
  • Taille :3405 caractères
?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));
                }
        }      
}
Auteur
Neamar
Date
Aout 2008
Voir aussi
Compiler l'AS3
Retour
Retour au jeu
Menu
Index des ressources

Chargement du sommaire...