Maze gen - Unity crash

Hi everybody,

sorry for my english, I’m from Belgium so I apologize if you find some language mistakes in this thread.


My problem is:

I’ve created a C program to randomly generate Maze. Then I’ve wanted to create a game based on this one. So I’ve written this again but in Javascript. Sadly, the scipt seems not to work perfectly and make my Unity crash when I check “maximize on play” in the game window. But no error shows up when it seems to partly work.


Here is the code:

// Variables
private var dimension : int = 15;
private var limite : int = dimension * 2 + 1;
private var direction : int;
private var compteur : int = 0;
private var nbrMurs : int = dimension * dimension - 1;
private var i : int;
private var j : int;
private var possibilites : int;

private var grille = new Array(limite);
private var pos = new Array(2);
private var posTest = new Array(2);
private var cases = new Array(4);
private var deplacements = new Array(dimension * dimension);

public var mur : GameObject;


// Fonction principale ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function Start ()
{
   // Initialisation de la grille
   for (i=0; i<limite; i++)
   {
      grille *= new Array(limite);*

}
for (i=0; i<limite; i++)
{
for (j=0; j<limite; j++)
{
if ((i % 2) != 0 && (j % 2) != 0)
grille*[j] = 1;*
else
grille*[j] = 0;*
}
}

// Choix de la première case
for (i=0; i<2; i++)
{
do
{
pos = parseInt(Random.Range(0, (limite - 1)));
}
while ((pos % 2)==0);
}

// Génération du labyrinthe
do
{
// Choix de la direction
possibilites = 0;
for (i=0; i<4; i++)
{
// Choix de la case à tester
if (i==0)
{
posTest[0] = pos[0];
posTest[1] = pos[1] - 2;
}
else if (i==1)
{
posTest[0] = pos[0] + 2;
posTest[1] = pos[1];
}
else if (i==2)
{
posTest[0] = pos[0];
posTest[1] = pos[1] + 2;
}
else if (i==3)
{
posTest[0] = pos[0] - 2;
posTest[1] = pos[1];
}
// Teste de la case
if (posTest[0]>0 && posTest[0]<(limite-1) && posTest[1]>0 && posTest[1]<(limite-1))
{
* if (grille[posTest[0]][posTest[1]]==1)*
* {*
_ cases = 1;
* possibilites++;
}
}
else
cases = 0;
// Définition de la direction*

if (possibilites>0)
{
do
{
direction = parseInt(Random.Range(0, 3));
}
while (cases[direction]!=1);
}
else
direction = 4;
}_

// Si un chemin est possible
if (direction<4)
{
// Traçage du chemin
if (direction==0)
{
grille[pos[0]][pos[1]] = 2;
grille[pos[0]][pos[1]-1] = 2;
grille[pos[0]][pos[1]-2] = 2;
pos[1] -= 2;
}
else if (direction==1)
{
grille[pos[0]][pos[1]] = 2;
grille[pos[0]+1][pos[1]] = 2;
grille[pos[0]+2][pos[1]] = 2;
pos[0] += 2;
}
else if (direction==2)
{
grille[pos[0]][pos[1]] = 2;
grille[pos[0]][pos[1]+1] = 2;
grille[pos[0]][pos[1]+2] = 2;
pos[1] += 2;
}
else if (direction==3)
{
grille[pos[0]][pos[1]] = 2;
grille[pos[0]-1][pos[1]] = 2;
grille[pos[0]-2][pos[1]] = 2;
pos[0] -= 2;
}
deplacements[compteur] = direction;
compteur++;
nbrMurs–;
}

// Si c’est un cul de sac
else
{
// Retour en arrière
compteur–;
if (deplacements[compteur]==0)
pos[1] += 2;
else if (deplacements[compteur]==1)
pos[0] -= 2;
else if (deplacements[compteur]==2)
pos[1] -= 2;
else if (deplacements[compteur]==3)
pos[0] += 2;
}
}
while (nbrMurs>0);

// Affichage du labyrinthe
for (i=0; i<limite; i++)
{
for (j=0; j<limite; j++)
{
_ if (grille*[j]==0)
{
var wall : GameObject;
var position : Vector3 = this.transform.position;
position[0] += (j * 0.1);
position[1] += (i * 0.1);
wall = Instantiate(mur, position, Quaternion.identity);
wall.name = “Wall”;
}
}
}
}
----------
Here is a picture of the C program result (top) and a picture of the JS result (bottom):
![alt text][1]![alt text][2]
----------
I would be really thanksfull if some of yours found the problem because I’ve spent so much time on those lines that I can’t see anything wrong.
Have a nice day!
MG
[1]: https://mgprog.files.wordpress.com/2014/08/labyrinthe30x30.png*_

_*[2]: https://mgprog.files.wordpress.com/2014/08/amazing03.png*_


direction = parseInt(Random.Range(0, 3));

was not ever doing direction 3

it has to be

direction = parseInt(Random.Range(0, 4));

strange it surprised me too.

`hey i ran it, your code is being stuck in infinite feedback loop, something is going – on some loop number or it’s just going round 2 conditions to infinity.

for this kind of problem, its hard to find it, so i added 20 30 print statements for every condition and a yield… yield makes it jump a frame, and if it jumps frame between infinite loop it can’t crash

with this version, you have a printout and you should be able to see where the error occurs, by using the print number reference:

 // Variables
private var dimension : int = 15;
private var limite : int = dimension * 2 + 1;
private var direction : int;
private var compteur : int = 0;
private var nbrMurs : int = dimension * dimension - 1;
private var i : int;
private var j : int;
private var possibilites : int;
 
private var grille = new Array(limite);
private var pos = new Array(2);
private var posTest = new Array(2);
private var cases = new Array(4);
private var deplacements = new Array(dimension * dimension);
 
public var mur : GameObject;
 function Start (){
 Draw ();
 
 }
 
// Fonction principale ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function Draw ()
{
   // Initialisation de la grille
   	  print(24); 	yield WaitForFixedUpdate;
   for (i=0; i<limite; i++)
   {
   	  print(25); 	yield WaitForFixedUpdate;
      grille *= new Array(limite);*
  • print(i); yield WaitForFixedUpdate;*
    }
    for (i=0; i<limite; i++)
    {
  • print(1); yield WaitForFixedUpdate;*
    for (j=0; j<limite; j++)
    {
  •    print(2); 	yield WaitForFixedUpdate;*
    

if ((i % 2) != 0 && (j % 2) != 0)
{grille*[j] = 1; print(543); yield WaitForFixedUpdate;}*
else
{grille*[j] = 0; print(562); yield WaitForFixedUpdate;}*
}
}

// Choix de la première case
for (i=0; i<2; i++)
{
* print(3); yield WaitForFixedUpdate;*
do
{
* print(456); yield WaitForFixedUpdate;*
pos = parseInt(Random.Range(0, (limite - 1)));
}
while ((pos % 2)==0);
}

// Génération du labyrinthe
do
{
* print(4); yield WaitForFixedUpdate;*
// Choix de la direction
possibilites = 0;
for (i=0; i<4; i++)
{
// Choix de la case à tester
if (i==0)
{ print(6); yield WaitForFixedUpdate;
posTest[0] = pos[0];
posTest[1] = pos[1] - 2;
}
else if (i==1)
{
* print(7); yield WaitForFixedUpdate;*
posTest[0] = pos[0] + 2;
posTest[1] = pos[1];
}
else if (i==2)
{
* print(17); yield WaitForFixedUpdate;*
posTest[0] = pos[0];
posTest[1] = pos[1] + 2;
}
else if (i==3)
{
* print(17); yield WaitForFixedUpdate;*
posTest[0] = pos[0] - 2;
posTest[1] = pos[1];
}
// Teste de la case
if (posTest[0]>0 && posTest[0]<(limite-1) && posTest[1]>0 && posTest[1]<(limite-1))
{
* print(8); yield WaitForFixedUpdate;*
if (grille[posTest[0]][posTest[1]]==1)
{
* print(44); yield WaitForFixedUpdate;*
cases = 1;
possibilites++;
}
}
else
{ cases = 0;
* print(46); yield WaitForFixedUpdate;}*
// Définition de la direction
if (possibilites>0)
{
* print(9); yield WaitForFixedUpdate;*
do
{
* print(32); yield WaitForFixedUpdate;*
direction = parseInt(Random.Range(0, 3));
}
while (cases[direction]!=1);
}
else
direction = 4;
* print(10); yield WaitForFixedUpdate;*
}

// Si un chemin est possible
if (direction<4)
{
* print(11); yield WaitForFixedUpdate;*
// Traçage du chemin
if (direction==0)
{
* print(30); yield WaitForFixedUpdate;*
grille[pos[0]][pos[1]] = 2;
grille[pos[0]][pos[1]-1] = 2;
grille[pos[0]][pos[1]-2] = 2;
pos[1] -= 2;
}
else if (direction==1)
{
* print(26); yield WaitForFixedUpdate;*
grille[pos[0]][pos[1]] = 2;
grille[pos[0]+1][pos[1]] = 2;
grille[pos[0]+2][pos[1]] = 2;
pos[0] += 2;
}
else if (direction==2)
{
* print(27); yield WaitForFixedUpdate;*
grille[pos[0]][pos[1]] = 2;
grille[pos[0]][pos[1]+1] = 2;
grille[pos[0]][pos[1]+2] = 2;
pos[1] += 2;
}
else if (direction==3)
{
* print(28); yield WaitForFixedUpdate;*
grille[pos[0]][pos[1]] = 2;
grille[pos[0]-1][pos[1]] = 2;
grille[pos[0]-2][pos[1]] = 2;
pos[0] -= 2;
}
* print(29); yield WaitForFixedUpdate;*
deplacements[compteur] = direction;
* print(compteur); yield WaitForFixedUpdate;*
compteur++;
nbrMurs–;
* print(“nbrMurs” + nbrMurs); yield WaitForFixedUpdate;*
}

// Si c’est un cul de sac
else
{
* print(15); yield WaitForFixedUpdate;*
// Retour en arrière
compteur–;
if (deplacements[compteur]==0)
pos[1] += 2;
else if (deplacements[compteur]==1)
pos[0] -= 2;
else if (deplacements[compteur]==2)
pos[1] -= 2;
else if (deplacements[compteur]==3)
pos[0] += 2;
}
}
while (nbrMurs>0);

// Affichage du labyrinthe
for (i=0; i<limite; i++)
{ print(17); yield WaitForFixedUpdate;
for (j=0; j<limite; j++)
{
* print(18); yield WaitForFixedUpdate;*
if (grille*[j]==0)*
{
* print(19); yield WaitForFixedUpdate;*
var wall : GameObject;
var position : Vector3 = this.transform.position;
position[0] += (j * 0.1);
position[1] += (i * 0.1);
wall = Instantiate(mur, position, Quaternion.identity);
wall.name = “Wall”;
}
}
}
}

My problem is solved!

If you wanna know what was going wrong, it came from the fact that when I check the possible directions, I put value 1 in an array if it’s a good way, and a 0 if it isn’t. But sometimes, in the case that the position was fine for the first conditions, there was no value to assign so the script used the last value!

Here is the code that works perfectly:

// Variables
private var dimension : int = 15;
private var limite : int = dimension * 2 + 1;
private var direction : int;
private var compteur : int = 0;
private var nbrMurs : int = dimension * dimension - 1;
private var i : int;
private var j : int;
private var possibilites : int;
 
private var grille = new Array(limite);
private var pos = new Array(2);
private var posTest = new Array(2);
private var cases = new Array(4);
private var deplacements = new Array(dimension * dimension);
 
public var mur : GameObject;
 
 
// Fonction principale ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function Start ()
{
   // Initialisation de la grille
   for (i=0; i<limite; i++)
   {
      grille *= new Array(limite);*

}
for (i=0; i<limite; i++)
{
for (j=0; j<limite; j++)
{
if ((i % 2) != 0 && (j % 2) != 0)
grille*[j] = 1;*
else
grille*[j] = 0;*
}
}

// Choix de la première case
for (i=0; i<2; i++)
{
do
{
pos = parseInt(Random.Range(0, (limite - 1)));
}
while ((pos % 2)==0);
}

// Génération du labyrinthe
do
{
// Choix de la direction
possibilites = 0;
for (i=0; i<4; i++)
{
// Choix de la case à tester
if (i==0)
{
posTest[0] = pos[0];
posTest[1] = pos[1] - 2;
}
else if (i==1)
{
posTest[0] = pos[0] + 2;
posTest[1] = pos[1];
}
else if (i==2)
{
posTest[0] = pos[0];
posTest[1] = pos[1] + 2;
}
else if (i==3)
{
posTest[0] = pos[0] - 2;
posTest[1] = pos[1];
}
// Teste de la case
if (posTest[0]>0 && posTest[0]<(limite-1) && posTest[1]>0 && posTest[1]<(limite-1))
{
if (grille[posTest[0]][posTest[1]]==1)
{
cases = 1;
possibilites++;
}
else
_ cases = 0;
}
else
cases = 0;
// Définition de la direction
if (possibilites>0)
{
do
{
direction = parseInt(Random.Range(0, 4));
}
while (cases[direction]!=1);
}
else
direction = 4;
}_

// Si un chemin est possible
if (direction<4)
{
// Traçage du chemin
if (direction==0)
{
grille[pos[0]][pos[1]] = 2;
grille[pos[0]][pos[1]-1] = 2;
grille[pos[0]][pos[1]-2] = 2;
pos[1] -= 2;
}
else if (direction==1)
{
grille[pos[0]][pos[1]] = 2;
grille[pos[0]+1][pos[1]] = 2;
grille[pos[0]+2][pos[1]] = 2;
pos[0] += 2;
}
else if (direction==2)
{
grille[pos[0]][pos[1]] = 2;
grille[pos[0]][pos[1]+1] = 2;
grille[pos[0]][pos[1]+2] = 2;
pos[1] += 2;
}
else if (direction==3)
{
grille[pos[0]][pos[1]] = 2;
grille[pos[0]-1][pos[1]] = 2;
grille[pos[0]-2][pos[1]] = 2;
pos[0] -= 2;
}
deplacements[compteur] = direction;
compteur++;
nbrMurs–;
}

// Si c’est un cul de sac
else
{
// Retour en arrière
compteur–;
if (deplacements[compteur]==0)
pos[1] += 2;
else if (deplacements[compteur]==1)
pos[0] -= 2;
else if (deplacements[compteur]==2)
pos[1] -= 2;
else if (deplacements[compteur]==3)
pos[0] += 2;
}
}
while (nbrMurs>0);

// Affichage du labyrinthe
for (i=0; i<limite; i++)
{
for (j=0; j<limite; j++)
{
if (grille*[j]==0)*
{
var wall : GameObject;
var position : Vector3 = this.transform.position;
position[0] += (j * 0.1);
position[1] += (i * 0.1);
wall = Instantiate(mur, position, Quaternion.identity);
wall.name = “Wall”;
}
}
}
}
Thank you very much!
See you!