0 Replies - 1622 Views - Last Post: 13 September 2012 - 07:00 AM

#1 skyvergil83  Icon User is offline

  • New D.I.C Head

Reputation: 0
  • View blog
  • Posts: 3
  • Joined: 02-December 10

convert 2d sliding game project to 3d

Posted 13 September 2012 - 07:00 AM

i have a tutorial code which is a 2d sliding puzzle game. Now i trying to convert it in to a 3d sliding puzzle game. i am using papervision3D to do that.

The problem iam facing is that i trying to put my puzzle pieces into a 3D object container(since i searched for the source and many suggest to use displayobject3d to do it). My puzzles piecesare Sprite data type, but i am having problem to put all my puzzle pieces into the displayobject3d container.

Below is my code. Some of you might see this code before, because i get it from the book titled "G._Rosenzweig_ActionScript_3.0_Game_Programming_University-2nd_Ed". i have added a few addition which is the program allow player to choose an image from his local disk, and enter the number of dimension of the puzzle game. But my only concern is to convert it into a 3d sliding puzzle game.

Hope anyone help is kind to help me on this.

package {

	import flash.display.*;
	import flash.events.*;
	import flash.net.URLRequest;
	import flash.geom.*;
	import flash.utils.Timer;
	import flash.utils.getTimer;
	import flash.display.BitmapData;
	import flash.display.StageAlign;
	import flash.display.StageQuality;
	import flash.display.StageScaleMode;
	import flash.net.FileFilter;
	import flash.net.FileReference;
	import flash.display.Loader;
	import flash.display.LoaderInfo;
	import flash.text.*;
	
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.objects.DisplayObject3D;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.view.BasicView;
	import org.papervision3d.materials.BitmapFileMaterial;
	import org.papervision3d.events.FileLoadEvent;
	import org.papervision3d.materials.BitmapAssetMaterial;
	import org.papervision3d.materials.MovieMaterial;
	import org.papervision3d.cameras.Camera3D;
	import flash.media.Camera;
	import away3d.containers.View3D;
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.materials.BitmapMaterial;
	
	public class SlidingPuzzle extends MovieClip {
		// space between pieces and offset
		static const pieceSpace:Number = 2;
		static const horizOffset:Number = 50;
		static const vertOffset:Number = 50;
		
		// number of pieces
	 	private var numPiecesHoriz:int;
		private var numPiecesVert:int;
		
		// random shuffle steps
		static const numShuffle:int = 200;
		
		// animation steps and time
		static const slideSteps:int = 10;
		static const slideTime:int = 250;
		
		// size of pieces
		private var pieceWidth:Number;
		private var pieceHeight:Number;

		// game pieces
		private var puzzleObjects:Array;
		private var selectedImage:String;
		// tracking moves
		private var blankPoint:Point;
		private var slidingPiece:Object;
		private var slideDirection:Point;
		private var slideAnimation:Timer;
		
		private var getRowNumbers:TextField;
		private var getColNumbers:TextField;
		
		private var startTime:uint;
		private var playTime:uint;
		
		private var totalTimeField:TextField;
		
		private var plane1:Plane;
		private var planeContainer:DisplayObject3D = new DisplayObject3D;
		private var camera:Camera3D = new Camera3D();
		private var view:Viewport3D = new Viewport3D();
		private var scene:Scene3D = new Scene3D();
		private var render:BasicRenderEngine = new BasicRenderEngine();
		var planeArray:Array = new Array();
		
		var xDist:Number = mouseX - stage.stageWidth * 0.5;
		var yDist:Number = mouseY - stage.stageHeight * 0.5;
		private var easeOut:Number = 0.3;
		private var reachX:Number = 0.5;
		private var reachY:Number = 0.5;
		private var reachZ:Number = 0.05;
		
		public function startSlidingPuzzle() {
			//stage.scaleMode = StageScaleMode.NO_SCALE;
			//stage.align = StageAlign.TOP_LEFT;
			addChild(view);
			// blank spot is the bottom right
			//blankPoint = new Point(numPiecesHoriz-1,numPiecesVert-1);	
			blankPoint = new Point(numPiecesHoriz-1,numPiecesVert-1);		
			//getDimension();
			loadBitmap();
			setGameTimeField();
			//scene.addChild(plane1);
			//this.addChild(view);
			//render.renderScene(scene, camera, view);
			//this.addEventListener(Event.ENTER_FRAME, render);
		}
		
		public function setGameTimeField():void{
			totalTimeField = new TextField();
			totalTimeField.x = 550;
			
			startTime = getTimer();
			playTime = 0;
			
			addEventListener(Event.ENTER_FRAME, displayTime);
			addChild(totalTimeField);
		}
		
		public function displayTime(event:Event){
			playTime = getTimer()-startTime;
			totalTimeField.text = "Time: " + clockTime(playTime);
		}
		
		public function clockTime(ms:int){
			var second:int = Math.floor(ms/1000);
			var minute:int = Math.floor(second/60);
			var timeString:String = minute + ":" +String(second + 100).substr(1, 2);
			
			return timeString;
		}
		
		// get the bitmap from an external source
		private var loader:FileReference;
		public function loadBitmap() {
			loader = new FileReference();
			loader.addEventListener(Event.SELECT, selectHandler);
			var fileFilter:FileFilter = new FileFilter("Image(*.jpg,*.png,*.gif,*.bmp)", "*.jpg;*.png;*.gif;*.bmp");
			loader.browse([fileFilter]);
		}
		
		private function selectHandler(event:Event):void{
			loader.removeEventListener(Event.SELECT, selectHandler);
			//setDisplayState(PROGRESS);
			loader.addEventListener(Event.COMPLETE, loadingDone);
			loader.load();
		}
		
		// bitmap done loading 
		public function loadingDone(event:Event):void {
			loader.removeEventListener(Event.COMPLETE, loadingDone);
			
			var fileload:Loader = new Loader();
			
			fileload.contentLoaderInfo.addEventListener(Event.COMPLETE, LoadBytesHandler);
			fileload.loadBytes(loader.data);
		}
		//close loadind event and cut bitmap into pieces
		public function LoadBytesHandler(event:Event):void{
			var loadInfo:LoaderInfo = (event.target as LoaderInfo);
			
			var image:Bitmap = loadInfo.content as Bitmap;
			//var i:BitmapData = loadInfo.content as BitmapData;
			//var bitmapMate:BitmapMaterial = new BitmapMaterial(image.bitmapData);
			loadInfo.removeEventListener(Event.COMPLETE, LoadBytesHandler);
			
			//bitmapMate.doubleSided = true;
			//plane1 = new Plane(bitmapMate, 480, 320);
			//scene.addChild(plane1);
			//this.addChild(view);
			//render.renderScene(scene, camera, view);
			
			pieceWidth = image.width/numPiecesHoriz;
			pieceHeight = image.height/numPiecesVert;
			
			// cut into puzzle pieces
			makePuzzlePieces(image.bitmapData);
			
			// shuffle them
			shufflePuzzlePieces();
			
		}
		
		// cut bitmap into pieces
		public function makePuzzlePieces(bitmapData:BitmapData) {
			
			puzzleObjects = new Array();
			for(var x:uint=0;x<numPiecesHoriz;x++) {
				planeArray[x] = new Array();
				for (var y:uint=0;y<numPiecesVert;y++) {
					// skip blank spot
					if (blankPoint.equals(new Point(x,y))) continue;
					
					// create new puzzle piece bitmap and sprite
					var newPuzzlePieceBitmap:Bitmap = new Bitmap(new BitmapData(pieceWidth,pieceHeight));
					newPuzzlePieceBitmap.bitmapData.copyPixels(bitmapData,new Rectangle(x*pieceWidth,y*pieceHeight,pieceWidth,pieceHeight),new Point(0,0));
					var newPuzzlePiece:Sprite = new Sprite();
					newPuzzlePiece.addChild(newPuzzlePieceBitmap);
					addChild(newPuzzlePiece);
					//var b:BitmapData = new BitmapData();
					//b.draw(newPuzzlePiece);
					//var bitmapMate:BitmapMaterial = new BitmapMaterial(B)/>;
					planeContainer.addChild(newPuzzlePiece);
					//addChild(planeContainer);
					
					// set location
					newPuzzlePiece.x = x*(pieceWidth+pieceSpace) + horizOffset;
					newPuzzlePiece.y = y*(pieceHeight+pieceSpace) + vertOffset;
					//
					//
					//plane1 = new Plane(bitmapMate, 350, 350);
					//planeArray[x][y] = new Plane(bitmapMate, 400, 400);
					//planeContainer.addChild(planeArray[x][y]);
					//planeContainer.x= 400;
					//planeContainer.y=400;
					//pcContainer.addChild(planeContainer);
					//scene.addChild(pcContainer);
					
					// create object to store in array
					var newPuzzleObject:Object = new Object();
					newPuzzleObject.currentLoc = new Point(x,y);
					newPuzzleObject.homeLoc = new Point(x,y);
					newPuzzleObject.piece = newPuzzlePiece;
					newPuzzlePiece.addEventListener(MouseEvent.CLICK,clickPuzzlePiece);
					puzzleObjects.push(newPuzzleObject);
					
				}
			}	
			
			scene.addChild(planeContainer);
			//for(var i:uint = 0; i<puzzleObjects; i++){
				//planeArray[i] = new Array();
				//for(var j:uint = 0; j<puzzleObjects; j++){
					//plane1 = new Plane();
					//planes.x = 50 * i + 5;
					//planes.y = -50 *j ;
					//array[i][j] = planes;
					//container.addChild(array[i][j]);
				//}
				
			//}
			//var count:int = 0;
//			var planeArray:Array = new Array();
			//pcContainer.addChild(planeContainer);
//			for(var i:uint=0;i<planeArray.length;i++) {
//				planeArray[i] = new Array();
//				for(var j:uint=0;j<planeArray.length;j++){
//					//planeArray[i][j] = new Plane();
//					planeContainer.addChild(planeArray[i][j]);
//				}
////				count++;
//			}
//			trace(count);
			//plane1 = new Plane();
					//pcContainer.addChild(planeContainer);
					//scene.addChild(pcContainer);
					//this.addChild(view);
					//scene.addChild(plane1);
					//camera.zoom = 200;
					//addEventListener(MouseEvent.MOUSE_OVER, renderGameScene);
					//addEventListener(Event.ENTER_FRAME, loop);
					render.renderScene(scene, camera, view);
		}
		
		public function renderGameScene(e:MouseEvent){
			camera.x += (xDist - camera.x * reachX) * easeOut;
			camera.y += (yDist- camera.y * reachY) * easeOut;
			render.renderScene(scene, camera, view);
		}
		
		// make a number of random moves
		public function shufflePuzzlePieces() {
			for(var i:int=0;i<numShuffle;i++) {
				shuffleRandom();
			}
        }
		
		// random move
		public function shuffleRandom() {
			// loop to find valid moves
			var validPuzzleObjects:Array = new Array();
			for(var i:uint=0;i<puzzleObjects.length;i++) {
				if (validMove(puzzleObjects[i]) != "none") {
					validPuzzleObjects.push(puzzleObjects[i]);
				}
			}
			// pick a random move
			var pick:uint = Math.floor(Math.random()*validPuzzleObjects.length);
			movePiece(validPuzzleObjects[pick],false);
		}

		public function validMove(puzzleObject:Object): String {
			// is the blank spot above
			if ((puzzleObject.currentLoc.x == blankPoint.x) &&
				(puzzleObject.currentLoc.y == blankPoint.y+1)) {
				return "up";
			}
			// is the blank spot below
			if ((puzzleObject.currentLoc.x == blankPoint.x) &&
				(puzzleObject.currentLoc.y == blankPoint.y-1)) {
				return "down";
			}
			// is the blank to the left
			if ((puzzleObject.currentLoc.y == blankPoint.y) &&
				(puzzleObject.currentLoc.x == blankPoint.x+1)) {
				return "left";
			}
			// is the blank to the right
			if ((puzzleObject.currentLoc.y == blankPoint.y) &&
				(puzzleObject.currentLoc.x == blankPoint.x-1)) {
				return "right";
			}
			// no valid moves
			return "none";
		}
		
		// puzzle piece clicked
		public function clickPuzzlePiece(event:MouseEvent) {
			// find piece clicked and move it
			for(var i:int=0;i<puzzleObjects.length;i++) {
				if (puzzleObjects[i].piece == event.currentTarget) {
					movePiece(puzzleObjects[i],true);
					break;
				}
			}
		}
		
		// move a piece into the blank space
		public function movePiece(puzzleObject:Object, slideEffect:Boolean) {
			// get direction of blank space
			switch (validMove(puzzleObject)) {
				case "up":
					movePieceInDirection(puzzleObject,0,-1,slideEffect);
					break;
				case "down":
					movePieceInDirection(puzzleObject,0,1,slideEffect);
					break;
				case "left":
					movePieceInDirection(puzzleObject,-1,0,slideEffect);
					break;
				case "right":
					movePieceInDirection(puzzleObject,1,0,slideEffect);
					break;
			}
		}
		
		// move the piece into the blank spot
		public function movePieceInDirection(puzzleObject:Object, dx,dy:int, slideEffect:Boolean) {
			puzzleObject.currentLoc.x += dx;
			puzzleObject.currentLoc.y += dy;
			blankPoint.x -= dx;
			blankPoint.y -= dy;
			
			// animate or not
			if (slideEffect) {
				// start animation
				startSlide(puzzleObject,dx*(pieceWidth+pieceSpace),dy*(pieceHeight+pieceSpace));
			} else {
				// no animation, just move
				puzzleObject.piece.x = puzzleObject.currentLoc.x*(pieceWidth+pieceSpace) + horizOffset;
				puzzleObject.piece.y = puzzleObject.currentLoc.y*(pieceHeight+pieceSpace) + vertOffset;
			}
		}
		
		// set up a slide
		public function startSlide(puzzleObject:Object, dx, dy:Number) {
			if (slideAnimation != null) slideDone(null);
			slidingPiece = puzzleObject;
			slideDirection = new Point(dx,dy);
			slideAnimation = new Timer(slideTime/slideSteps,slideSteps);
			slideAnimation.addEventListener(TimerEvent.TIMER,slidePiece);
			slideAnimation.addEventListener(TimerEvent.TIMER_COMPLETE,slideDone);
			slideAnimation.start();
		}
		
		// move one step in slide
		public function slidePiece(event:Event) {
			slidingPiece.piece.x += slideDirection.x/slideSteps;
			slidingPiece.piece.y += slideDirection.y/slideSteps;
		}
		
		// complete slide
		public function slideDone(event:Event) {
			slidingPiece.piece.x = slidingPiece.currentLoc.x*(pieceWidth+pieceSpace) + horizOffset;
			slidingPiece.piece.y = slidingPiece.currentLoc.y*(pieceHeight+pieceSpace) + vertOffset;
			slideAnimation.stop();
			slideAnimation = null;
			
			// check to see if puzzle is complete now
			if (puzzleComplete()) {
				clearPuzzle();
				MovieClip(root).gotoAndStop("gameover");
			}
		}
		
		// check to see if all pieces are in place
		public function puzzleComplete():Boolean {
			for(var i:int=0;i<puzzleObjects.length;i++) {
				if (!puzzleObjects[i].currentLoc.equals(puzzleObjects[i].homeLoc)) {
					return false;
				}
			}
			return true;
		}
		
		// remove all puzzle pieces
		public function clearPuzzle() {
			for (var i in puzzleObjects) {
				puzzleObjects[i].piece.removeEventListener(MouseEvent.CLICK,clickPuzzlePiece);
				removeChild(puzzleObjects[i].piece);
			}
			puzzleObjects = null;
		}
		
	}
}



Well, it's kinda messy and i apologize for that.... it is not complete yet...

Is This A Good Question/Topic? 0
  • +

Page 1 of 1