public Area(Vetor2 posicaoMatriz)
{
this.posicaoMatriz = posicaoMatriz;
tema = "semtema";
dungeonInserida = null;
//Toda área possui uma dificuldade, logo será randomizado uma dificuldade:
System.Random rnd = new System.Random(Guid.NewGuid().GetHashCode());
int resultRand = rnd.Next(1, 411);
if (resultRand >= 1 && resultRand <= 20)
{
this.dificuldade = 0;
}
if (resultRand >= 21 && resultRand <= 250)
{
this.dificuldade = 1;
}
if (resultRand >= 251 && resultRand <= 380)
{
this.dificuldade = 2;
}
if (resultRand >= 381 && resultRand <= 400)
{
this.dificuldade = 3;
}
if (resultRand >= 401 && resultRand <= 409)
{
this.dificuldade = 4;
}
if (resultRand >= 410)
{
this.dificuldade = 5;
}
}
//
public void CriarAreaBoss(Zona zonaInserida)
{
Vetor2 auxTamMin = new Vetor2(0, 0);
Vetor2 auxTamMax = new Vetor2(0, 0);
zonaInserida.bossArea = new Area(null);
zonaInserida.bossArea.boss = true;
auxTamMin.x = Config.tamanhoMinDungeon.x;
auxTamMin.y = Config.tamanhoMinDungeon.y;
auxTamMax.x = Config.tamanhoMaxDungeon.x;
auxTamMax.y = Config.tamanhoMaxDungeon.y;
Config.tamanhoMinDungeon.x = 100;
Config.tamanhoMinDungeon.y = 40;
Config.tamanhoMaxDungeon.x = 100;
Config.tamanhoMaxDungeon.y = 40;
zonaInserida.bossArea.dungeonInserida = new Dungeon(zonaInserida.bossArea);
zonaInserida.bossArea.dungeonInserida.dungeon[Config.tamanhoMaxDungeon.x / 2, 2].spawnsbPlayer = true;
zonaInserida.bossArea.dungeonInserida.dungeon[Config.tamanhoMaxDungeon.x / 2, Config.tamanhoMaxDungeon.y - 3].spawnsbBoss = true;
Config.tamanhoMinDungeon.x = auxTamMin.x;
Config.tamanhoMinDungeon.y = auxTamMin.y;
Config.tamanhoMaxDungeon.x = auxTamMax.x;
Config.tamanhoMaxDungeon.y = auxTamMax.y;
for (int i = 1; i < zonaInserida.bossArea.dungeonInserida.tamanhoDungeon.y - 1; i++)
{
for (int j = 1; j < zonaInserida.bossArea.dungeonInserida.tamanhoDungeon.x - 1; j++)
{
if (zonaInserida.bossArea.dungeonInserida.dungeon[j, i].tipoCelula != "caminho")
{
zonaInserida.bossArea.dungeonInserida.dungeon[j, i].tipoCelula = "caminho";
}
}
}
}
public void CriarAreasSecretas(Zona zonaInserida, int totalAreasCriadas, Vetor2[] coordAreasSecretas, int nAreasSecretas, System.Random rnd)
{
int nAdjacentes;
bool permissao = false;
Vetor2 novaCoord;
//numeroDeAreasRandomizado---
if (totalAreasCriadas >= nAreasSecretas)
{
//interrompe a recursão.
return;
}
else
{
while (permissao == false)
{
int coordx = rnd.Next(1, Config.tamanhoMatrizZona.x - 2);
int coordy = rnd.Next(1, Config.tamanhoMatrizZona.y - 2);
nAdjacentes = 0;
//checa se a posicao da matriz está vazia
if (zonaInserida.zona[coordx, coordy] == null)
{
//checa os adjacentes:
//cima:
if (zonaInserida.zona[coordx, coordy - 1] != null)
{
nAdjacentes++;
}
//baixo
if (zonaInserida.zona[coordx, coordy + 1] != null)
{
nAdjacentes++;
}
//esquerda
if (zonaInserida.zona[coordx - 1, coordy] != null)
{
nAdjacentes++;
}
//direita
if (zonaInserida.zona[coordx + 1, coordy] != null)
{
nAdjacentes++;
}
if (nAdjacentes > 0)
{
//insere uma area na posicao da matriz.
novaCoord = new Vetor2(coordx, coordy);
zonaInserida.zona[coordx, coordy] = new Area(novaCoord);
zonaInserida.zona[coordx, coordy].secreta = true;
totalAreasCriadas++;
coordAreasSecretas[totalAreasCriadas] = novaCoord;
permissao = true;
}
}
}
//Chama a recursão:
CriarAreasSecretas(zonaInserida, totalAreasCriadas, coordAreasSecretas, nAreasSecretas, rnd);
}
}
public bool spawnItem = false; //identificar se já tem um item spawnando na celula;
public Celula(Vetor2 coordCelulaDun, string tipoCelula)
{
//Pegando a cordenada da celula em questão.
this.coordCelulaDun = coordCelulaDun;
//Pegando o tipo da celula em questão.
this.tipoCelula = tipoCelula;
idCelula = idCelula++;
}
public void PrimeiraArea(Zona zonaInserida)
{
Vetor2 coordAtual = new Vetor2((Config.tamanhoMatrizZona.x / 2), (Config.tamanhoMatrizZona.y / 2));
Area areaCriada = new Area(coordAtual);
zonaInserida.zona[coordAtual.x, coordAtual.y] = areaCriada;
coordAreas[0] = coordAtual;
}
//
public void EscolherAreaInicial(Zona zonaInserida)
{
System.Random rnd = new System.Random(Guid.NewGuid().GetHashCode());
int posicaoRandom = rnd.Next(0, numeroDeAreas);
Vetor2 coordAreaInicial = coordAreas[posicaoRandom];
zonaInserida.zona[coordAreaInicial.x, coordAreaInicial.y].inicial = true;
this.areaInicial = coordAreaInicial;
}
public Button2D(EpicoGraphics engine, Controle2D parent)
{
_epico = engine;
Nome = _nomePadrao;
Parent = parent ?? throw new ArgumentNullException(nameof(parent));
Vetor2 proxPos = ProximoPosControle();
GerarControle(proxPos.X, proxPos.Y, 100, 100);
Mat_render.CorSolida = new RGBA(200, 0, 200, 88);
}
public void EscolherAreaFinal(Zona zonaInserida)
{
System.Random rnd = new System.Random(Guid.NewGuid().GetHashCode());
bool loop = true;
while (loop == true)
{
int posicaoRandom = rnd.Next(0, numeroDeAreas);
Vetor2 coordAreaFinal = coordAreas[posicaoRandom];
if (zonaInserida.zona[coordAreaFinal.x, coordAreaFinal.y].inicial == false)
{
zonaInserida.zona[coordAreaFinal.x, coordAreaFinal.y].final = true;
this.areaFinal = coordAreaFinal;
loop = false;
}
}
}
public static bool AdicionarJogadorEmSessao(Jogador jogadorAlvo, Sessao sessaoAlvo)
{
if (ChecarSessaoCheia(sessaoAlvo))
{
return(false);
}
else
{
int slot = ChecarQtdJogadoresSessao(sessaoAlvo);
sessaoAlvo.jogadoresNaSessao[slot] = jogadorAlvo;
jogadorAlvo.sessaoAtual = sessaoAlvo;
//
int x, y;
//Caso eu não queria usar o vetor coordAreas: (não lembro se no coordAreas tá inclusa as áreas secretas, mas acredito que não).(checarei depois no console)
/*
* List<Area> areasDaZona = new List<Area>();
* foreach (Area a in sessaoAlvo.zonaDaSessao.zona)
* {
* if (a != null)
* {
* areasDaZona.Add(a);
* }
* }
*/
//(se eu quiser incluir as areas secretas como possibilidade de spawn, talvez seja melhor usar o codigo a cima usando lista.)
Random rnd = new Random();
int indice = rnd.Next(0, sessaoAlvo.zonaDaSessao.numeroDeAreas);
x = sessaoAlvo.zonaDaSessao.coordAreas[indice].x;
y = sessaoAlvo.zonaDaSessao.coordAreas[indice].y;
//
jogadorAlvo.areaAtual = sessaoAlvo.zonaDaSessao.zona[x, y];
Vetor2 aux = Area.RandomizarCelulaArea("caminho", jogadorAlvo.areaAtual).coordCelulaDun;
jogadorAlvo.coordJogadorX = aux.x;
jogadorAlvo.coordJogadorY = aux.y;
}
return(true);
}
public void gerarGrafico(Area areaPai, int linha, int coluna)
{
Dungeon dungeonInstanciada = areaPai.dungeonInserida;
Vector3 boundsmin = new Vector3(0, 0, 0), boundsmax = new Vector3(0, 0, 0);
//inicio do teste no console do sistema de dificuldade de salas e areas
if (areaPai.boss == false)
{
print("x: " + areaPai.posicaoMatriz.x + " / y: " + areaPai.posicaoMatriz.y + " dificuldade: " + areaPai.dificuldade);
for (int i = 0; i < areaPai.dungeonInserida.numeroSalas; i++)
{
print("x: " + areaPai.posicaoMatriz.x + " / y: " + areaPai.posicaoMatriz.y + " idsala: " + areaPai.dungeonInserida.salas[i].idSala + " dificuldade: " + areaPai.dungeonInserida.salas[i].dificuldade);
}
}
//fim do teste no console do sistema de dificuldade de salas e areas
for (int i = 0; i < dungeonInstanciada.tamanhoDungeon.x; i++)
{
for (int j = 0; j < dungeonInstanciada.tamanhoDungeon.y; j++)
{
Vetor2 v = new Vetor2(0, 0);
Celula cel = new Celula(v, " ");
cel = dungeonInstanciada.dungeon[i, j];
tileCoord = new Vector3(linha * 2 * Config.tamanhoMaxDungeon.x * tileSize + cel.coordCelulaDun.x * tileSize, -1 * coluna * 2 * Config.tamanhoMaxDungeon.y * tileSize + cel.coordCelulaDun.y * -1 * tileSize, 0); //eixo y está invertido, pois o sistema de coordenadas que usei na matriz foi diferente. Invertendo ele renderiza nos lugares corretos da matriz//onde tem tileSize antes tinha um "2".
gerarString(cel.tipoCelula, cel.subTipoCelula, tileCoord, cel.ehEntradaSecreta, cel.spawn, cel.spawnBoss, cel.spawnsbBoss, cel);
if (i == 0 && j == dungeonInstanciada.tamanhoDungeon.y - 1)
{
boundsmin.x = tileCoord.x;
boundsmin.y = tileCoord.y;
}
if (i == dungeonInstanciada.tamanhoDungeon.x - 1 && j == 0)
{
Vector3 calibragemSize = new Vector3(0, 0), calibragemPosition = new Vector3(0, 0);
if (dungeonInstanciada.tamanhoDungeon.x % 2 == 0)
{
calibragemSize = new Vector3(tileSize, calibragemSize.y);
calibragemPosition = new Vector3(1, calibragemPosition.y);
}
if (dungeonInstanciada.tamanhoDungeon.x % 2 == 1)
{
calibragemSize = new Vector3(tileSize, calibragemSize.y);
calibragemPosition = new Vector3(calibragemPosition.x, calibragemPosition.y);
}
if (dungeonInstanciada.tamanhoDungeon.y % 2 == 0)
{
calibragemSize = new Vector3(calibragemSize.x, tileSize);
calibragemPosition = new Vector3(calibragemPosition.x, -1);
}
if (dungeonInstanciada.tamanhoDungeon.y % 2 == 1)
{
calibragemSize = new Vector3(calibragemSize.x, tileSize);
calibragemPosition = new Vector3(calibragemPosition.x, calibragemPosition.y);
}
boundsmax.x = tileCoord.x;
boundsmax.y = tileCoord.y;
cameraBoundInstanciada = Instantiate(cameraBound, tileCoord, Quaternion.identity);
cameraBoundCollider = cameraBoundInstanciada.GetComponent <BoxCollider2D>();
Bounds bounds = new Bounds();
bounds.SetMinMax(boundsmin, boundsmax);
cameraBoundCollider.bounds.center.Set(bounds.center.x, bounds.center.y, bounds.center.z);
cameraBoundCollider.size = bounds.size + calibragemSize;
cameraBoundCollider.offset = new Vector3(0, 0);
cameraBoundCollider.transform.position = new Vector3(linha * 2 * Config.tamanhoMaxDungeon.x * tileSize + ((dungeonInstanciada.tamanhoDungeon.x - 1) / 2) * tileSize, -1 * coluna * 2 * Config.tamanhoMaxDungeon.y * tileSize + (-1 * (dungeonInstanciada.tamanhoDungeon.y - 1) / 2) * tileSize, 0) + calibragemPosition;
}
}
}
//posicionando tiles anti-exploit
for (int i = -1; i <= dungeonInstanciada.tamanhoDungeon.x; i++)
{
for (int j = -1; j <= dungeonInstanciada.tamanhoDungeon.y; j++)
{
if ((i == -1 || j == -1) || (i == dungeonInstanciada.tamanhoDungeon.x || j == dungeonInstanciada.tamanhoDungeon.y))
{
tileCoord = new Vector3(linha * 2 * Config.tamanhoMaxDungeon.x * 2 + i * 2, -1 * coluna * 2 * Config.tamanhoMaxDungeon.y * 2 + j * -2, 0); //eixo y está invertido, pois o sistema de coordenadas que usei na matriz foi diferente. Invertendo ele renderiza nos lugares corretos da matriz.
Instantiate(tileAntiExploit, tileCoord, Quaternion.identity);
}
}
}
}
public Sala()
{
//Instanciando a Randomizacao
System.Random tamanho = new System.Random(Guid.NewGuid().GetHashCode());
// Gerando valores aleatorios de coordenada x e y, para instanciar o vector.
int x = tamanho.Next(Config.tamanhoMinSala.x, Config.tamanhoMaxSala.x);
int y = tamanho.Next(Config.tamanhoMinSala.y, Config.tamanhoMaxSala.y);
Vetor2 tamanhoSala = new Vetor2(x, y);
Celula[,] sala = new Celula[tamanhoSala.x, tamanhoSala.y];
this.tamanhoSala = tamanhoSala;
int numeroPortas = tamanho.Next(Config.numeroMinPortas, Config.numeroMaxPortas);
this.numeroPortas = numeroPortas;
//Preenchendo a Sala;
for (int i = 0; i < tamanhoSala.y; i++)
{
for (int j = 0; j < tamanhoSala.x; j++)
{
if (j == 0 || i == 0 || j == (tamanhoSala.x - 1) || i == (tamanhoSala.y - 1))
{
Vetor2 coordPreenchida = new Vetor2(j, i);
Celula celulaPreencheu = new Celula(coordPreenchida, "pSala");
//adicionando subtipo*
if (j == 0 && i == 0)
{
celulaPreencheu.subTipoCelula = "quinaECp";
}
if (j == 0 && i == (tamanhoSala.y - 1))
{
celulaPreencheu.subTipoCelula = "quinaEBp";
}
if (j == 0 && i != (tamanhoSala.y - 1) && i != 0)
{
celulaPreencheu.subTipoCelula = "esquerdap";
}
if (j == (tamanhoSala.x - 1) && i == 0)
{
celulaPreencheu.subTipoCelula = "quinaDCp";
}
if (j == (tamanhoSala.x - 1) && i == (tamanhoSala.y - 1))
{
celulaPreencheu.subTipoCelula = "quinaDBp";
}
if (j == (tamanhoSala.x - 1) && i != (tamanhoSala.y - 1) && i != 0)
{
celulaPreencheu.subTipoCelula = "direitap";
}
if (i == 0 && j != 0 && j != (tamanhoSala.x - 1))
{
celulaPreencheu.subTipoCelula = "cimap";
}
if (i == tamanhoSala.y - 1 && j != 0 && j != (tamanhoSala.x - 1))
{
celulaPreencheu.subTipoCelula = "baixop";
}
celulaPreencheu.coordCelulaSala = coordPreenchida;
sala[j, i] = celulaPreencheu;
}
else
{
Vetor2 coordPreenchida = new Vetor2(j, i);
Celula celulaPreencheu = new Celula(coordPreenchida, "chao");
celulaPreencheu.coordCelulaSala = coordPreenchida;
sala[j, i] = celulaPreencheu;
}
}
}
//Adicionando Portas.
for (int i = 0; i < numeroPortas; i++)
{
int xPorta = tamanho.Next(2, tamanhoSala.x - 3);
int yPorta = tamanho.Next(2, tamanhoSala.y - 3);
int ladoPorta = tamanho.Next(1, 5);
Vetor2 coordPreenchida2 = new Vetor2(0, 0);
string subtipo = "";
switch (ladoPorta)
{
case 1:
coordPreenchida2 = new Vetor2(0, yPorta);
subtipo = "esquerdap";
break;
case 2:
coordPreenchida2 = new Vetor2(tamanhoSala.x - 1, yPorta);
subtipo = "direitap";
break;
case 3:
coordPreenchida2 = new Vetor2(xPorta, 0);
subtipo = "cimap";
break;
case 4:
coordPreenchida2 = new Vetor2(xPorta, tamanhoSala.y - 1);
subtipo = "baixop";
break;
}
Celula celulaPreencheu = new Celula(coordPreenchida2, "porta");
celulaPreencheu.ehPorta = true;
celulaPreencheu.subTipoCelula = subtipo;
celulaPreencheu.coordCelulaSala = coordPreenchida2;
sala[coordPreenchida2.x, coordPreenchida2.y] = celulaPreencheu;
}
this.sala = sala;
}
public ColisaoPoligonoConvexoResultado PoligonoConvexo(
Objeto2D objetoA, Objeto2D objetoB, Vetor2 movimento)
{
ColisaoPoligonoConvexoResultado resultado = new ColisaoPoligonoConvexoResultado();
resultado.Intersecao = true;
resultado.Interceptar = true;
int arestaQuantA = objetoA.Arestas.Count;
int arestaQuantB = objetoB.Arestas.Count;
float minIntervalDistance = float.PositiveInfinity;
Vetor2 EixoTranslacao = new Vetor2();
Vetor2 aresta;
// Loop através de todas as bordas de ambos os polígonos
for (int indiceAresta = 0; indiceAresta < arestaQuantA + arestaQuantB; indiceAresta++)
{
if (indiceAresta < arestaQuantA)
{
aresta = objetoA.Arestas[indiceAresta];
}
else
{
aresta = objetoB.Arestas[indiceAresta - arestaQuantA];
}
// ===== 1. Descobrir se os polígonos estão se cruzando atualmente =====
// Encontre o eixo perpendicular à borda atual
Vetor2 eixo = new Vetor2(objetoA, -aresta.Y, aresta.X);
eixo.Normalizar <Eixos>();
// Encontre a projeção do polígono no eixo atual
float minA = 0; float minB = 0; float maxA = 0; float maxB = 0;
ProjecaoPoligono(eixo, objetoA, ref minA, ref maxA);
ProjecaoPoligono(eixo, objetoB, ref minB, ref maxB);
// Verifique se as projeções de polígono estão se cruzando atualmente
if (DistanciaDoIntervalo(minA, maxA, minB, maxB) > 0)
{
resultado.Intersecao = false;
}
// ===== 2. Agora, encontre os polígonos que irão se *cruzar* =====
// Projetar a velocidade no eixo atual
float velocidadeProjecao = eixo.Produto(movimento);
// Obter a projeção do polígono A durante o movimento
if (velocidadeProjecao < 0)
{
minA += velocidadeProjecao;
}
else
{
maxA += velocidadeProjecao;
}
// Faça o mesmo teste acima para a nova projeção
float distanciaDoIntervalo = DistanciaDoIntervalo(minA, maxA, minB, maxB);
if (distanciaDoIntervalo > 0)
{
resultado.Interceptar = false;
}
// Se os polígonos não estiverem se cruzando e não se cruzarem, saia do loop
if (!resultado.Intersecao && !resultado.Interceptar)
{
break;
}
// Verifique se a distância atual do intervalo é a mínima.
// Em caso afirmativo, armazene a distância do intervalo e a distância atual.
// Isso será usado para calcular o vetor de transladação mínima
distanciaDoIntervalo = Math.Abs(distanciaDoIntervalo);
if (distanciaDoIntervalo < minIntervalDistance)
{
minIntervalDistance = distanciaDoIntervalo;
EixoTranslacao = eixo;
Vetor2 d = new Vetor2(objetoA, (Vetor2)(objetoA.Centro.Global - objetoB.Centro.Global));
if (d.Produto(EixoTranslacao) < 0)
{
EixoTranslacao = -EixoTranslacao;
}
}
}
// O vetor de transladação mínimo pode ser usado para pressionar os polígonos.
// Primeiro move os polígonos pela sua velocidade e, em seguida, move PoligonoA por TransladacaoMinimaVetor.
if (resultado.Interceptar)
{
resultado.TranslacaoMinimaVetor = EixoTranslacao * minIntervalDistance;
}
return(resultado);
}
public void PreencherZona(Zona zonaInserida, Area areaPartida, int totalAreasCriadas, Vetor2[] coordAreas, int nAreas, System.Random rnd)
{
bool permissao;
Vetor2 novaCoord;
//numeroDeAreasRandomizado---
if (totalAreasCriadas >= nAreas)
{
//interrompe a recursão.
return;
}
else
{
int porta = rnd.Next(0, 4);
switch (porta)
{
//Não cria;
case 0:
//baixo
//Cria;
novaCoord = new Vetor2(areaPartida.posicaoMatriz.x, areaPartida.posicaoMatriz.y + 1);
//Checa
permissao = true;
for (int i = 0; i <= totalAreasCriadas; i++)
{
if ((coordAreas[i].x == novaCoord.x && coordAreas[i].y == novaCoord.y) || (novaCoord.x >= Config.tamanhoMatrizZona.x || novaCoord.x >= Config.tamanhoMatrizZona.y) || (novaCoord.x < 1 || novaCoord.y < 1))
{
permissao = false;
}
}
//Insere
if (permissao == true)
{
zonaInserida.zona[areaPartida.posicaoMatriz.x, areaPartida.posicaoMatriz.y + 1] = new Area(novaCoord);
totalAreasCriadas++;
coordAreas[totalAreasCriadas] = novaCoord;
}
break;
case 1:
//cima:
//Cria;
novaCoord = new Vetor2(areaPartida.posicaoMatriz.x, areaPartida.posicaoMatriz.y - 1);
//Checa
permissao = true;
for (int i = 0; i <= totalAreasCriadas; i++)
{
if (coordAreas[i].x == novaCoord.x && coordAreas[i].y == novaCoord.y)
{
permissao = false;
}
}
//Insere
if (permissao == true)
{
zonaInserida.zona[areaPartida.posicaoMatriz.x, areaPartida.posicaoMatriz.y - 1] = new Area(novaCoord);
totalAreasCriadas++;
coordAreas[totalAreasCriadas] = novaCoord;
}
break;
case 2:
//esquerda
//Cria;
novaCoord = new Vetor2(areaPartida.posicaoMatriz.x - 1, areaPartida.posicaoMatriz.y);
//Checa
permissao = true;
for (int i = 0; i <= totalAreasCriadas; i++)
{
if (coordAreas[i].x == novaCoord.x && coordAreas[i].y == novaCoord.y)
{
permissao = false;
}
}
//Insere
if (permissao == true)
{
zonaInserida.zona[areaPartida.posicaoMatriz.x - 1, areaPartida.posicaoMatriz.y] = new Area(novaCoord);
totalAreasCriadas++;
coordAreas[totalAreasCriadas] = novaCoord;
}
break;
case 3:
//direita
//Cria;
novaCoord = new Vetor2(areaPartida.posicaoMatriz.x + 1, areaPartida.posicaoMatriz.y);
//Checa
permissao = true;
for (int i = 0; i <= totalAreasCriadas; i++)
{
if (coordAreas[i].x == novaCoord.x && coordAreas[i].y == novaCoord.y)
{
permissao = false;
}
}
//Insere
if (permissao == true)
{
zonaInserida.zona[areaPartida.posicaoMatriz.x + 1, areaPartida.posicaoMatriz.y] = new Area(novaCoord);
totalAreasCriadas++;
coordAreas[totalAreasCriadas] = novaCoord;
}
break;
}
//Chama a recursão:
if (totalAreasCriadas > (nAreas / 4))
{
PreencherZonaLimitado(zonaInserida, totalAreasCriadas, coordAreas, nAreas, rnd);
}
else
{
int posicaorandom = rnd.Next(0, totalAreasCriadas + 1);
PreencherZona(zonaInserida, zonaInserida.zona[coordAreas[posicaorandom].x, coordAreas[posicaorandom].y], totalAreasCriadas, coordAreas, nAreas, rnd);
//Console.WriteLine("entrou" + (totalAreasCriadas + 1));
}
}
}
public void PreencherZonaLimitado(Zona zonaInserida, int totalAreasCriadas, Vetor2[] coordAreas, int nAreas, System.Random rnd)
{
int nAdjacentes;
bool permissao = false;
Vetor2 novaCoord;
//numeroDeAreasRandomizado---
if (totalAreasCriadas >= nAreas)
{
//interrompe a recursão.
return;
}
else
{
while (permissao == false)
{
int coordx = rnd.Next(1, Config.tamanhoMatrizZona.x - 2);
int coordy = rnd.Next(1, Config.tamanhoMatrizZona.y - 2);
nAdjacentes = 0;
//checa se a posicao da matriz está vazia
if (zonaInserida.zona[coordx, coordy] == null)
{
//checa os adjacentes:
//cima:
if (zonaInserida.zona[coordx, coordy - 1] != null)
{
nAdjacentes++;
}
//baixo
if (zonaInserida.zona[coordx, coordy + 1] != null)
{
nAdjacentes++;
}
//esquerda
if (zonaInserida.zona[coordx - 1, coordy] != null)
{
nAdjacentes++;
}
//direita
if (zonaInserida.zona[coordx + 1, coordy] != null)
{
nAdjacentes++;
}
if (nAdjacentes > 0 && nAdjacentes < 2)
{
//insere uma area na posicao da matriz.
novaCoord = new Vetor2(coordx, coordy);
zonaInserida.zona[coordx, coordy] = new Area(novaCoord);
totalAreasCriadas++;
coordAreas[totalAreasCriadas] = novaCoord;
permissao = true;
}
}
}
//Chama a recursão:
if (totalAreasCriadas > (nAreas / 4))
{
PreencherZonaLimitado(zonaInserida, totalAreasCriadas, coordAreas, nAreas, rnd);
}
else
{
int posicaorandom = rnd.Next(0, totalAreasCriadas + 1);
PreencherZona(zonaInserida, zonaInserida.zona[coordAreas[posicaorandom].x, coordAreas[posicaorandom].y], totalAreasCriadas, coordAreas, nAreas, rnd);
//Console.WriteLine("entrou" + (totalAreasCriadas + 1));
}
}
}
