SPLIT FROG

/************************
IMPORTS
************************/
import dimArray;
import item;
import flash.net.SharedObject;
stop();

/************************
INITS
************************/
indication.visible = false;
//script principal d'éxécution
var grille:dimArray = new dimArray (5,5);
//nombre d'image 
var nbImage:int = grille.length - grille.colonne;
//création d'un objet item
var myItem:item;
//variable utile pour le menu
var myItemPreview:Sprite = new Sprite();
var score:int = 0;
var nbLife:int = 3;
var timer:int = 90000;
var lifeStartTime:int;
var lifeTimeTo:int;
var interval:int = 1000;
var prevtime:int;
//var de controle d'animation
var isMoving:Boolean = false;
//tableau d'item contenant les images
var itemList:Array = new Array ();
//dimension d'une case
var caseHeight:Number = 100;
var caseWidth:Number = 100;
//variable de limite
var maxLine:int = grille.ligne;
var maxRow:int = grille.colonne;
//point de départ de la découpe
var ptX:Number = 0;
var ptY:Number = 0;
//variable de parcours
var line:int = 1;
var row:int = 0;
//point d'origine de la grille
var xGridOrigin:Number = 64;
var yGridOrigin:Number = 56;
//point maximun de la grille
var xGridMax:Number = xGridOrigin + (maxLine-1)*caseWidth;
var yGridMax:Number = yGridOrigin + (maxRow-1)*caseHeight;
//position du curseur dans le tableau
var curseurLine:int = 0;
var curseurRow:int = 0;
//variable de destination de l'item
var dest:int = -1;
//variable pour l'éxectution (doEveryFrame)
var curLine:int;
var curRow:int;
var mypreview:DisplayObject;
var img:Bitmap;
//récupération de l'image dans la bibliothéque en fonction du niveaux
var monImage:*;
// gestion du son
var mus:musique = new musique();
var be:beep = new beep();
//création d'un sharedObject pour le highscore
var mySo:SharedObject;
mySo = SharedObject.getLocal("highScore");
if(mySo.size == 0)
{
	mySo.data.now = new Date().time;
}
switch (level)
{
	case 1 : 
	monImage = new level1(0,0);
	break;
	case 2 : 
	monImage = new level2(0,0);
	break;
	default:
	break;
}
// creation des éléments du jeux
for (var i:int = 0;i<nbImage;i++)
{
	myItem = new item ("image"+i);
	myItemPreview = new Sprite();
	//creation d'un bitmapData
	var myBmpData:BitmapData = new BitmapData(caseWidth, caseHeight , true, 0x0000CC44);
	//création des objet pour la découpe d'image
	var myRect:Rectangle = new Rectangle(ptX, ptY, caseWidth,caseHeight );
	var myPt:Point = new Point(0, 0);
	//découpe de l'image
	myBmpData.copyPixels(monImage, myRect, myPt);
	//creation d&#8217;une enveloppe Bitmap pour le zone de jeu
	var myBmp:Bitmap = new Bitmap (myBmpData);
	//creation d&#8217;une enveloppe Bitmap pour la preview
	var myBmp2:Bitmap = new Bitmap (myBmpData);
	// ajout à l'affichage
	myItem.addChild (myBmp);
	myItemPreview.addChild(myBmp2);
	//chargement du reflet
	var myReflet:reflet = new reflet ();
	//myReflet.cacheAsBitmap();
	myItem.addChild (myReflet);
	itemList.push(myItem);
	//gestion de la zone "menu"
	//ajout de l'image de preview
	myItemPreview.scaleX *= 0.3;
	myItemPreview.scaleY *= 0.3;
	myItemPreview.x = 1+ptX*0.3;
	myItemPreview.y = 1+ptY*0.3;
	myItemPreview.name = myItem.name;
	menu.preview.addChild (myItemPreview);
	//création de la case correspondante
	var caseIn:gridCase = new gridCase(ptX+xGridOrigin,ptY+yGridOrigin+caseHeight,"image"+i);
	grille.addToTab(line,row,caseIn);
	if (ptX == 400)
	{
		ptY += caseHeight;
		row = 0;
		ptX = 0;
		line += 1;
	}
	else
	{
		ptX += caseWidth;
		row += 1;
	}
}
for (i= 0;i < nbLife ; i++)
{
	var iconLife:curseur = new curseur();
	iconLife.x = 0 + i*30;
	iconLife.y = 0;
	iconLife.scaleX = 0.2;
	iconLife.scaleY = 0.2;
	iconLife.name = "life"+i;
	menu.life_count.addChild (iconLife);
}

line = 0;
row = 0;
for (i=0;i<maxRow;i++)
{
	caseIn = new gridCase((i*caseWidth)+xGridOrigin,yGridOrigin,"none"+i);
	grille.addToTab(line,row,caseIn);
	row++;
}
grille.tab[0][0].used = true;
//random sur le tableaux des boites 
var RandomItemList:Array = new Array();
var n:int = itemList.length;
for (i=0;i<n;i++)
{      
	var ind: int  = Math.floor(Math.random() * itemList.length);
	RandomItemList.push(itemList[ind]);
	itemList.splice(ind,1);
}
var nbItemInStock:int = RandomItemList.length;
//nombre d'objet déjà sur la grille
var nbItemOnScreen:int = 0;

var myCurseur:curseur = new curseur();
myCurseur.x = xGridOrigin;
myCurseur.y = yGridOrigin;
myCurseur.name = "curseur";
zone.addChild (myCurseur);
//gestion des entrées clavier
var spaceIsPress:Boolean = false;
//ecouteur sur le clavier
stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);
stage.addEventListener(KeyboardEvent.KEY_UP, keyUpHandler);
addEventListener(Event.ENTER_FRAME, doEveryFrame);
lifeStartTime = getTimer();
//lancement du son
var canalmusique:SoundChannel = mus.play(0,100);
var transformationSon1:SoundTransform = canalmusique.soundTransform;
transformationSon1.volume = .4;
canalmusique.soundTransform = transformationSon1;
//fin script principal d'éxécution



//handler sur les evenements clavier
function keyDownHandler(event:KeyboardEvent):void 
{
	if (event.keyCode == 32)
	{
		spaceIsPress = true;
		if (isMoving == false && nbItemOnScreen<nbItemInStock)
		{
			// positionnement de l'image
			if (myCurseur.x == xGridOrigin && myCurseur.y == yGridOrigin)
			{
				addSquareToStage();
			}
		}
	}
}
function keyUpHandler(event:KeyboardEvent):void 
{
	//espace
	if (event.keyCode == 32)
	{
		spaceIsPress = false;
	}
	//envoyer vers le gauche
	else if (event.keyCode == 37)
	{
		if (spaceIsPress && isMoving == false)
		{
			curseurLine = (myCurseur.y-yGridOrigin)/caseHeight;
			curseurRow = (myCurseur.x-xGridOrigin)/caseWidth;
			myItem = grille.tab[curseurLine][curseurRow].content;
			if (myItem != null)
			{
				dest = itemMoveAviability("line",false,curseurLine,curseurRow);
				if (dest != -1)
				{
					isMoving = true;
					myItem.moveMeTo("x",xGridOrigin+(caseWidth*dest),15);
					myItem.addEventListener(item.FINISH,finishMove);
					grille.tab[curseurLine][curseurRow].content = null;
					grille.tab[curseurLine][curseurRow].used = false;
				}
			}
		}
		else if (myCurseur.x > xGridOrigin)
		{
			myCurseur.x -= caseHeight;
		}
	}
	//envoyer vers le haut
	else if (event.keyCode == 38)
	{
		if (spaceIsPress && isMoving == false)
		{
			curseurLine = (myCurseur.y-yGridOrigin)/caseHeight;
			curseurRow = (myCurseur.x-xGridOrigin)/caseWidth;
			myItem = grille.tab[curseurLine][curseurRow].content;
			if (myItem != null)
			{
				dest = itemMoveAviability("row",false,curseurRow,curseurLine);
				if (dest != -1)
				{
					isMoving = true;
					myItem.moveMeTo("y",yGridOrigin+(caseHeight*dest),15);
					myItem.addEventListener(item.FINISH,finishMove);
					grille.tab[curseurLine][curseurRow].content = null;
					grille.tab[curseurLine][curseurRow].used = false;
				}
			}
		}
		else if (myCurseur.y > yGridOrigin)
		{
			myCurseur.y -= caseHeight;
		}
	}
	//envoyer vers le droite
	else if (event.keyCode == 39)
	{
		if (spaceIsPress && isMoving == false)
		{
			curseurLine = (myCurseur.y-yGridOrigin)/caseHeight;
			curseurRow = (myCurseur.x-xGridOrigin)/caseWidth;
			myItem = grille.tab[curseurLine][curseurRow].content;
			if (myItem != null)
			{
				dest = itemMoveAviability("line",true,curseurLine,curseurRow);
				if (dest != -1)
				{
					isMoving = true;
					myItem.moveMeTo("x",xGridOrigin+(caseWidth*dest),15);
					myItem.addEventListener(item.FINISH,finishMove);
					grille.tab[curseurLine][curseurRow].content = null;
					grille.tab[curseurLine][curseurRow].used = false;
				}
			}
		}
		else if (myCurseur.x < xGridMax)
		{
			myCurseur.x += caseHeight;
		}
	}
	//envoyer vers le bas
	else if (event.keyCode == 40)
	{
		if (spaceIsPress && isMoving == false)
		{
			curseurLine = (myCurseur.y-yGridOrigin)/caseHeight;
			curseurRow = (myCurseur.x-xGridOrigin)/caseWidth;
			myItem = grille.tab[curseurLine][curseurRow].content;
			if (myItem != null)
			{
				dest = itemMoveAviability("row",true,curseurRow,curseurLine);
				if (dest != -1)
				{
					isMoving = true;
					myItem.moveMeTo("y",yGridOrigin+(caseHeight*dest),15);
					myItem.addEventListener(item.FINISH,finishMove);
					grille.tab[curseurLine][curseurRow].content = null;
					grille.tab[curseurLine][curseurRow].used = false;
				}
			}
		}
		else if (myCurseur.y < yGridMax)
		{
			myCurseur.y += caseHeight;
		}
	}
}

function doEveryFrame(event:Event):void
{
	//gestion du timer
	lifeTimeTo = timer - (getTimer() - lifeStartTime);
	menu.time_barre.barre.scaleX = lifeTimeTo/timer;
	if (lifeTimeTo <=0)
	{
		removeEventListener(Event.ENTER_FRAME, doEveryFrame);
		stage.removeEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);
		stage.removeEventListener(KeyboardEvent.KEY_UP, keyUpHandler);
		menu.time_barre.barre.scaleX = 0;
		nbLife --;
		if (nbLife == 0)
		{
			canalmusique.stop();
			zone.removeChild(myCurseur);
			gotoAndStop("lose");
		}
		else
		{
			newLife();
		}
	}
	else if (lifeTimeTo <=10000)
	{
		if (prevtime != 0)
		{
			interval = prevtime - lifeTimeTo;
		}
		var colorInfo:ColorTransform = menu.time_barre.transform.colorTransform;
		colorInfo.color = 0x993300;
    	menu.time_barre.transform.colorTransform = colorInfo;
		if (interval >= 1000)
		{
			prevtime = lifeTimeTo;
			var canalbeep:SoundChannel =  be.play();
			var transformationSon2:SoundTransform = canalbeep.soundTransform;
			transformationSon2.volume = .5;
			canalbeep.soundTransform = transformationSon2;
			interval = 0;
		}
	}
	//gestion de la preview
	curLine = (myCurseur.y-yGridOrigin)/caseHeight;
	curRow = (myCurseur.x-xGridOrigin)/caseWidth;
	if (myItem != null)
	{
		mypreview = menu.preview.getChildByName(myItem.name);
		mypreview.visible = true;
	}
	myItem = grille.tab[curLine][curRow].content;
	if (myItem != null)
	{
		mypreview = menu.preview.getChildByName(myItem.name);
		mypreview.visible = false;
	}
}
//fonction qui gére le passage entre deux vie
function newLife () :void
{
		menu.life_count.removeChild (menu.life_count.getChildByName("life"+nbLife));
		var MyDeathCurseur:curseurDeath= new curseurDeath();
		MyDeathCurseur.stop();
		MyDeathCurseur.x = myCurseur.x;
		MyDeathCurseur.y = myCurseur.y;
		zone.addChild (MyDeathCurseur);
		zone.removeChild(myCurseur);
		MyDeathCurseur.play();
		MyDeathCurseur.addEventListener("finish",gotoNew);
}
//fonction qui ajoute le curseur et décompte la vie
function gotoNew (e:Event):void
{
	myCurseur = new curseur();
	myCurseur.x = xGridOrigin;
	myCurseur.y = yGridOrigin;
	myCurseur.name = "curseur";
	zone.addChild (myCurseur);
	lifeStartTime = getTimer();
	menu.time_barre.barre.scaleX = 1;
	interval = 1000;
	prevtime = 0;
	var colorInfo:ColorTransform = menu.time_barre.transform.colorTransform;
	colorInfo.color = 0xFFFFFF;
    menu.time_barre.transform.colorTransform = colorInfo;
	zone.removeChild(DisplayObject(e.target));
	isMoving = false;
	spaceIsPress = false;
	stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);
	stage.addEventListener(KeyboardEvent.KEY_UP, keyUpHandler);
	addEventListener(Event.ENTER_FRAME, doEveryFrame);
}
//fonction qui gére l'ajout d'element dans le taquin
function addSquareToStage ():void
{
	dest = itemMoveAviability("line",true,0,0);
	if (dest != -1)
	{
		myItem = RandomItemList[nbItemOnScreen];
		myItem.x = caseWidth + xGridOrigin;
		myItem.y = yGridOrigin;
		zone.addChild(myItem);
		isMoving = true;
		myItem.moveMeTo("x",xGridOrigin+(caseWidth*dest),15);
		myItem.addEventListener(item.FINISH,finishMove);
		zone.swapChildren(myCurseur,myItem);
		nbItemOnScreen++;
	}
}
// fonction de fin de déplacement
function finishMove (event:Event)
{
	isMoving = false;
	var itemLine:int =(event.target.y-yGridOrigin)/caseHeight;
	var itemRow:int = (event.target.x-xGridOrigin)/caseWidth;
	grille.tab[itemLine][itemRow].used = true;
	grille.tab[itemLine][itemRow].content = event.target;
	//si puzzle finit (VICTOIRE)
	if (isPuzzleComplete())
	{
		canalmusique.stop();
		removeEventListener(Event.ENTER_FRAME, doEveryFrame);
		stage.removeEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);
		stage.removeEventListener(KeyboardEvent.KEY_UP, keyUpHandler);
		img = new Bitmap (monImage);
		img.x = 65;
		img.y = 157;
		img.alpha = 0;
		img.name = "img";
		addChild(img);
		addEventListener(Event.ENTER_FRAME, imgAff);
	}
}
//fonction qui fait apparaitre l'image à la fin du puzzle
function imgAff (event:Event):void
{
	if (img.alpha < 1)
	{
		img.alpha += 0.05;
		zone.alpha -= 0.05;
	}
	else
	{
		
		stage.addEventListener(KeyboardEvent.KEY_DOWN, finishKey);
		removeChild(zone);
		indication.visible = true;
		score = ((nbLife-1+menu.time_barre.barre.scaleX)*2000);
		if (mySo.data["value"] != null)
		{
			if (score > mySo.data["value"])
			{
				mySo.data["value"] = score;
			}
		}
		else
		{
			mySo.data["value"] = score;
		}
		removeEventListener(Event.ENTER_FRAME, imgAff);
	}
}
//handler sur les evenements clavier aprés réussite
function finishKey(event:KeyboardEvent):void 
{
	if (event.keyCode == 32)
	{
		stage.removeEventListener(KeyboardEvent.KEY_DOWN, finishKey);
		gotoAndStop("win");
	}
}
//fonction qui calcule la destination de la piéce renvoit -1 si impossible
function itemMoveAviability(prop:String,positif:Boolean,propInd,itemPos):int
{
	var posTo:int = -1;
	var j:int;
	if (prop == "line")
	{
		//vers la droite
		if (positif)
		{
			for (j=itemPos+1;j<maxRow;j++)
			{
				if (!grille.tab[propInd][j].used)
				{
					posTo = j;
				}
				else
				{
					break;
				}
			}
			return posTo;
		}
		//vers la gauche
		else
		{
			for (j=itemPos-1;j>=0;j--)
			{
				if (!grille.tab[propInd][j].used)
				{
					posTo = j;
				}
				else
				{
					break;
				}
			}
			return posTo;
		}
	}
	else if (prop == "row")
	{
		//vers le bas
		if (positif)
		{
			for (j=itemPos+1;j<maxLine;j++)
			{
				if (!grille.tab[j][propInd].used)
				{
					posTo = j;
				}
				else
				{
					break;
				}
			}
			return posTo;
		}
		//vers le haut
		else
		{
			for (j=itemPos-1;j>=0;j--)
			{
				if (!grille.tab[j][propInd].used)
				{
					posTo = j;
				}
				else
				{
					break;
				}
			}
			return posTo;
		}
	}
	//propriété non traité
	else
	{
		return posTo;
	}
}
//fonction qui test si l'image est compléte 
function isPuzzleComplete():Boolean
{
	var isComp:Boolean = false; 
	for each ( var ligne:Array in grille.tab )
	{
		for each (var element:gridCase in ligne)
		{
			if(element.content != null)
			{
				if (element.target == element.content.name)
				{
					isComp = true;
				}
				else if (element.target.indexOf("none")==-1 && element.target != element.content.name)
				{ 
					isComp = false;
					return isComp;
				}
			}
			else if (element.content == null && element.target.indexOf("none")==-1)
			{
				isComp = false;
				return isComp;
			}
		}
	}
	return isComp;
}