/*----------------------------------------------------------
  File: 		puzzle.js
	Author: 	Andreas Ravn

	Version:	0.2 (16.03.2003)

	Description:
	Jigsaw puzzle execution program
	
	Details:
	Start by executing function draw_pieces()
	
	Still needs these variables to be set from the calling
	program:
		var n_x = 5; // number of pieces horiz
		var n_y = 4; // number of pieces vert
		var namestem_pieces = "img/pinguin_cellscellXY_"; // 
		var filetype_pieces = ".gif"; // 
		pieces_yx = [ [ [0,0], [0,118], [0,242], [0,366], [0,466]], [ [80,0], [80,94], [80,243], [104,342], [80,491]], [ [214,0], [214,94], [190,218], [214,367], [190,491]], [ [324,0], [300,118], [300,242], [324,366], [300,490]]];
	
----------------------------------------------------------*/

// Constants
var idstem_pieces = "PIECE_";		// the object ids for pieces always begin with this string
var DOCKING_PROX = 5; 					// the proximity (in pixels) until matching pieces dock
var XY_SEP = "_";								// separator for the object x and y parts

// Globals
var pieces_ids = null;		// saves the pieces' div-ids
var pieces_inchunk = null; 	// saves the chunk-id of every piece, or null.
var chunks = new Array();	// saves the chunks
var ChunkId = 0;			// fortlaufende Numerierung der Chunks

// ---------------------------------------------------------
// install all pieces into internal arrays
// ---------------------------------------------------------
function installPieces()
{
	linear_piece_counter = 0;
	pieces_ids = new Array(n_y-1);
	pieces_images = new Array(n_y-1);
	pieces_inchunk = new Array(n_y-1);

	for(var cy=0;cy<n_y;++cy)
	{
		pieces_ids[cy] = new Array(n_x-1);
		pieces_images[cy] = new Array(n_x-1);
		pieces_inchunk[cy] = new Array(n_x-1);
		for(var cx=0;cx<n_x;++cx)
		{
			pieces_ids[cy][cx] = idstem_pieces + linear_piece_counter;
			// better put position inside id:
			pieces_ids[cy][cx] = idstem_pieces + cy + XY_SEP + cx;
			pieces_inchunk[cy][cx] = null; // by default, pieces are NOT part of a chunk
			pieces_images[cy][cx] = new Image(); pieces_images[cy][cx].src = namestem_pieces + (linear_piece_counter) + filetype_pieces;
			++linear_piece_counter;
		}
	};
}

// ---------------------------------------------------------
// make a new chunk id
// ---------------------------------------------------------
function generateChunkId()
{
	return ChunkId++;
}

// ---------------------------------------------------------
// convert CSS strings like "14px" to a number ("14")
// ---------------------------------------------------------
function convertNum(a)
{
	return a.replace(/px/ig,"");
}

// ---------------------------------------------------------
// convert CSS strings like "14px.880px" to a number ("14")
// NN7 sometimes does strange things.
// ---------------------------------------------------------
function convertNumStrange(a)
{
	return a.replace(/^(\d*)(.*)$/, "$1");
}


function getPosFromId(objid, dir)
{
	// dir (direction) is "X" or "Y"
	// attention: XY_SEP is hardcoded into rexp... (middle)
	// rexp = /.+_(\d+)_(\d+)/g;
	rexp = new RegExp(".+_(\\d+)"+XY_SEP+"(\\d+)","g");
	rexp.exec(objid);
	// alert("1:"+RegExp.$1+"; 2:"+RegExp.$2);

	switch (dir.toLowerCase())
	{
		case "x" :	{ return Number(RegExp.$2); break; }
		case "y" :	{ return Number(RegExp.$1); break; }
		default: { return null; }
	}
}

// ---------------------------------------------------------
// main function: position all pieces randomly on the screen
// ---------------------------------------------------------
function drawPieces()
	{
		installPieces();
		for(var cy=0;cy<n_y;++cy)
		{
			for(var cx=0;cx<n_x;++cx)
			{
				xpos = Math.random() * 750;
				ypos = 250 + Math.random() * 300;
				document.write("<div id='"+pieces_ids[cy][cx]+"' style='position:absolute;top:"+ypos+";left:"+xpos+"'><img src='"+pieces_images[cy][cx].src+"' border='0' alt=''></div>");
			}
		}
	};

// ---------------------------------------------------------
// change chunk membership of a piece
// ---------------------------------------------------------
function changeInchunks(from_nr, to_nr)
{
	for(iy=0;iy<n_y;++iy)
	{
		for(ix=0;ix<n_x;++ix)
		{
			if(pieces_inchunk[iy][ix] == from_nr) pieces_inchunk[iy][ix] = to_nr;
		}
	}
}

// ---------------------------------------------------------
// link two pieces/chunks to one another
// ---------------------------------------------------------
function linkToPartner(objid)
{
	// check in all 4 directions
	for (cardinalPoint=0;cardinalPoint<=3;++cardinalPoint)
	{
		dy = 0;
		dx = 0;
		switch (cardinalPoint)
		{
			case 0 : dy = -1; break;
			case 1 : dx = 1; break;
			case 2 : dy = 1; break;
			case 3 : dx = -1; break;
		}

		// get current item's position
		idx = getPosFromId(objid, "x");
		idy = getPosFromId(objid, "y");
		// do not continue checking this cardinal point, if piece the very directions border
		if (!( ((dy == -1)&&(idy==0)) || ((dy == 1)&&(idy==(n_y-1))) || ((dx == -1)&&(idx==0)) || ((dx == 1)&&(idx==(n_x-1))) ))
		{
			pidx = idx+dx;
			pidy = idy+dy;
			tx = pieces_yx[idy][idx][1];
			ty = pieces_yx[idy][idx][0];
			// get relevant partner position
			px = pieces_yx[pidy][pidx][1];
			py = pieces_yx[pidy][pidx][0];

			// dont continue if these two parts already belong to the same group.
			if( !((pieces_inchunk[idy][idx] == pieces_inchunk[pidy][pidx]) && (pieces_inchunk[idy][idx] != null)) )
			{
				pobjid = pieces_ids[pidy][pidx];
			
				pobj = eval(getObjXS(pobjid));
				tobj = eval(getObjXS(objid));
				// check if diff is in range
				if(pobj.style.pixelLeft)
				{
				// default, IE.
				ppx = pobj.style.pixelLeft;
				ppy = pobj.style.pixelTop;
				tpx = tobj.style.pixelLeft;
				tpy = tobj.style.pixelTop;
				}
				else
				{
				// NN?
				
				ppx = convertNumStrange(pobj.style.left);
				ppy = convertNumStrange(pobj.style.top);
				tpx = convertNumStrange(tobj.style.left);
				tpy = convertNumStrange(tobj.style.top);
				}
				
				diffx = Math.abs( (py - ty) - (ppy-tpy) )
				diffy = Math.abs( (px - tx) - (ppx-tpx) );
				// if yes, dock together: exact position and straighten chunk and inchunk arrays
				diff = Math.max(diffx,diffy);
				if (diff <= DOCKING_PROX)
				{
					// yes, these are docking! Dock either their groups or the single pieces

					// Is the dropped piece part of a group?
					tch = pieces_inchunk[idy][idx];
					// Is the found neighbor part of a group?
					pch = pieces_inchunk[pidy][pidx]
					// if none is a group, let them both compose a new group.
					if ( (tch == null) && (pch == null) )
					{
						correctItemPos(objid, (px - tx) - (ppx-tpx), (py - ty) - (ppy-tpy))	
						newChunkId = generateChunkId();
						chunks[newChunkId] = new Array();
						chunks[newChunkId][0] = objid;
						chunks[newChunkId][1] = pobjid;
						pieces_inchunk[idy][idx] = newChunkId;
						pieces_inchunk[pidy][pidx] = newChunkId;
	
						 // window.status = "Created new chunked object '"+newChunkId+"' from objects "+objid+" and "+pobjid+".";
					} 
					// If one is a group, include the single part in this group
	
					else if (pch == null)
					{
						// this item belongs to a chunk, but not the other.
						correctChunkPos(tch, (px - tx) - (ppx-tpx), (py - ty) - (ppy-tpy))	

						// this item belongs to a chunk
						chunk = chunks[tch];
						chunk[chunk.length] = pobjid;
						pieces_inchunk[pidy][pidx] = tch;
						 // window.status = "Added piece "+pobjid+" to chunk " + tch + "."

					} else if (tch == null)
					{
						// the partner item belongs to a chunk, but not this one
						correctItemPos(objid, (px - tx) - (ppx-tpx), (py - ty) - (ppy-tpy))	

						chunk = chunks[pch];
						chunk[chunk.length] = objid;
						pieces_inchunk[idy][idx] = pch;
						 // window.status = "Added piece "+objid+" to chunk " + pch + "."
					} else
					{
						// both items belong to chunks
						correctChunkPos(tch, (px - tx) - (ppx-tpx), (py - ty) - (ppy-tpy))	
	
						// If both are groups, concat the groups to a single group
						chunks[tch] = chunks[tch].concat(chunks[pch]);
						// change the inchunk array
						changeInchunks(pch, tch);

						chunks[pch] = null;
						 // window.status = "Concated chunks " + tch + " and " + pch + "."
					}				
	
					// maybe the puzzle is finished now?
					if(isOnlyOneGroupLeft()) { alert("Fantastisch! Das Puzzle ist gelöst!"); move_puzzle_to_mid_pos(); }
					// end of the game
					
				} // if
			} // if
		} // if
	} // for
} // func

// ---------------------------------------------------------
// cirrect the position of all pieces of the currently moved 
// chunk when linking two pieces/chunks
// ---------------------------------------------------------
function correctChunkPos(chunkid, dx, dy)
{
	for(cr=0;cr<pieces_inchunk.length;++cr)
		for(cc=0;cc<pieces_inchunk[cr].length;++cc)
			if (pieces_inchunk[cr][cc] == chunkid)
			{
				iobjid = pieces_ids[cr][cc];
				correctItemPos(iobjid, dx, dy)
			}
}

// ---------------------------------------------------------
// correct the position of a piece when linking pieces
// ---------------------------------------------------------
function correctItemPos(itemid, dx, dy)
{
	iobj = eval(getObjXS(itemid));
	if(iobj.style.pixelLeft)
	{
		//ie
		iidx = iobj.style.pixelLeft;
		iidy = iobj.style.pixelTop;
	}
	else
	{
		//nn7
		iidx = convertNum(iobj.style.left);
		iidy = convertNum(iobj.style.top);
	}
	// iidx = getPosFromId(itemid, "x");
	// iidy = getPosFromId(itemid, "y");									

	newxpos = iidx - dx; 
	newypos = iidy - dy;
	
	if(iobj.style.pixelLeft)
	{
		// ie
		iobj.style.pixelLeft = newxpos;
		iobj.style.pixelTop = newypos;
	}
	else
	{
		// nn7
		iobj.style.left = newxpos;
		iobj.style.top = newypos;
	}
}

// ---------------------------------------------------------
// find out if there is only one group left (which means,
// that the puzzle is solved
// ---------------------------------------------------------
function isOnlyOneGroupLeft()
{
	// make a reverse array from the pieces_inchunk one
	// if it contains a NULL value, that is still a single puzzle part,
	// thus we return FALSE.
	da1 = new Array();
	for(cr=0;cr<pieces_inchunk.length;++cr)
		for(cc=0;cc<pieces_inchunk[cr].length;++cc)
			if (pieces_inchunk[cr][cc] == null)
				return false;
			else
			{
				da1[pieces_inchunk[cr][cc]] = 1;
			}
			
	// now count the number of elements in this array. If greater
	// than 1, we still have different groups
	nc=0;
	for(dc=0;dc<da1.length;++dc)
		if (da1[dc] == 1) nc++;
	return (nc == 1);	
}

function getObjXS(id)
{
	return 'document.getElementById("'+id+'")';
}