Rapidité et stratégie : Don't Click

• Langage : actionscript3
• 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/"));

		}

	}

	

}

• Langage : actionscript3
• 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} } );

		}

	}

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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));

		}

	}

	

}

• Langage : actionscript3
• 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);

		}

	}



}

• Langage : actionscript3
• 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 !

		}

	}

	

}

• Langage : actionscript3
• 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();

		}

	}

}

• Langage : actionscript3
• 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);

		}

	}



}

• Langage : actionscript3
• 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 } );

		}

	}

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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);



		}

		

	}

	

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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;

			}

		}

	}

	

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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;

	}

}

• Langage : actionscript3
• 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));

		}

	}

	

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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));

			}

		}

	}

	

}

• Langage : actionscript3
• 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);

		}

	}

}

• Langage : actionscript3
• 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);

		}

	}

	

}

• Langage : actionscript3
• 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;

		}

	}

	

}

• Langage : actionscript3
• 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();

		}

	}

	

}

• Langage : actionscript3
• 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;

		}

	}

}

• Langage : actionscript3
• 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;

		}

		

	}

	

}

• Langage : actionscript3
• 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));

		}

	}	

}