// Use this for initialization
void Start()
{
Poblation = new List <GameObject>();
for (int a = 0; a < Cantidad; a++)
{
GameObject _GO = Instantiate <GameObject>(OrganismModel);
ADN _ADN = _GO.GetComponent <ADN>();
_ADN.Target = Target;
_ADN.LIFE = LIFE;
_ADN.transform.position = new Vector3(-35f, 62f, 0f);
_ADN.InitializeLife(null);
Poblation.Add(_GO);
running = true;
}
}
public void combine(ADN D1, ADN D2)
{
for (int i = 0; i < adnLenght; i++)
{
if (i < adnLenght / 2.0f) // la mitad de las celulas
{
int c = D1.genes[i];
genes[i] = c;
}
else
{
int c = D2.genes[i];
genes[i] = c;
}
}
}
public void Init()
{
// estos son los comandos que le damos al character
//0 adelante
//1 atras
//2 derecha
//3 izquierda
// 4 salto
// 5 agacharse
adn = new ADN(dnaLenght, 6);
m_Character = GetComponent <ThirdPersonCharacter>();
timeAlive = 0;
alive = true;
startPos = this.transform.position;
}
public int Index([Microsoft.AspNetCore.Mvc.FromBody] ADN dna)
{
try
{
byte valueToSave = 0;
var personToInsert = new Person();
//Con este procedimiento unimos el Array para crear un solo String para almacenar
personToInsert.DNA = String.Join("", dna.dna);
var dnaAArray = dna.ToString();
// Invocamos al servicio que revisa todas las posibles variantes de concurrencias
bool flag = _sevicioMutant.IsMutant(dna);
if (flag)
{
valueToSave = 1;
}
else
{
valueToSave = 0;
}
personToInsert.Mutant = valueToSave;
BD.Person.Add(personToInsert);
BD.SaveChanges();
//De Acuerdo al resultado del servicio sabemos si es mutante o no se lo plasma con los requerimientos pedidos
if (valueToSave == 1)
{
//Es Mutante
return(StatusCodes.Status200OK);
}
else
{
//No es Mutante
return(StatusCodes.Status403Forbidden);
}
}
catch (Exception)
{
return(StatusCodes.Status500InternalServerError);
}
}
GameObject Breed(GameObject parent1, GameObject parent2)
{
Vector3 pos = new Vector3(Random.Range(-9, 9), Random.Range(-4.5f, 4.5f), 0);
GameObject go = Instantiate(personPrefab, pos, Quaternion.identity);
ADN adn1 = parent1.GetComponent <ADN>();
ADN adn2 = parent2.GetComponent <ADN>();
if (Random.Range(0, 10) < 9)
{
go.GetComponent <ADN>().r = Random.Range(0, 10) < 5 ? adn1.r : adn2.r;
go.GetComponent <ADN>().g = Random.Range(0, 10) < 5 ? adn1.g : adn2.g;
go.GetComponent <ADN>().b = Random.Range(0, 10) < 5 ? adn1.b : adn2.b;
go.GetComponent <ADN>().s = Random.Range(0, 10) < 5 ? adn1.s : adn2.s;
}
else
{
go.GetComponent <ADN>().r = Random.Range(0.0f, 1.0f);
go.GetComponent <ADN>().g = Random.Range(0.0f, 1.0f);
go.GetComponent <ADN>().b = Random.Range(0.0f, 1.0f);
go.GetComponent <ADN>().s = Random.Range(0.1f, 0.4f);
}
return(go);
}
public bool Insert()
{
try
{
using (var db = new LiteDatabase(@"C:\Temp\MyData.db"))
{
// Get a collection (or create, if doesn't exist)
var col = db.GetCollection <ADN>("ADN");
// Create your new customer instance
var adn = new ADN
{
Id = Guid.NewGuid().ToString(),
DateTime = DateTime.Now,
DNA = "",
Human = true,
Multant = false
};
// Insert new customer document (Id will be auto-incremented)
col.Insert(adn);
// Use LINQ to query documents
var results = col.Find(x => x.Human == true);
return(true);
}
}
catch (Exception e)
{
return(false);
}
}
private void CalculateResults()
{
WEIGHTS = new List <int>();
for (int a = 0; a < Poblation.Count; a++)
{
WEIGHTS.Add(Poblation[a].GetComponent <ADN>().WEIGHT);
}
Hello:
bool sw = false;
for (int a = 0; a < WEIGHTS.Count; a++)
{
if (a < WEIGHTS.Count - 2)
{
int W1 = WEIGHTS[a];
int W2 = WEIGHTS[a + 1];
if (W1 > W2)
{
WEIGHTS[a] = W2;
WEIGHTS[a + 1] = W1;
sw = true;
}
}
}
if (sw == true)
{
goto Hello;
}
weight1 = WEIGHTS[WEIGHTS.Count - 1];
weight2 = WEIGHTS[WEIGHTS.Count - 2];
ADN1 = new List <string[]>();
ADN2 = new List <string[]>();
for (int a = 0; a < Poblation.Count; a++)
{
if (Poblation[a].GetComponent <ADN>().WEIGHT == weight1)
{
ADN1 = new List <string[]>(Poblation[a].GetComponent <ADN>().MyADN);
}
;
if (Poblation[a].GetComponent <ADN>().WEIGHT == weight2)
{
ADN2 = new List <string[]>(Poblation[a].GetComponent <ADN>().MyADN);
}
;
}
bool change = false;
for (int a = 0; a < ADN1.Count; a++)
{
for (int b = 0; b < ADN1[a].Length; b++)
{
int RR = Random.Range(0, 10);
if (change == true && RR == 3)
{
string DNA1 = ADN1[a][b];
string DNA2 = ADN2[a][b];
ADN1[a][b] = DNA2;
ADN2[a][b] = DNA1;
change = false;
}
else
{
ADN1[a][b] = ADN1[a][b];
ADN2[a][b] = ADN2[a][b];
change = true;
}
}
}
GameObject[] GOL = GameObject.FindGameObjectsWithTag("Organismo");
for (int a = 0; a < GOL.Length; a++)
{
DestroyImmediate(GOL[a]);
}
Poblation.Clear();
Poblation = new List <GameObject>();
bool divide = false;
for (int a = 0; a < Cantidad; a++)
{
GameObject _GO = Instantiate <GameObject>(OrganismModel);
ADN _ADN = _GO.GetComponent <ADN>();
_ADN.Target = Target;
_ADN.LIFE = LIFE;
_ADN.transform.position = new Vector3(-35f, 62f, 0f);
if (divide == true)
{
_ADN.InitializeLife(ADN1, a == 0 || a == 1);
divide = false;
}
else
{
_ADN.InitializeLife(ADN2, a == 0 || a == 1);
divide = true;
}
Poblation.Add(_GO);
}
running = true;
}
public bool IsMutant(ADN ADN)
{
string[] chain = ADN.dna;
int concurrecias = 0;
int total = 0;
int concurrenciasHorizontal = 0;
int concurrenciasVertical = 0;
int concuDiagPrincipalIzDe = 0;
int concuDiagSec1zDeAba = 0;
int concuDiagSec2zDeAba = 0;
int concuDiagSec1zDeArriba = 0;
int concuDiagSec2zDeArriba = 0;
int concuDiagPrinDerIz = 0;
int concuDiagSec1DerIzAbajo = 0;
int concuDiagSec2DerIzAbajo = 0;
int concuDiagSec1DerIzArriba = 0;
int concuDiagSec2DerIzArriba = 0;
concurrenciasHorizontal = Horizontal(chain, concurrecias);
concurrenciasVertical = Vertical(chain, concurrecias);
concuDiagPrincipalIzDe = DiagonalPrinIzDe(chain, concurrecias);
concuDiagSec1zDeAba = DiagonalSec1IzDeAbajo(chain, concurrecias);
concuDiagSec2zDeAba = DiagonalSec2IzDeAbajo(chain, concurrecias);
concuDiagSec1zDeArriba = DiagonalSec1IzDeArriba(chain, concurrecias);
concuDiagSec2zDeArriba = DiagonalSec2IzDeArriba(chain, concurrecias);
concuDiagPrinDerIz = DiagonalPrinDerIz(chain, concurrecias);
concuDiagSec1DerIzAbajo = DiagonalSec1DerIzAbajo(chain, concurrecias);
concuDiagSec2DerIzAbajo = DiagonalSec2DerIzAbajo(chain, concurrecias);
concuDiagSec1DerIzArriba = DiagonalSec1DerIzArriba(chain, concurrecias);
concuDiagSec2DerIzArriba = DiagonalSec2DerIzArriba(chain, concurrecias);
total = concurrenciasHorizontal + concurrenciasVertical + concuDiagPrincipalIzDe + concuDiagSec1zDeAba + concuDiagSec2zDeAba +
concuDiagSec1zDeArriba + concuDiagSec2zDeArriba + concuDiagPrinDerIz + concuDiagSec1DerIzAbajo +
concuDiagSec2DerIzAbajo + concuDiagSec1DerIzArriba + concuDiagSec2DerIzArriba;
if (total >= 2)
{
return(true);
}
else
{
return(false);
}
int Horizontal(string[] dna, int concuHorizontal)
{
int contador = 0;
for (int fila = 0; fila < dna.Length; fila++)
{
for (int col = 0; col < dna.Length - 1; col++)
{
var c = dna[fila][col];
var comparar = dna[fila][col + 1];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 4)
{
concurrenciasHorizontal++;
}
}
}
return(concurrenciasHorizontal);
}
int Vertical(string[] dna, int concurrency)
{
int contador = 0;
for (int fila = 0; fila < dna.Length; fila++)
{
for (int col = 0; col < dna.Length - 1; col++)
{
var c = dna[col][fila];
var comparar = dna[col + 1][fila];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 4)
{
concurrenciasVertical++;
}
}
}
return(concurrenciasVertical);
}
int DiagonalPrinIzDe(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = 0; col < dna.Length - 1; col++)
{
var c = dna[col][col];
var comparar = dna[col + 1][col + 1];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagPrincipalIzDe++;
}
}
}
return(concuDiagPrincipalIzDe);
}
int DiagonalSec1IzDeAbajo(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = 0; col < dna.Length - 2; col++)
{
var c = dna[col + 1][col];
var comparar = dna[col + 2][col + 1];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagSec1zDeAba++;
}
}
}
return(concuDiagSec1zDeAba);
}
int DiagonalSec2IzDeAbajo(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = 0; col < dna.Length - 3; col++)
{
var c = dna[col + 2][col];
var comparar = dna[col + 3][col + 1];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagSec2zDeAba++;
}
}
}
return(concuDiagSec2zDeAba);
}
int DiagonalSec1IzDeArriba(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = 0; col < dna.Length - 2; col++)
{
var c = dna[col][col + 1];
var comparar = dna[col + 1][col + 2];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagSec1zDeArriba++;
}
}
}
return(concuDiagSec1zDeArriba);
}
int DiagonalSec2IzDeArriba(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = 0; col < dna.Length - 3; col++)
{
var c = dna[col][col + 2];
var comparar = dna[col + 1][col + 3];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagSec2zDeArriba++;
}
}
}
return(concuDiagSec2zDeArriba);
}
int DiagonalPrinDerIz(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = dna.Length - 1; col > 0; col--)
{
var c = dna[fila][col];
var comparar = dna[fila + 1][col - 1];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagPrinDerIz++;
}
fila++;
}
}
return(concuDiagPrinDerIz);
}
int DiagonalSec1DerIzAbajo(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = dna.Length - 1; col > 1; col--)
{
var c = dna[fila + 1][col];
var comparar = dna[fila + 2][col - 1];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagSec1DerIzAbajo++;
}
fila++;
}
}
return(concuDiagSec1DerIzAbajo);
}
int DiagonalSec2DerIzAbajo(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = dna.Length - 1; col > 2; col--)
{
var c = dna[fila + 2][col];
var comparar = dna[fila + 3][col - 1];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagSec2DerIzAbajo++;
}
fila++;
}
}
return(concuDiagSec2DerIzAbajo);
}
int DiagonalSec1DerIzArriba(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = dna.Length - 1; col > 1; col--)
{
var c = dna[fila][col - 1];
var comparar = dna[fila + 1][col - 2];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagSec1DerIzArriba++;
}
fila++;
}
}
return(concuDiagSec1DerIzArriba);
}
int DiagonalSec2DerIzArriba(string[] dna, int concurrencias)
{
int contador = 0;
for (int fila = 0; fila < dna.Length - 5; fila++)
{
for (int col = dna.Length - 1; col > 2; col--)
{
var c = dna[fila][col - 2];
var comparar = dna[fila + 1][col - 3];
if (c == comparar)
{
contador++;
}
else
{
contador = 0;
}
if (contador == 3)
{
concuDiagSec2DerIzArriba++;
}
fila++;
}
}
return(concuDiagSec2DerIzArriba);
}
}
