//Game display piece size+spacing
side = 20;
space = 2;
//Game controls
CONTROL = {};
CONTROL.LEFT = Key.LEFT;
CONTROL.RIGHT = Key.RIGHT;
CONTROL.DOWN = Key.DOWN;
CONTROL.ROTCW = Key.UP;
CONTROL.ROTCCW = Key.CONTROL;
CONTROL.DROP = new String('Q').charCodeAt(0);
CONTROL.PAUSE = new String('W').charCodeAt(0);
CONTROL.NEWGAME = new String(' ').charCodeAt(0);
//Stage setup
Stage.scaleMode = 'noScale';
Stage.align = 'TL';
//Clip setup
this.createEmptyMovieClip('board_mc', 0);
this.createEmptyMovieClip('queue_mc', 1);
this.createEmptyMovieClip('dP', 2);
//Create/format fields
this.createTextField('info_txt', 5, 0, 0, 100, 100);
info_txt.html = true;
info_txt.multiline = true;
info_txt.wordWrap = false;
this.createTextField('ctrls_txt', 7, 0, 120, 200, 500);
ctrls_txt.html = true;
ctrls_txt.htmlText = '<B>CONTROLS</B>\nLEFT:    LEFT ARROW\nRIGHT:   RIGHT ARROW\nDOWN:    DOWN ARROW\nROT CW:  UP ARROW\nROT CCW: CONTROL\nDROP:    Q\nPAUSE:   W\nNEWGAME: SPACE';
ctrls_txt.setTextFormat(new TextFormat('_typewriter'));
this.createTextField('disp_txt', 6, (Stage.width-100)/2, (Stage.height-20)/2, 100, 20);
disp_txt.border = true;
disp_txt.autoSize = 'left';
disp_txt.backgroundColor = 0xCCCCCC;
disp_txt.selectable = false;
disp_txt.background = true;
//Center all on Stage resize
this.onResize = function() {
	disp_txt._x = (Stage.width-disp_txt._width)/2;
	disp_txt._y = (Stage.height-disp_txt._height)/2;
	board_mc._x = (Stage.width-board_mc._width)/2;
	board_mc._y = (Stage.height-board_mc._height)/2;
	queue_mc._x = board_mc._x+board_mc._width+20;
	queue_mc._y = board_mc._y;
	dP._x = board_mc._x+gridC(dP.gX);
	dP._y = board_mc._y+gridC(dP.gY);
};
Stage.addListener(this);
//Center when display text changes
disp_txt.addProperty('texts', function () {
	return this.text;
}, function (t) {
	this.text = t;
	onResize();
});
//=======================================================================
//Array of Tetris Pieces
var p, q;
p = pieces=[];
//I piece
q = p[0]=dim(5, 5, 0);
q[2][1] = q[2][2]=q[2][3]=q[2][4]=0x00FFFF;
//Z piece
q = p[1]=dim(3, 3, 0);
q[0][0] = q[0][1]=q[1][1]=q[1][2]=0xFF0000;
//S piece
q = p[2]=dim(3, 3, 0);
q[1][0] = q[1][1]=q[0][1]=q[0][2]=0x00FF00;
//J piece
q = p[3]=dim(3, 3, 0);
q[0][0] = q[1][0]=q[1][1]=q[1][2]=0x0000FF;
//L piece
q = p[4]=dim(3, 3, 0);
q[0][2] = q[1][0]=q[1][1]=q[1][2]=0xFF9900;
//O piece
q = p[5]=dim(2, 2, 0xFFFF00);
//T piece
q = p[6]=dim(3, 3, 0);
q[0][1] = q[1][0]=q[1][1]=q[1][2]=0xCC66CC;
//Created 2D Array with default values of 'c'
function dim(x, y, c) {
	var row = [];
	for (var X = 0; X<x; X++) {
		row[X] = c;
	}
	var grid = [];
	for (var Y = 0; Y<y; Y++) {
		grid[Y] = row.slice();
	}
	return grid;
}
//Rotate 2D array, dir:CW=1,CCW=-1
function rot(q, dir) {
	var oX, oY, nx, nY, m, n;
	var d = (q.length-1)/2;
	for (var y = 0; y<d; y++) {
		for (var x = 0; x<=d; x++) {
			nX = x;
			nY = y;
			n = q[nX][nY];
			for (var r = 0; r<4; r++) {
				oX = nX;
				oY = nY;
				nX = dir*(oY-d)+d;
				nY = -dir*(oX-d)+d;
				m = n;
				n = q[nX][nY];
				q[nX][nY] = m;
			}
		}
	}
	return q;
}
//Duplicate Array
function dup(q) {
	var t = [];
	for (var y in q) {
		t[y] = q[y].slice();
	}
	return t;
}
//=====================================================================
//Draw a unit square
MovieClip.prototype.drawSquare = function(x:Number, y:Number, color:Color):Void  {
	with (this) {
		lineStyle(1, 0);
		beginFill(color, 100);
		moveTo(x, y);
		lineTo(x+side, y);
		lineTo(x+side, y+side);
		lineTo(x, y+side);
		lineTo(x, y);
		endFill();
	}
};
//Draw a piece on a MovieClip
MovieClip.prototype.drawPiece = function(cP_arr) {
	with (this) {
		clear();
		for (var y = 0; y<cP_arr.length; y++) {
			for (var x = 0; x<cP_arr[y].length; x++) {
				if (cP_arr[y][x]) {
					this.drawSquare(x*(side+space), y*(side+space), cP_arr[y][x]);
				}
			}
		}
	}
};
//=========================================================================
//Redraws the board_mc
function redrawBoard() {
	board_mc.clear();
	for (var y = 0; y<board.length; y++) {
		for (var x = 0; x<board[y].length; x++) {
			board_mc.drawSquare(x*(side+space), y*(side+space), board[y][x]);
		}
	}
}
//Check for completion of row, handle assoc. scoring, remove row
function checkForComplete() {
	var i = 0;
	for (var y = 0; y<board.length; y++) {
		if (String(','+board[y].join(',')+',').indexOf(',0,') == -1) {
			i++;
			if (++info.lines == 10) {
				info.level++;
				info.lines = 0;
			}
			board.splice(y, 1);
			board.unshift([0xCCCCCC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xCCCCCC]);
		}
	}
	info.score += i*i*100;
	if (i) {
		redrawBoard();
	}
}
//===========================================================================
//Drop new piece from top
function nextPiece() {
	checkForComplete();
	var p = queue_mc.pull();
	dP.piece = dup(pieces[p]);
	dP.drawPiece(dP.piece);
	var c = (dP.piece.length-1)/2;
	dP.gX = 5-Math.floor(c);
	dP.gY = 0-Math.ceil(c);
	dP._x = board_mc._x+gridC(dP.gX);
	dP._y = board_mc._y+gridC(dP.gY);
	//When piece is initially dropped, and piece has already hit, gameover.
	if (!checkForNoHit(dP.piece, dP.gX, dP.gY)) {
		mode = 'lose';
		disp_txt.texts = 'G A M E O V E R';
		disp_txt._visible = true;
	}
}
//Convert grid pos. to pixel pos.
function gridC(c) {
	return c*(space+side);
}
//Piece falls one square per interval
function gameplay() {
	if (mode == 'game') {
		if (dP.noHit(CONTROL.DOWN)) {
			//If can move down, move down
			dP._y += (space+side);
			dP.gY += 1;
			stopTry();
		} else {
			//Otherwise, intiate countdown for next drop
			tryNext();
		}
	}
	updateAfterEvent();
}
//Check if desired action is allowable
dP.noHit = function(d) {
	var t = dup(this.piece);
	var gX = dP.gX;
	var gY = dP.gY;
	if (d == CONTROL.ROTCW) {
		rot(t, 1);
	} else if (d == CONTROL.ROTCCW) {
		rot(t, -1);
	} else if (d == CONTROL.LEFT) {
		gX -= 1;
	} else if (d == CONTROL.RIGHT) {
		gX += 1;
	} else if (d == CONTROL.DOWN) {
		gY += 1;
	}
	return checkForNoHit(t, gX, gY);
};
//Check if a piece with given position hits the board
function checkForNoHit(t, gX, gY) {
	board[-1] = [0xCCCCCC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xCCCCCC];
	for (var y = 0; y<t.length; y++) {
		for (var x = 0; x<t[y].length; x++) {
			if (t[y][x] && board[y+gY][x+gX]) {
				return false;
			}
		}
	}
	return true;
}
//Controls that only occur on key press
function onceActionKeys() {
	//New game
	if (mode != 'paused') {
		if (Key.isDown(CONTROL.NEWGAME)) {
			if (!flagNEWGAME) {
				resetAll();
			}
			flagNEWGAME = true;
		} else {
			flagNEWGAME = false;
		}
	}
	//Pause  
	if (Key.isDown(CONTROL.PAUSE)) {
		if (!flagPAUSE) {
			if (mode == 'game') {
				mode = 'paused';
				disp_txt.texts = 'P A U S E D';
				disp_txt._visible = true;
				//end drop if already touching
				if (nextID) {
					stopTry();
					nextF();
				}
				//Memorize board  
				board2 = dup(board);
				//Hide all
				board = dim(12, 20, 0);
				for (var y = 0; y<board.length-1; y++) {
					board[y][0] = board[y][board[y].length-1]=0xCCCCCC;
				}
				for (var x = 1; x<board[board.length-1].length-1; x++) {
					board[board.length-1][x] = 0xCCCCCC;
				}
				board[-1] = [0xCCCCCC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xCCCCCC];
				redrawBoard();
				dP._visible = false;
				queue_mc._visible = false;
			} else if (mode == 'paused') {
				mode = 'game';
				//show all
				board = board2;
				redrawBoard();
				disp_txt.texts = '';
				disp_txt._visible = false;
				dP._visible = true;
				queue_mc._visible = true;
			}
			flagPAUSE = true;
		}
	} else {
		flagPAUSE = false;
	}
	if (mode == 'game') {
		//Hard Drop
		if (Key.isDown(CONTROL.DROP)) {
			if (!flagUP) {
				while (dP.noHit(CONTROL.DOWN)) {
					dP._y += gridC(1);
					dP.gY += 1;
					info.score += Math.floor(0.2*info.level);
				}
				nextF();
			}
			flagUP = true;
		} else {
			flagUP = false;
		}
		//Rotate Piece CCW
		if (Key.isDown(CONTROL.ROTCCW)) {
			if (!flagROTCCW) {
				if (dP.noHit(CONTROL.ROTCCW)) {
					rot(dP.piece, -1);
					dP.drawPiece(dP.piece);
				}
			}
			flagROTCCW = true;
		} else {
			flagROTCCW = false;
		}
		//Rotate Piece CW
		if (Key.isDown(CONTROL.ROTCW)) {
			if (!flagROTCW) {
				if (dP.noHit(CONTROL.ROTCW)) {
					rot(dP.piece, 1);
					dP.drawPiece(dP.piece);
				}
			}
			flagROTCW = true;
		} else {
			flagROTCW = false;
		}
	}
}
dP.onEnterFrame = function() {
	//Controls for Left, Right, Soft Drop
	if (mode == 'game') {
		if (Key.isDown(CONTROL.LEFT) && dP.noHit(CONTROL.LEFT)) {
			dP._x -= gridC(1);
			dP.gX -= 1;
		}
		if (Key.isDown(CONTROL.RIGHT) && dP.noHit(CONTROL.RIGHT)) {
			dP._x += gridC(1);
			dP.gX += 1;
		}
		if (Key.isDown(CONTROL.DOWN)) {
			if (dP.noHit(CONTROL.DOWN)) {
				dP._y += gridC(1);
				dP.gY += 1;
				info.score += Math.floor(0.1*info.level);
				stopTry();
			} else {
				tryNext();
			}
		}
	}
};
//Initiates countdown to nextF
function tryNext() {
	if (!nextID) {
		nextID = setInterval(nextF, 500);
	}
}
//Aborts countdown to nextF
function stopTry() {
	if (nextID) {
		clearInterval(nextID);
		delete nextID;
	}
}
//Handles when piece has 'landed'
function nextF() {
	//Countdown attained, stop calling drop next piece
	stopTry();
	//If cannot fall down further, fuse piece with board
	if (!dP.noHit(CONTROL.DOWN)) {
		for (var y = 0; y<dP.piece.length; y++) {
			for (var x = 0; x<dP.piece[y].length; x++) {
				if (dP.piece[y][x]) {
					board[y+dP.gY][x+dP.gX] = dP.piece[y][x];
				}
			}
		}
		//Redraw, and next piece
		redrawBoard();
		nextPiece();
	}
}
//============================================================================
//Shuffles Array
Array.prototype.shuffle = function() {
	for (ivar=this.length-1; ivar>=0; ivar--) {
		var p = random(ivar+1);
		var t = this[ivar];
		this[ivar] = this[p];
		this[p] = t;
	}
	return this;
};
//Positions MovieClip from top-left corner
MovieClip.prototype.pos = function(x, y) {
	var b = this.getBounds(this._parent);
	this._x = this._x-b.xMin+x;
	this._y = this._y-b.yMin+y;
};
//Takes next piece from queue array
queue_mc.pull = function() {
	var p = pieceQueue.shift();
	if (pieceQueue.length == 7) {
		pieceQueue = pieceQueue.concat(new Array(0, 1, 2, 3, 4, 5, 6).shuffle());
	}
	this.removeFirst();
	this.addPiece();
	return p;
};
//Removes first piece in queue
queue_mc.removeFirst = function() {
	var clip = this.clip;
	clip.shift().removeMovieClip();
	var cy = queue_mc.clip[0]._y;
	for (var c = 0; c<clip.length; c++) {
		clip[c].swapDepths(c);
		clip[c].tY -= cy;
		clip[c]._y -= cy;
	}
};
//Adds piece to end of queue_mc
queue_mc.addPiece = function() {
	var clip = this.clip;
	var prev = clip[clip.length-1];
	var nP;
	if (prev) {
		nP = this.createEmptyMovieClip('p'+(Number(prev._name.slice(1))+1), prev.getDepth()+1);
	} else {
		nP = this.createEmptyMovieClip('p0', 0);
		prev = {tY:0, _height:0};
	}
	clip.push(nP);
	nP.drawPiece(pieces[pieceQueue[nP.getDepth()]]);
	nP.tX = 0;
	nP.tY = prev.tY+prev._height+space+side+space;
	nP.pos(nP.tX, nP.tY);
};
//=======================================================================
//Initial view to handle aquiring keyboard focus to flash
disp_txt.texts = 'CLICK MOUSE TO START A NEW GAME';
info_txt._visible = false;
onMouseDown = function () {
	resetAll();
	delete onMouseDown;
	onMouseDown = onResize;
};
//Start a new game
function resetAll() {
	//Make the board
	board = dim(12, 20, 0);
	for (var y = 0; y<board.length-1; y++) {
		board[y][0] = board[y][board[y].length-1]=0xCCCCCC;
	}
	for (var x = 1; x<board[board.length-1].length-1; x++) {
		board[board.length-1][x] = 0xCCCCCC;
	}
	board[-1] = [0xCCCCCC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xCCCCCC];
	redrawBoard();
	onResize();
	//Set up starting queue
	pieceQueue = [];
	pieceQueue = pieceQueue.concat(new Array(0, 1, 2, 3, 4, 5, 6).shuffle());
	pieceQueue = pieceQueue.concat(new Array(0, 1, 2, 3, 4, 5, 6).shuffle());
	queue_mc.clip = [];
	for (var i = 0; i<4; i++) {
		queue_mc.addPiece();
	}
	//Clean up old intervals
	if (nextID) {
		clearInterval(nextID);
		delete nextID;
	}
	if (onceActionID) {
		clearInterval(onceActionID);
		delete onceActionID;
	}
	if (gameID) {
		clearInterval(gameID);
		delete gameID;
	}
	//Drop piece  
	mode = 'game';
	nextPiece();
	onceActionID = setInterval(onceActionKeys, 1);
	//Info keeps track of scoring, lines, and level
	info = {};
	//Updates scoring
	info.updateScore = function(score, lines, level) {
		info_txt.htmlText = '<b>Score:</b> '+score+'<br><b>Lines:</b> '+lines+'<br><b>Level:</b> '+level;
	};
	//Changes game speed based on level
	info.watch('level', function (p, o, n) {
		this.updateScore(this.score, this.lines, n);
		clearInterval(gameID);
		gameID = setInterval(gameplay, 1000-(n-1)*999/29);
		return n;
	});
	info.watch('lines', function (p, o, n) {
		this.updateScore(this.score, n, this.level);
		return n;
	});
	info.watch('score', function (p, o, n) {
		this.updateScore(n, this.lines, this.level);
		return n;
	});
	//Initial field views
	info.lines = 0;
	//Can use querystring to test different levels, e.g. tetris.swf?level=30 
	info.level = _root.level == undefined ? 1 : _root.level;
	info.score = 0;
	info_txt._visible = true;
	disp_txt.texts = '';
	disp_txt._visible = false;
}