// on crée la grille avec le nombre de colonnes et de ligens
public grille()
{
for (int y = 0; y < horizontal; y++)
{
for (int x = 0; x < vertical; x++)
{
tab[y, x] = new cellule(y, x);
}
}
}
// on crée la grille avec le nombre de colonnes et de ligens
public grille()
{
for (int y = 0; y < horizontal; y++)
{
for (int x = 0; x < vertical; x++)
{
tab[y, x] = new cellule(y, x);
}
}
}
unsafe void generate_lab(cellule[] G, int nx, int ny)
{
cellule[] T = new cellule[nx * ny];
System.Random rnd = new System.Random();
int r = rnd.Next(0, nx * ny);
T[0] = G[r];
int lengthT = 1;
int n = nx * ny;
List <int> GR = new List <int>();
for (int i = 0; i < n; i++)
{
GR.Add(i);
}
GR.Remove(r);
int dir_x = 1;
int dir_y = 1;
int go_x = 1;
int go_y = 1;
while (lengthT < n)
{
int i_target = rnd.Next(0, n - lengthT);
i_target = GR[i_target];
GR.Remove(i_target);
int index_ofcc = get_closest_cell(T, G, nx, lengthT, i_target);
if ((G[index_ofcc].x - G[i_target].x) > 0)
{
dir_x = -1;
}
if ((G[index_ofcc].y - G[i_target].y) > 0)
{
dir_y = -1;
}
if (G[i_target].x == G[index_ofcc].x)
{
go_x = 0;
}
if (G[i_target].y == G[index_ofcc].y)
{
go_y = 0;
}
create_link(T, G, nx, ny, ref lengthT, index_ofcc, i_target, dir_x, dir_y, go_x, go_y, GR, false);
dir_x = 1;
dir_y = 1;
go_x = 1;
go_y = 1;
}
}
unsafe cellule[] generate_grille(int nx, int ny)
{
cellule[] G = new cellule[nx * ny];
int i = 0;
for (int y = 0; y < ny; y++)
{
for (int x = 0; x < nx; x++)
{
G[i] = new cellule();
G[i].x = x;
G[i].y = y;
G[i].left = null;
G[i].right = null;
i++;
}
}
return(G);
}
// on ajoute un bateau selon une cellule de départ et une direction
public bool ajoutBateau(bateau bateau, cellule cellule, direction direction)
{
int taille = bateau.taille;
int x = cellule.x;
int y = cellule.y;
// on vérifie le placement d'un bateau en position verticale vers le bas
switch (direction)
{
case direction.bas:
//on vérifie si il y a asser de place pour le placement du bateau
// la taille du bateau + la valeur de la cellule de départ ne peut dépasser la longueur totale de la colonne
if (y + taille <= 10)
{
// on initialise une variable bool à true
bool ok = true;
// on fait une boucle pour la taille du bateau
for (int i = 0; i < taille; i++)
{
if (tab[y+i, x].etat != etat.eau)
{
ok = false;
}
}
if (ok)
{
// on fait une boucle pour la taille du bateau
for (int i = 0; i < taille; i++)
{
// on place le bateau
tab[y+i, x].ajoutBateau(bateau);
}
return true;
}
else
{
return false;
}
}
else
{
return false;
}
case direction.haut:
//la taille de vérification doit être inversée du fait qu'on remonte vers la cellule 0
if (y - taille >= 0)
{
bool ok = true;
for (int i = 0; i < taille; i++)
{
if (tab[y-i,x].etat != etat.eau)
{
ok = false;
}
}
if (ok)
{
for (int i = 0; i < taille; i++)
{
tab[y-i, x].ajoutBateau(bateau);
}
return true;
}
else
{
return false;
}
}
else
{
return false;
}
case direction.gauche:
if (x - taille >= 0)
{
bool ok = true;
for (int i = 0; i < taille; i++)
{
if (tab[y, x-i].etat != etat.eau)
{
ok = false;
}
}
if (ok)
{
for (int i = 0; i < taille; i++)
{
tab[y, x-i].ajoutBateau(bateau);
}
return true;
}
else
{
return false;
}
}
else
{
return false;
}
case direction.droite:
if (x + taille <= 10)
{
bool ok = true;
for (int i = 0; i < taille; i++)
{
if (tab[y, x+i].etat != etat.eau)
{
ok = false;
}
}
if (ok)
{
for (int i = 0; i < taille; i++)
{
tab[y, x+i].ajoutBateau(bateau);
}
return true;
}
else
{
return false;
}
}
else
{
return false;
}
default:
return false;
}
}
// on ajoute un bateau selon une cellule de départ et une direction
public bool ajoutBateau(bateau bateau, cellule cellule, direction direction)
{
int taille = bateau.taille;
int x = cellule.x;
int y = cellule.y;
// on vérifie le placement d'un bateau en position verticale vers le bas
switch (direction)
{
case direction.bas:
//on vérifie si il y a asser de place pour le placement du bateau
// la taille du bateau + la valeur de la cellule de départ ne peut dépasser la longueur totale de la colonne
if (y + taille <= 10)
{
// on initialise une variable bool à true
bool ok = true;
// on fait une boucle pour la taille du bateau
for (int i = 0; i < taille; i++)
{
if (tab[y + i, x].etat != etat.eau)
{
ok = false;
}
}
if (ok)
{
// on fait une boucle pour la taille du bateau
for (int i = 0; i < taille; i++)
{
// on place le bateau
tab[y + i, x].ajoutBateau(bateau);
}
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
case direction.haut:
//la taille de vérification doit être inversée du fait qu'on remonte vers la cellule 0
if (y - taille >= 0)
{
bool ok = true;
for (int i = 0; i < taille; i++)
{
if (tab[y - i, x].etat != etat.eau)
{
ok = false;
}
}
if (ok)
{
for (int i = 0; i < taille; i++)
{
tab[y - i, x].ajoutBateau(bateau);
}
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
case direction.gauche:
if (x - taille >= 0)
{
bool ok = true;
for (int i = 0; i < taille; i++)
{
if (tab[y, x - i].etat != etat.eau)
{
ok = false;
}
}
if (ok)
{
for (int i = 0; i < taille; i++)
{
tab[y, x - i].ajoutBateau(bateau);
}
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
case direction.droite:
if (x + taille <= 10)
{
bool ok = true;
for (int i = 0; i < taille; i++)
{
if (tab[y, x + i].etat != etat.eau)
{
ok = false;
}
}
if (ok)
{
for (int i = 0; i < taille; i++)
{
tab[y, x + i].ajoutBateau(bateau);
}
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
default:
return(false);
}
}
unsafe public void generate()
{
generatebutton.interactable = false;
int nx = int.Parse(Xfield.text);
int ny = int.Parse(Yfield.text);
MazeSurface.localScale = new Vector3(nx, 0.2f, ny);
MazeSurface.position = new Vector3((float)(nx % 2) / 2, MazeSurface.position.y, (float)((ny + 1) % 2) / 2);
cellule[] G = new cellule[nx * ny];
G = generate_grille(nx, ny);
generate_lab(G, nx, ny);
Vector3 SpawnPosition = new Vector3(-nx / 2, 0.5f, ny / 2);
Vector3 nextPosition;
int n = nx * ny;
GameObject tempWall;
#region GenerateWalls
int k = 0;
for (int l = 0; l < nx; l++)
{
nextPosition = new Vector3(SpawnPosition.x + l + 0.5f, 0.5f, SpawnPosition.z + 0.5f);
tempWall = Instantiate(Wall, nextPosition, Quaternion.Euler(0.0f, 90.0f, 0.0f)) as GameObject;
tempWall.transform.parent = upperWall;
}
for (int j = 0; j < ny; j++)
{
nextPosition = new Vector3(SpawnPosition.x, 0.5f, SpawnPosition.z - j);
Instantiate(Wall, nextPosition, Quaternion.identity, leftWall);
for (int i = 0; i < nx; i++)
{
if (k + nx < n)
{
fixed(cellule *c1 = &G[k])
{
fixed(cellule *c2 = &G[k + nx])
{
if (!(c1->left == c2 || c1->right == c2 || c2->left == c1 || c2->right == c1))
{
nextPosition = new Vector3(SpawnPosition.x + i + 0.5f, 0.5f, SpawnPosition.z - j - 0.5f);
tempWall = Instantiate(Wall, nextPosition, Quaternion.Euler(0.0f, 90.0f, 0.0f)) as GameObject;
tempWall.transform.parent = maze;
}
}
}
}
else
{
nextPosition = new Vector3(SpawnPosition.x + i + 0.5f, 0.5f, SpawnPosition.z - j - 0.5f);
tempWall = Instantiate(Wall, nextPosition, Quaternion.Euler(0.0f, 90.0f, 0.0f)) as GameObject;
tempWall.transform.parent = lowerWall;
}
if (k + 1 < n)
{
fixed(cellule *c1 = &G[k])
{
fixed(cellule *c2 = &G[k + 1])
{
if (!(c1->left == c2 || c1->right == c2 || c2->left == c1 || c2->right == c1))
{
nextPosition = new Vector3(SpawnPosition.x + i + 1.0f, 0.5f, SpawnPosition.z - j);
if ((k + 1) % nx == 0)
{
Instantiate(Wall, nextPosition, Quaternion.identity, rightWall);
}
else
{
Instantiate(Wall, nextPosition, Quaternion.identity, maze);
}
}
}
}
}
else
{
nextPosition = new Vector3(SpawnPosition.x + i + 1.0f, 0.5f, SpawnPosition.z - j);
Instantiate(Wall, nextPosition, Quaternion.identity, rightWall);
}
k++;
}
}
#endregion
#region Enter/Exit
List <int> ids = new List <int>();
for (int i = 0; i < 4; i++)
{
ids.Add(i);
}
System.Random rnd = new System.Random();
int r = rnd.Next(0, 4);
startPosition = removewall(ids[r], nx, ny);
ids.Remove(ids[r]);
r = rnd.Next(0, 3);
endPosition = removewall(ids[r], nx, ny);
#endregion
NavSurface.BuildNavMesh();
SpawnButton.interactable = true;
}
