";
for($j = 0; $j < count($mapMatrix[$i]); $j++)
{
$handle = "$idprefix,$i,$j";
switch($mapMatrix[$i][$j])
{
case 's': $maptable .= " | "; break;
case 'f': $maptable .= " | "; break;
//TP1
case 't': $maptable .= " | "; break;
case 'u': $maptable .= " | "; break;
//TP2
case 'm': $maptable .= " | "; break;
case 'n': $maptable .= " | "; break;
//TP3
case 'g': $maptable .= " | "; break;
case 'h': $maptable .= " | "; break;
//TP4
case 'i': $maptable .= " | "; break;
case 'j': $maptable .= " | "; break;
//TP5
case 'k': $maptable .= " | "; break;
case 'l': $maptable .= " | "; break;
case 'a': $maptable .= " | "; break;
case 'b': $maptable .= " | "; break;
case 'c': $maptable .= " | "; break;
case 'd': $maptable .= " | "; break;
case 'e': $maptable .= " | "; break;
case 'r': $maptable .= " | "; break; //rock
case 'R': $maptable .= " | "; break; //metalic looking rock
case 'p': $maptable .= " | "; break; //path.
case 'q': $maptable .= " | "; break; //transparent
case 'w': $maptable .= " | "; break; //wall
// default; normally 'o'.
default: $maptable .= " | ";
//default: $maptable .= "".$mapMatrix[$i][$j]." | ";
}
}
$maptable .= "";
}
//Prepare mapdata.
$mapdata['height'] = $mapMatrix[0][0];
$mapdata['width'] = $mapMatrix[0][1];
$mapdata['points'] = $mapMatrix[0][2];
$mapdata['rocks'] = $mapMatrix[0][3];
$mapdata['walls'] = $mapMatrix[0][4];
$mapdata['teleports'] = $mapMatrix[0][5];
$mapdata['example'] = $example;
$mapdata['mapid'] = $idprefix;
$path = routePath($mapMatrix, '');
$mapdata['code'] = GenerateMapCode($mapMatrix);
$width = (($j * 35) + 2).'px';
//$width = (($j * 23) + 2).'px';
$i -= 1;
$height = (($i * 35)).'px';
//$height = (($i * 22) + 2).'px';
$jsonmap = json_encode($mapdata);
//This works in chrome, not sure about others.
$preloaddiv .= "
";
$mapdatadiv .= "";
$mapdatadiv .= $jsonmap;
$mapdatadiv .= '
';
$maptable = "$preloaddiv
";
$prefSpeed = $_COOKIE['pref_speed'];
$speedOption['Slow'] = 1;
$speedOption['Med'] = 2;
$speedOption['Fast'] = 3;
$speedOption['Ultra'] = 4;
if (!in_array($prefSpeed, $speedOption))
$prefSpeed = '2';
foreach ($speedOption as $key => $value) {
$rOption .= "Mute";
} else {
$mutebutton = "";
}
if ($example) {
$output = $maptable;
$output .= "
$mutebutton
";
$output .= $mapdatadiv;
$output = "
$output
";
return $output;
}
//$date = date("m-d-y");
//OUTPUT FOR PUZZLE-STYLE MAPS
if ($puzzle) {
$output = "
".$mapdata['walls']." walls
$maptable
Speed:
$mutebutton
$mapdatadiv
";
return $output;
}
//NORMAL OUTPUT:
$output = "
".$mapdata['walls']." walls
( Reset )
$maptable
Speed:
$mutebutton
$mapdatadiv
";
return $output;
}
//Generates map
function GenerateMap($rows, $cols, $rockchance, $numBlocks = -1, $cp = -1, $tp = -1) {
if ($numBlocks == -1)
$numBlocks = Rand(7, (int)($rows * $cols) * .12);
//Checkpoints and teleports.
if ($cp == -1)
$cp = rand(0, 5);
if ($tp == -1)
$tp = rand(0, 2);
$tp = $tp * 2; //Requires an out-teleport.
//== Possibility of inf loop here, if the map is too small.
do {
$randvalue = rand(1, ($rows * $cols));
//As long as it isn't the first, or last column.
//if ((($randvalue +1) % ($rows)) > 1) {
//As long as it isn't in the first, 2nd, last and 2nd to last column.
if ((($randvalue +2) % ($rows)) > 3) {
$unique[] = $randvalue;
$unique = array_unique($unique);
$unique = array_values($unique);
}
} while (count($unique) < ($cp+$tp) );
//Prepare our checkpoint and teleport names.
$cpnames = Array("a", "b", "c", "d", "e");
// in out in out etc.
$tpnames = Array("t", "u", "m", "n", 'g', 'h', 'i', 'j', 'k', 'l');
$teleport = Array();
$checkpoint = Array();
//Assign our checkpoints and teleports a unique position on the map.
$i = 0;
for($p = 0; $p < $cp; $p++) {
$checkpoint[$cpnames[$p]] = $unique[$i];
$i++;
}
for($p = 0; $p < $tp; $p++) {
$teleport[$tpnames[$p]] = $unique[$i];
$i++;
}
$rocks = 0; //Number of rocks in the maze.
// We need to make sure the map we construct is valid.
// so we throw this in a do-while the map is invalid.
do {
$p = -1;
//Begin loop to populate grid.
for( $y = 1; $y <= $cols; $y++) { //Number of Columns
for( $x = 0; $x < $rows; $x++) { //Number of Rows
$p++;
//Start and Finish squares.
if ($x == 0) {
//if ($x == 0 AND $y == 1) {
//if ($x == 0 AND rand(1,3) == 1) {
$grid[$y][$x] = "s";
} elseif ($x == $rows - 1) {
//} elseif ($x == $rows - 1 AND $y == intval(($cols + 1) * .5) ) {
//} elseif ($x == $rows - 1 AND rand(1,3) == 1) {
$grid[$y][$x] = "f";
//Randomly Placed Rocks
} elseif (rand(1, $rockchance) == 2) {
$grid[$y][$x] = "r";
$rocks++;
//!! rock count could be off if covered by checkpoint.
//Just a normal square.
} else {
$grid[$y][$x] = "o";
}
//Absolutely placed points; Checkpoints.
foreach ($checkpoint as $key => $v) {
if ($v == $p) {
$grid[$y][$x] = $key;
}
} //Teleports too
foreach ($teleport as $key => $v) {
if ($v == $p) {
$grid[$y][$x] = $key;
}
}
} //Rows
} //Cols
//Fill $grid[0] with header information
$grid[0][0] = $rows;
$grid[0][1] = $cols;
$grid[0][2] = count($checkpoint);
$grid[0][3] = $rocks;
$grid[0][4] = $numBlocks;
$grid[0][5] = count($teleport);
//Validate map
$path = routePath($grid, '', true);
//Only repeat if it's blocked.
} while ($path['blocked'] == true);
return $grid;
}
//Generates map based on $shape.
function GenerateShapedMap($shape, $params) {
//Get width and height.
$cols = strlen($shape[0]);
$rows = count($shape);
//Scan for checkpoints.
//$checkpoints = 0;
//$cpnames = Array("a", "b", "c", "d", "e");
//Get the amount of checkpoints on this map.
//foreach ($cpnames as $cpt)
// if (findTiles($mygrid, $cpt))
// $checkpoints++;
//Confirm params.
if ($params['rockchance'])
$rockchance = $params['rockchance'];
else
$rockchance = 10;
if ($params['checkpoints'])
$checkpoints = $params['checkpoints'];
else
$checkpoints = 0;
if ($params['teleports'])
$teleports = $params['teleports'];
else
$teleports = 0;
if (is_int($params['walls']))
$walls = $params['walls'];
else
$walls = 13;
$mapMatrix[0][0] = $cols;
$mapMatrix[0][1] = $rows;
$mapMatrix[0][2] = $checkpoints;
//set after;
$mapMatrix[0][3] = 0;
//walls
$mapMatrix[0][4] = $walls;
$mapMatrix[0][5] = $teleports;
do {
$rockcount = 0;
$i = 0;
if (! is_array($shape))
break;
foreach ($shape as $row) {
$i++;
for( $j = 0; $j < $cols; $j++) { //Number of Columns
$item = substr($row, $j, 1);
if ($item == '?') {
if (rand(1, $rockchance) == 1) {
$item = 'r';
$rockcount++;
} else {
$item = 'o';
}
}
$mapMatrix[$i][$j] = $item;
//echo $item;
}
//echo "\n";
}
$path = routePath($mapMatrix, '', true);
//echo $path['blocked']."\n";
//Only repeat if it's blocked.
} while ($path['blocked'] == true);
//Set rockcount.
$mapMatrix[0][3] = $rockcount;
//print_r ($mapMatrix);
return $mapMatrix;
}
//Inserts a point into a shape-array.
function insertPoint($array, $new, $target = '?') {
//Replaces a random element in $array that matches $target with $new,
// if $new is a single character.
//If $new is a string, replace a random element for each of $new's characters.
/*
Snap - "the goal is to turn something like:
$mymap = Array("s??????f". "s???????f")
// into; Array("s???a??f", "s???b???f")
after a couple calls to the function."
*/
//Getting $array parameters
$rows = count($array);
$length = strlen($array[0]);
$size = $rows * $length;
//Retrieving all cells == $target from $array
//This is more memory intensive, and probably more CPU-so, but far more safe.
$targetCells = array();
for( $i = 0; $i < $size; $i++)
{
$y = $i % $length; //Get coordinates based on $index
$x = (int)($i / $length);
//echo "
index: $i y: $y, x: $x
";
//echo $array[$x][$y];
if($array[$x][$y] == $target)
$targetCells[] = $i;
}
//Now that we have a definite selection of cells, we can pick easily with
// the only caveat being if there aren't enough $target cells.
if(strlen($new) > $length)
{
//There are too many replace requests and not enough free cells.
echo "Too many $new characters. No replacements made.
";
return $array;
}
//Debug to see what indexes were selected as == $target
/*
echo "array = ";
print_r($array);
echo "
";
echo "targetCells = ";
print_r($targetCells);
echo "
";
echo "
";
*/
while(strlen($new) > 0)
{
$length = count($targetCells);
$indexReplace = rand(0, $length - 1); //Get a random position in $targetCells
$indexTarget = $targetCells[$indexReplace]; //Get the index stored in $targetCells
$y = $indexTarget % strlen($array[0]); //Get coordinates based on $index
$x = (int)($indexTarget / strlen($array[0]));
if($array[$x][$y] == $target) //Shouldn't be necessary, but just in case...
{
$array[$x][$y] = $new[0]; //We've found a valid target. Replace.
$new = substr($new, 1); //Go to the next $new character.
unset($targetCells[$indexReplace]); //Remove the selected $targetCell.
$targetCells = array_values($targetCells); //Reorder the array for no holes.
continue;
}
else
{
//Somehow an invalid target got into our list of valid targets...
echo "
";
echo "Error in selecting $indexTarget ($x,$y). Replacement stopped on $new[0].
";
echo "indexTarget = $indextarget
";
echo "indexReplace = $indexReplace
";
echo "array = ";
print_r($array);
echo "
";
echo "targetCells = ";
print_r($targetCells);
echo "
";
echo "
";
return $array;
}
}
return $array;
}
//Turns a mapMatrix into a code - see GenerateMapByCode
function GenerateMapCode($mapMatrix) {
//Iterate through $mapMatrix and generate the code used to save and
// load the map through the database.
$code = ""; //The string to return to the database.
$index = 0; //The current number of tiles from the last tile saved.
// $mapMatrix[0] stores header data--dimensions, #checkpoints, #rocks, #walls
// $mapMatrix[1] count will always be the width.
$mapsize = $mapMatrix[0][0].'x'.$mapMatrix[0][1]; //Width x Height
$code = $mapsize.
'.c'.$mapMatrix[0][2].
'.r'.$mapMatrix[0][3].
'.w'.$mapMatrix[0][4].
'.t'.$mapMatrix[0][5];
// dimensions + # checkpoints + # rocks + # placeable walls
//echo $code."
";
$code .= ".:";
for( $i = 1; $i < count($mapMatrix); $i++)
{
for( $j = 0; $j < count($mapMatrix[$i]); $j++)
{
if($mapMatrix[$i][$j] != 'o')
{
//As long as the tile is NOT open, embed it in the code.
$code .= $index.$mapMatrix[$i][$j].'.';
//Start from 0 again.
$index = -1;
}
$index += 1;
}
}
//== Don't need to fill in the last spot.
//if ($index > 1) {
// $code .= $index.'o.';
//}
return $code;
}
//Turns a mapcode into a mapMatrix, - see GenerateMapCode
function GenerateMapByCode($code) {
//Create $mapMatrix by iterating through $code (a string value).
//==$mapMatrix = array();
$tmp = explode( ":", $code);
$headers = explode( '.', $tmp[0]);
$splitCode = explode( '.', $tmp[1]);
//Extract header information.
//==$mapMatrix[0] = array();
$dimensions = explode( 'x', $headers[0]);
$mapMatrix[0][0] = $dimensions[0]; //Width
$mapMatrix[0][1] = $dimensions[1]; //Height
//Select the next parameters by ignoring the character label.
$mapMatrix[0][2] = (int)substr($headers[1], 1); //Number of Checkpoints
$mapMatrix[0][3] = (int)substr($headers[2], 1); //Number of Rocks
$mapMatrix[0][4] = (int)substr($headers[3], 1); //Number of Wall Blocks
$mapMatrix[0][5] = (int)substr($headers[4], 1); //Number of Teleports
//Printing out parameters for debug purposes...
/*
echo "
Map Parameters:
";
echo "mapMatrix[0][0]: ".$mapMatrix[0][0]."
";
echo "mapMatrix[0][1]: ".$mapMatrix[0][1]."
";
echo "mapMatrix[0][2]: ".$mapMatrix[0][2]."
";
echo "mapMatrix[0][3]: ".$mapMatrix[0][3]."
";
echo "mapMatrix[0][4]: ".$mapMatrix[0][4]."
";
echo "mapMatrix[0][5]: ".$mapMatrix[0][5]."
";
*/
//Begin creating our mapMatrix
$t = -1;
$index = 0;
for( $i = 1; $i <= $mapMatrix[0][1]; $i++) { //Number of Rows
for( $j = 0; $j < $mapMatrix[0][0]; $j++) { //Number of Columns
$t++;
$next = substr($splitCode[$index], 0, strlen($splitCode[$index]) - 1);
//Are we at the next target, if there is one.
if ($next == $t AND $next != '') {
//Update tile.
$type = substr($splitCode[$index], -1, 1);
$mapMatrix[$i][$j] = $type;
$index++;
//Start from 0 again.
$t = -1;
} else {
$mapMatrix[$i][$j] = 'o'; //Empty Tile
}
}
}
return $mapMatrix;
}
//Returns a mapMatrix merged with a solution/maze.
function MergeMapSolution($mapMatrix, $solution) {
//echo $solution;
$sa = explode( '.', $solution);
foreach($sa as $v) {
if ($v == '') continue;
$v= explode(",", $v);
$i = $v[0];
$j = $v[1];
//Trying to place a wall - where?
if ($mapMatrix[$i][$j] <> 'o') return -1;
$mapMatrix[$i][$j] = 'w';
//Are we out of blocks?
//if ($mapMatrix[0][2] < 1) return -2;
$mapMatrix[0][4]--;
}
return $mapMatrix;
}
function seperateMapSolution($mapMatrix) {
for( $i = 1; $i <= $mapMatrix[0][1]; $i++) //Number of Rows
for( $j = 0; $j < $mapMatrix[0][0]; $j++) //Number of Columns
if ($mapMatrix[$i][$j] == 'w')
$solution .= "$i,$j.";
$solution = ".".$solution;
return $solution;
}
//This is required to identify identical solutions, or even 'close' ones.
function formSolution($solution) {
$tmp = explode(".", $solution);
$tmp = array_filter($tmp);
sort($tmp);
$tmp = '.'.implode(".", $tmp).'.';
return $tmp;
}
//Returns the best solution.
function getSolution($userID, $mapID) {
include_once('db.inc.php');
$sql = "SELECT `solution`
FROM `solutions`
WHERE `userID` = '$userID' AND
`mapID` = '$mapID'
";
$result = mysql_query($sql);
if (mysql_num_rows($result) > 0) {
list($solution) = mysql_fetch_row($result);
return $solution;
}
}
function getMapCode($mapID) {
include_once('db.inc.php');
$sql = "SELECT `code`
FROM `maps`
WHERE `ID` = '$mapID'
";
$result = mysql_query($sql);
if (mysql_num_rows($result) > 0) {
list($map) = mysql_fetch_row($result);
return $map;
}
}
function pastMap($maptype, $daysago) {
$sql = "
SELECT `mapID`
FROM `mapOfTheDay`
WHERE DATE_ADD(CURDATE(), INTERVAL -$daysago DAY) =
DATE_FORMAT(mapDate,'%Y-%m-%d') AND
`mapType` = '$maptype'
";
//echo "
$sql
";
$result = mysql_query($sql) or die(mysql_error());
//No map for today?
if (mysql_num_rows($result) == 0)
return -1;
$r = mysql_result($result, 0, 'mapID');
//echo "result: $r";
return $r;
}
//Returns tiles as a string seperated like: x,y.x,y.
function findTiles ($mapMatrix, $search) {
$r = false;
for( $i = 1; $i <= $mapMatrix[0][1]; $i++) { //Number of Rows
for( $j = 0; $j < $mapMatrix[0][0]; $j++) { //Number of Columns
if ($mapMatrix[$i][$j] == $search)
$r.= "$j,$i.";
}
}
return $r;
}
// Returns: ARRAY( blocked, path, start, end )
function findPath($mapMatrix, $start = '0,1', $target = 'f') {
//Remove last period if existing.
if (substr($start, -1) == '.')
$start = substr ($start, 0, -1);
//Create our starting locations
$seed = explode(".", $start);
foreach ($seed as &$v) {
$v = explode(",", $v);
$v[2] = $v[0].','.$v[1];
$v[3] = '';
//Remove Seeds as potential seeding slots.
$x = $v[0];
$y = $v[1];
unset($mapMatrix[$y][$x]);
}
$index = count($seed);
do {
foreach ($seed as $key => &$v) {
//Search the squares around, to spread the seeds
for($i = 1; $i <= 4; $i++) {
$x = $v[0];
$y = $v[1];
//Create a handle on the squares around it.
switch($i){
case 1: $y--; break; //up
case 2: $x++; break; //right
case 3: $y++; break; //down
case 4: $x--; break; //left
}
//Ensure we don't enter into our mapdata area
if ($y < 1 OR $x < 0) continue 1;
//Is this tile even on the map?
if (!isset($mapMatrix[$y][$x])) {
continue 1;
}
$path = '';
//What's there?
switch($mapMatrix[$y][$x]) {
case $target: //Finishline!
//Our search is over.
$r['blocked'] = false;
$r['path'] = $seed[$key][3].$i;
$r['start'] = $v[2];
$r['end'] = "$x,$y";
return $r;
break;
// Teleports m t g i k
case "m": case "t": case "g": case "i": case "k":
$path = $mapMatrix[$y][$x];
case "o": //Available squares
//!!
case "p":
case "s": case "f": //Start and end tiles
case "a": case "b": case "c": case "d": case "e": //Checkpoints too
case "u": case "n": case "h": case "j": case "l": //Teleport-out towers included!
//Plant Seed here
$seed[$index][0] = $x;
$seed[$index][1] = $y;
//Save our starting position.
$seed[$index][2] = $v[2];
//Save 'PATH'
$path = $i.$path;
$seed[$index][3] = $v[3].$path;
//Don't plant a seed here again.
unset($mapMatrix[$y][$x]);
//Move index
$index++;
break;
}
}
//Running out of seeds?
if (count($seed) < 2) {
$r['blocked'] = true;
$r['path'] = $seed[$key][3].$i;
$r['start'] = $v[2];
$r['end'] = "$x,$y";
return $r;
}
//Lets not try this again.
unset($seed[$key]);
}
} while ( 1);
echo "Ran outa seeds.
";
print_r($seed);
return $mapMatrix;
}
/* UNUSED FUNCTION
function GetTile($mapMatrix, $id)
{
//Returns the location in $mapMatrix indicated by $id
$toReturn = &$mapMatrix [ (int)($id / $mapMatrix[0][0]) ]
[ $id % $mapMatrix[0][0] ];
return $toReturn;
}
*/
//Routes a path through all checkpoints and teleports, returning an array.
// [path] path-string. [blocked] boolean, [moves] int.
function routePath($mygrid, $start = '', $validate = false) {
//Our response
$r = array('start' => NULL, 'path' => NULL, 'blocked' => true);
//Locate the start locations.
$start = findTiles($mygrid, "s");
//Checkpoint names
$cpnames = array("a", "b", "c", "d", "e");
//Add the existing checkpoints to target array.
foreach ($cpnames as $cpt)
if (findTiles($mygrid, $cpt))
$target[] = $cpt;
//Our last target is the finish line.
$target[] = 'f';
//Assume that we're not blocked, and raise a red flag later.
$blocked = false;
//All possible teleports in play.
$tpnames = array('t', 'm', 'g', 'i', 'k');
//Where there's an in, there's an out.
$teleout['t'] = 'u';
$teleout['m'] = 'n';
$teleout['g'] = 'h';
$teleout['i'] = 'j';
$teleout['k'] = 'l';
$teleport = array();
//Find all the existing teleports.
foreach ($tpnames as $tpt)
if (findTiles($mygrid, $tpt))
$teleport[] = $tpt;
//If validate, add teleport in/out's.
if ($validate) {
$target = array_merge($target, $teleport);
foreach ($teleport as $tin)
$target[] = $teleout[$tin];
}
//Prepare vars for iteration;
$tpath = '';
$movesoffset = 0;
//Loop through all the targets.
foreach($target as $t) {
//FindPath from where we are, to the target.
$p = Findpath($mygrid, $start, $t);
//Mark where we ended up starting from.
if ($r['start'] == '')
$r['start'] = $p['start'];
//Could be blocked right already.
$blocked = $p['blocked'];
do {
//Exit if path is blocked.
if ($blocked) {
$r['blocked'] = true;
return $r;
}
//Make sure there is a teleport to search.
if (! is_array($teleport))
break 1;
//Search through the path to find first teleport hit, if any.
$pathary = str_split($p['path']);
//As per usual, it's best to assume that you've failed.
$foundtele = false;
//Search through pathary and compare all existing teleports.
foreach ($pathary as $position => $char) {
foreach ($teleport as $ktel => $port) {
//$r['z'] .= ';'.$f++;
if ($port == $char) {
//Disable teleport
unset($teleport[$ktel]);
//We found it
$foundtele = true;
break 2;
}
}
}
if ($foundtele == false)
break 1;
$outchar = $teleout[$port];
if ($position === false) continue;
//Find the teleport outs
$teleouts = findTiles($mygrid, $outchar);
//New path starting from an out-location.
$z = Findpath($mygrid, $teleouts, $t);
if ($z['blocked']) $blocked = true; //Optional?
$out = $z['start'];
//Deactivate teleport
$teleactive[$port] = false;
//$r['debug'] = "TPD: $port";
//Apply modified path, and warp-cordinates.
//123 _Tele_ 222
//123
$p['path'] = substr($p['path'], 0, $position + 1);
//123
//123 U CORDS U
$p['path'] .= $outchar.$out.$outchar;
//123 U CORDS U
//123 U CORDS U 2322
$p['path'] .= $z['path'];
//Our end point may have been modified.
$p['end'] = $z['end'];
$movesoffset -= countmoves($out);
//}
} while ($foundtele);
//$start = explode(",", $p['end']);
$start = $p['end'];
if ($p['blocked']) $blocked = true;
$tpath .= $t.$p['path'].'r';
}
$r['blocked'] = $blocked;
$r['path'] = $tpath;
$moves = countmoves($tpath);
$moves += $movesoffset;
$r['moves'] = $moves;
return $r;
}
//For use with routepath;
function cmp($a, $b) {
if ($a === false) $a = 10000;
if ($b === false) $b = 10000;
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}
//For use with routepath;
function countmoves($path) {
$moves = substr_count($path, '1');
$moves += substr_count($path, '2');
$moves += substr_count($path, '3');
$moves += substr_count($path, '4');
return $moves;
}
//Returns a random selection of one of the arguements.
function weight() {
$weights = func_get_args();
return $weights[rand(0, (count($weights) -1))];
}
?>
