private void DibujarArco(int arco, bool esRuta)
{
Graphics g = panel1.CreateGraphics();
Arco p = Arcos[arco];
//Vertice origen = Vertices[p.origen == 0 ? p.origen : p.origen-1] ;
//Vertice destino = Vertices[p.destino == 0 ? p.destino : p.destino - 1];
Vertice origen = Vertices[p.origen];
Vertice destino = Vertices[p.destino];
Point pOrigen;
Point pDestino;
Pen pen;
//pOrigen = new Point(origen.p.X + (origen.p.X < destino.p.X ? 2 : -2) * 1, origen.p.Y);
//pDestino = new Point(destino.p.X + (origen.p.X < destino.p.X ? -2 : 2) * 1, destino.p.Y);
pOrigen = origen.p;
pDestino = destino.p;
if (!esRuta)
{
pen = new Pen(Color.Black, 4);
}
else
{
pen = new Pen(Color.Red, 5);
}
pen.StartCap = LineCap.Round;
pen.EndCap = LineCap.ArrowAnchor;
g.DrawString(p.distancia.ToString(), new Font("Verdana", 11, FontStyle.Bold), new SolidBrush(Color.Red), new Point((pOrigen.X + pDestino.X) / 2, (pOrigen.Y + pDestino.Y) / 2 + (pOrigen.Y < pDestino.Y ? (-30) : 15)));
g.DrawLine(pen, origen.p, destino.p);
g.Dispose();
}
public Equipo(string nombre, List <Jugador> jugadores, Arco arcoPropio, Arco arcoRival)
{
this.nombre = nombre;
this.jugadores = jugadores;
this.arcoPropio = arcoPropio;
this.arcoRival = arcoRival;
}
public bool CriarArco(string nomeInput, string nomeOutput, int peso, string name)
{
lugar LugarIn = lugarez.Find(x => x.nome == nomeInput);
if (LugarIn != null)
{
transicao TransicaoOut = transicoes.Find(x => x.nome == nomeOutput);
if (TransicaoOut == null)
{
return(false);
}
Arco newArco = new Arco();
newArco.CreateArc(LugarIn, TransicaoOut, peso, name);
arcos.Add(newArco);
return(true);
}
transicao TransicaoIn = transicoes.Find(x => x.nome == nomeInput);
if (TransicaoIn != null)
{
lugar LugarOut = lugarez.Find(x => x.nome == nomeOutput);
if (LugarOut == null)
{
return(false);
}
Arco newArco = new Arco();
newArco.CreateArc(TransicaoIn, LugarOut, peso, name);
return(true);
}
return(false);
}
restoreElementValues( Arco edge,
XmlReader reader) {
/////////////////////////////////////////
/*** verifichiamo se l'arco è davvero esistente ***/
if (edge == null)
return;
String attrName = "";
String attrValue = "";
String attrType = "";
bool exit = false;
while (reader.Read() && !exit){
if (reader.NodeType == XmlNodeType.Element) {
switch (reader.Name) {
case "edgeAttrName":
while (reader.Read()) {
if (reader.NodeType == XmlNodeType.Text) {
attrName = reader.Value;
break;
}
}
while (reader.Read()) {
if (reader.Name == "edgeAttrType") {
while (reader.Read()) {
if (reader.NodeType == XmlNodeType.Text) {
attrType = reader.Value;
break;
}
}
break;
}
}
while (reader.Read()) {
if (reader.Name == "edgeAttrValue") {
while (reader.Read()) {
if (reader.NodeType == XmlNodeType.Text) {
attrValue = reader.Value;
break;
}
}
break;
}
}
/*** viene ripristinato l'attributo i-esimo dell'arco con nome, tipo e valore originari ***/
edge.attributi[attrName][0] = attrType;
edge.attributi[attrName][1] = attrValue;
break;
case "node":
exit = true;
break;
}
}
}
}
private Arco ObtienePrimerArco(NodoGrafo nodo)
{
Arco arco = null;
if (nodo.arcos != null && nodo.arcos.Count > 0)
{
arco = nodo.arcos.First();
}
return(arco);
}
private void DisparaMunicao()
{
Vector3 posicaoMouse = Camera.main.ScreenToWorldPoint(Input.mousePosition);
GameObject municao = SpawnMunicao(transform.position);
if (municao != null)
{
Arco arcoScript = municao.GetComponent <Arco>();
float duracaoTrajetoria = 1.0f / velocidadeArma;
StartCoroutine(arcoScript.arcoTrajetoria(posicaoMouse, duracaoTrajetoria));
}
}
public string InsertarEnMatriz(int pRow, int pColumn, int pDistancia, int pTiempo, int pCosto)
{
var arco = new Arco
{
distancia = pDistancia,
tiempo = pTiempo,
costo = pCosto
};
grafo.InsertarArco(pRow, pColumn, arco);
return("Datos guardados");
}
// Metodo que verifica a posiçao do mouse (destino) e inicia a corrotina de calcular a trajetoria do projetil até o destino
void DisparaMunicao()
{
Vector3 posicaoMouse = Camera.main.ScreenToWorldPoint(Input.mousePosition); // Pega a poisçao de destino
GameObject municao = SpawnMunicao(transform.position); // Instancia o projetil na posiçao do player
if (municao != null) // Se o projetil nao é nulo...
{
Arco arcoScript = municao.GetComponent <Arco>(); // Pega o componente Arco do projetil
float duracaoTrajetoria = 1f / velocidadeArma; // Calcula a duraçao da trajetoria
StartCoroutine(arcoScript.arcoTrajetoria(posicaoMouse, duracaoTrajetoria)); // Inicia a corrotina que controla a trajetoria do projetil
}
}
/// <summary>
/// Cria uma munição e à atira em uma direção
/// </summary>
void DispararMunicao()
{
Vector3 posicaoMouse = Camera.main.ScreenToWorldPoint(Input.mousePosition);
GameObject municao = SpawnMunicao(transform.position);
if (municao != null)
{
playerFiredSource.Play(); //toca o audio de atirar flecha
Arco arcoScript = municao.GetComponent <Arco>();
float duracaoTrajetoria = 1.0f / velocidadeArma;
StartCoroutine(arcoScript.ArcoTrajetoria(posicaoMouse, duracaoTrajetoria));
}
}
public int AddLink(int _parte, int link, float posizione, Boolean simmetric)
{
if (link > num_parti || _parte > num_parti)
return 0;
else
{
arco = new Arco();
parte=vettParti.Values[_parte];
arco.link = link;
arco.position = posizione;
arco.simmetric = simmetric;
parte.lista_archi.Add(parte.num_archi, arco);
parte.num_archi++;
return 1;
}
}
private void RecebeLugaresSaida(Transicao transicao)
{
Console.Write($"Quais são os lugares de saida de {transicao.Nome}? ");
string[] arrayLugares = Console.ReadLine().Split(',');
if (arrayLugares.Length > 0)
{
foreach (string nome in arrayLugares)
{
Lugar lugar = lugares.Find(obj => obj.Nome == nome);
Arco arco = new Arco(transicao, lugar);
arcos.Add(arco);
lugar.arco = arco;
transicao.arcos.Add(arco);
transicao.lugaresSaida.Add(lugar);
}
}
}
public void MostrarRutas(bool esCritica = true)
{
/*
* 1. Definir 4 Estructuras:
* Lista para rutaActual
* Pila de listas para rutasPendientes
* Lista de Listas para rutasFinales
* Arco
**Las anteriores estructuras apuntaran a los nodos directamente, NO a copias.
**Los pesos finales de cada ruta–final se calcularan al mostrarse ada ruta
* 2. Mientras haya ruta–pendiente:
* 3. desapile la ruta pendiente, y sera tratada como la ruta–actual
* 4. obtenga el primer arco con el q se relaciona el ultimo nodo de la ruta–actual
* 5. SI, el anterior arco es != null
* 5.1 adicione el nodo del arco a la ruta–actual
* 5.2 adicione los demas nodos de los demas arcos sobre la ruta–actual, cada nueva ruta obtenida quedara pendiente
* 5.3 adicione la nueva ruta–actual (la q ahora añadio al nodod el 1er arco) como pendiente
* 6. si el ultimo nodo de la ruta–actual no tiene arcos, adicionela como ruta final
* 3. Muestra las Rutas Finales, calcule y muestre sus respectivos pesos
*/
List <NodoGrafo> rutaActual = new List <NodoGrafo>();
Stack <List <NodoGrafo> > rutasPendientes = new Stack <List <NodoGrafo> >();
List <List <NodoGrafo> > rutasFinales = new List <List <NodoGrafo> >();
Arco primerArco = null;
rutaActual.Add(inicio);
rutasPendientes.Push(rutaActual);
while (rutasPendientes.Any())
{
rutaActual = rutasPendientes.Pop();
primerArco = ObtienePrimerArco(rutaActual.Last());
if (primerArco != null)
{
rutaActual.Add(primerArco.nodo);
AdicionaRutaPendientes(ref rutaActual, ref rutasPendientes);
rutasPendientes.Push(rutaActual);
}
AdicionaRutaFinal(ref rutaActual, ref rutasFinales);
}
MostrarRutas(rutasFinales, esCritica);
}
buildElementXML( XmlWriter writer,
Arco edge) {
///////////////////////////////////
/*
* Si verifica se l'arco di cui costruire l'XML sia un riferimento
* a null poiche' se esso non esiste viene stampato un elemento "<edge />"
* che deformatta l'intero documento e non rende possibile un parsing corretto.
*/
if (edge == null)
return;
writer.WriteStartElement("edge");
writer.WriteElementString("edgeID", Convert.ToString(edge.ID));
writer.WriteStartElement("edgeAttributeList");
foreach (KeyValuePair<String, String[]> pair in edge.attributi) {
writer.WriteStartElement("edgeAttribute");
writer.WriteElementString("edgeAttrName", pair.Key.ToString());
writer.WriteElementString("edgeAttrType", pair.Value[0].ToString());
writer.WriteElementString("edgeAttrValue", pair.Value[1].ToString());
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
} // End of method buildElementXML[arco]
public static void ConvertToArc(Arco arco, Path path)
{
path.Width = double.NaN;
path.Height = double.NaN;
path.StrokeThickness = arco.Pen.Widht;
path.Stroke = ConvertToBrush(arco.Pen.Stroke);
path.Fill = ConvertToBrush(arco.Background);
path.StrokeStartLineCap = ConvertToPen(arco.Pen).StartLineCap;
path.StrokeEndLineCap = ConvertToPen(arco.Pen).EndLineCap;
ArcSegment arc = new ArcSegment(new Point(arco.Width, 0), new Size(arco.Width, arco.Height), 0, false, SweepDirection.Clockwise, true);
PathFigure fig = new PathFigure();
fig.StartPoint = new Point(0, 0);
fig.Segments.Add(arc);
List <PathFigure> lista = new List <PathFigure>();
lista.Add(fig);
PathGeometry geo = new PathGeometry(lista);
path.Data = geo;
}
public void addArco(Arco a)
{
archi.Add(a);
}
public GrafoDisegno(GenotipoRN input)
{
Queue<Nodo> coda = new Queue<Nodo>();
nodi = new SortedList<int, Nodo>();
//crea i nodi
foreach (KeyValuePair<int, GenotipoRN.NeuroneG> neurone in input.neuroni)
{
Nodo nuovo = new Nodo(neurone.Value.neatID, neurone.Value.thresholdIndex);
nuovo.livello = 0;
nuovo.stato = Nodo.StatoVisita.NonVisitato;
nuovo.tipo = TipoNeurone.NHide;
nodi.Add(neurone.Key, nuovo);
}
//prepara i neuroni di input
foreach (GenotipoRN.NeuroneG neurone in input.neuroniInput)
{
Nodo nuovoInput = nodi[neurone.neatID];
nuovoInput.stato = Nodo.StatoVisita.InCoda;
nuovoInput.tipo = TipoNeurone.NSensor;
coda.Enqueue(nuovoInput);
}
foreach (GenotipoRN.NeuroneG neurone in input.neuroniOutput)
nodi[neurone.neatID].tipo = TipoNeurone.NActuator;
//crea gli archi e li inserisce nella lista archi del nodo di partenza
foreach(KeyValuePair<int,GenotipoRN.AssoneG> assone in input.assoni)
{
if (!assone.Value.attivo)
continue;
Arco nuovo = new Arco(nodi[assone.Value.output],nodi[assone.Value.input], assone.Value.neatID, assone.Value.peso);
nodi[assone.Value.input].addArco(nuovo);
}
//definisce i livelli come distanza massima da un qualsiasi nodo di input; per far questo fa una visita in ampiezza
//a partire dai nodi di input
while (coda.Count > 0)
{
Nodo n = coda.Dequeue();
n.stato = Nodo.StatoVisita.InVisita;
IEnumerator<Arco> enumerator = n.GetEnumeratorArco();
while (enumerator.MoveNext())
{
Arco a = enumerator.Current;
if ((a.destinazione.livello <= n.livello) && (a.destinazione.stato != Nodo.StatoVisita.Visitato) && (a.destinazione.tipo != TipoNeurone.NActuator) && (a.destinazione != a.partenza))
{
a.destinazione.livello = n.livello + 1;
if (a.destinazione.livello > maxLivello)
maxLivello = a.destinazione.livello;
}
if (a.destinazione.stato == Nodo.StatoVisita.NonVisitato)
{
a.destinazione.stato = Nodo.StatoVisita.InCoda;
coda.Enqueue(a.destinazione);
}
}
n.stato = Nodo.StatoVisita.Visitato;
}
foreach (GenotipoRN.NeuroneG neurone in input.neuroniOutput)
nodi[neurone.neatID].livello = maxLivello+1;
maxLivello++;
//y_corrente[i] contiene la coordinata y del prossimo neurone al livello i
int[] y_corrente = new int[maxLivello+1];
y_corrente[0] = Const.LatoGriglia / 2;
for (int i = 1; i <= maxLivello; i++)
y_corrente[i] = y_corrente[i - 1] + Const.LatoGriglia;
//assegna le posizioni
foreach (KeyValuePair<int, Nodo> neurone in nodi)
{
neurone.Value.posizione = new Vector2(neurone.Value.livello * Const.LatoGriglia + Const.LatoGriglia / 2, y_corrente[neurone.Value.livello]);
y_corrente[neurone.Value.livello] += Const.LatoGriglia*(maxLivello+1);
}
}
public GrafoDisegno(GenotipoRN input)
{
Queue<Nodo> coda = new Queue<Nodo>();
nodi = new SortedList<int, Nodo>();
//crea i nodi
foreach (KeyValuePair<int, GenotipoRN.NeuroneG> neurone in input.neuroni)
{
Nodo nuovo = new Nodo(neurone.Value.GetId());
nuovo.livello = 0;
nuovo.stato = Nodo.StatoVisita.NonVisitato;
nodi.Add(neurone.Key, nuovo);
}
//prepara i neuroni di input
foreach (GenotipoRN.NeuroneG neurone in input.neuroniInput)
{
Nodo nuovoInput = nodi[neurone.GetId()];
nuovoInput.stato = Nodo.StatoVisita.InCoda;
coda.Enqueue(nuovoInput);
}
//crea gli archi e li inserisce nella lista archi del nodo di partenza
foreach(GenotipoRN.AssoneG assone in input.assoni)
{
Arco nuovo = new Arco(nodi[assone.getOutput()],nodi[assone.getInput()], assone.GetId(), assone.getPeso());
nodi[assone.getInput()].addArco(nuovo);
}
//definisce i livelli come distanza massima da un qualsiasi nodo di input; per far questo fa una visita in ampiezza
//a partire dai nodi di input
while (coda.Count > 0)
{
Nodo n = coda.Dequeue();
n.stato = Nodo.StatoVisita.InVisita;
IEnumerator<Arco> enumerator = n.GetEnumeratorArco();
while (enumerator.MoveNext())
{
Arco a = enumerator.Current;
if (a.destinazione.livello < (n.livello + 1))
{
a.destinazione.livello = n.livello + 1;
if (a.destinazione.livello > maxLivello)
maxLivello = a.destinazione.livello;
}
if (a.destinazione.stato == Nodo.StatoVisita.NonVisitato)
{
a.destinazione.stato = Nodo.StatoVisita.InCoda;
coda.Enqueue(a.destinazione);
}
}
n.stato = Nodo.StatoVisita.Visitato;
}
//y_corrente[i] contiene la coordinata y del prossimo neurone al livello i
int[] y_corrente = new int[maxLivello+1];
y_corrente[0] = Const.LatoGriglia / 2;
for (int i = 1; i <= maxLivello; i++)
y_corrente[i] = y_corrente[i - 1] + Const.LatoGriglia;
//assegna le posizioni
foreach (KeyValuePair<int, Nodo> neurone in nodi)
{
neurone.Value.posizione = new Vector2(neurone.Value.livello * Const.LatoGriglia + Const.LatoGriglia / 2, y_corrente[neurone.Value.livello]);
y_corrente[neurone.Value.livello] += Const.LatoGriglia*(maxLivello+1);
}
//TODO: portare tutti i neuroni di output al livello massimo, per far sì che vengano tutti allineati. Bisogna però memorizzare
//separatamente i neuroni di output nel GenotipoRN, analogamente a quanto ho fatto per i neuroni di input.
}
public void CarregarSimulacao(string caminho)
{
var tipDado = eTipoDado.Nenhum;
foreach (var linha in File.ReadAllLines(caminho))
{
if (linha == "#LUGARES")
{
tipDado = eTipoDado.Lugar;
continue;
}
if (linha == "#TRANSIÇÕES")
{
tipDado = eTipoDado.Transicao;
continue;
}
if (linha == "#ARCOS")
{
tipDado = eTipoDado.Arco;
continue;
}
switch (tipDado)
{
case eTipoDado.Lugar:
var dados = linha.Split(';');
lugares.Add(new Lugar(dados[0], Int32.Parse(dados[1])));
break;
case eTipoDado.Transicao:
dados = linha.Split(';');
var transicao = new Transicao(dados[0]);
transicoes.Add(transicao);
break;
case eTipoDado.Arco:
dados = linha.Split(';');
var arco = new Arco();
arco.peso = Int32.Parse(dados[2]);
if (dados[0].StartsWith("L"))
{
var origem = lugares.Find(l => l.Nome == dados[0]);
arco.origem = origem;
var destino = transicoes.Find(l => l.Nome == dados[1]);
arco.destino = destino;
origem.arco = arco;
destino.arcos.Add(arco);
}
else
{
var origem = transicoes.Find(l => l.Nome == dados[0]);
arco.origem = origem;
var destino = lugares.Find(l => l.Nome == dados[1]);
arco.destino = destino;
origem.arcos.Add(arco);
destino.arco = arco;
}
arcos.Add(arco);
break;
}
}
}
public void AddInput(Arco arc)
{
inputs.Add(arc);
}
public void AddOutput(Arco arc)
{
outputs.Add(arc);
}
private void InitListaArcos()
{
var calculador = new ProyectoEstructuras2.Calculador();
var listVertices = ObtenerVertices();
//Arco 1
var startVertice = listVertices[0];
var endVertice = listVertices[1];
var km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
var arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 2
startVertice = listVertices[1];
endVertice = listVertices[2];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 3
startVertice = listVertices[2];
endVertice = listVertices[3];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 4
startVertice = listVertices[3];
endVertice = listVertices[4];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 5
startVertice = listVertices[4];
endVertice = listVertices[5];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 6
startVertice = listVertices[5];
endVertice = listVertices[6];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 7
startVertice = listVertices[6];
endVertice = listVertices[7];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 8
startVertice = listVertices[7];
endVertice = listVertices[8];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 9
startVertice = listVertices[8];
endVertice = listVertices[9];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 10
startVertice = listVertices[9];
endVertice = listVertices[10];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 11
startVertice = listVertices[10];
endVertice = listVertices[11];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 12
startVertice = listVertices[11];
endVertice = listVertices[12];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 13
startVertice = listVertices[12];
endVertice = listVertices[13];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 14
startVertice = listVertices[13];
endVertice = listVertices[14];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 15
startVertice = listVertices[14];
endVertice = listVertices[15];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 16
startVertice = listVertices[15];
endVertice = listVertices[16];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 17
startVertice = listVertices[16];
endVertice = listVertices[17];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 18
startVertice = listVertices[17];
endVertice = listVertices[18];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 19
startVertice = listVertices[18];
endVertice = listVertices[19];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 20
startVertice = listVertices[19];
endVertice = listVertices[20];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 21
startVertice = listVertices[20];
endVertice = listVertices[21];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 22
startVertice = listVertices[21];
endVertice = listVertices[22];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 23
startVertice = listVertices[22];
endVertice = listVertices[23];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 24
startVertice = listVertices[23];
endVertice = listVertices[24];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 25
startVertice = listVertices[24];
endVertice = listVertices[20];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 26
startVertice = listVertices[24];
endVertice = listVertices[5];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 27
startVertice = listVertices[0];
endVertice = listVertices[4];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 28
startVertice = listVertices[4];
endVertice = listVertices[2];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 29
startVertice = listVertices[19];
endVertice = listVertices[5];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
//Arco 30
startVertice = listVertices[13];
endVertice = listVertices[7];
km = calculador.CalculateKilometers(startVertice.Latitud, startVertice.Longitud, endVertice.Latitud, endVertice.Longitud);
arco = new Arco {
VerticeDestino = endVertice, Kilometros = km
};
startVertice.Arcos.Insertar(arco);
}
private void AtualizarArcos()
{
Random rand = new Random();
int w = graphics.PreferredBackBufferWidth;
int h = graphics.PreferredBackBufferHeight;
// Verifica se a lista de arcos está completa
if (arcosT.Count < 3)
{
// Insere novos arcos na lista
Arco arcoF;
Arco arcoT;
// Verifica se é o primeiro arco
if (arcosT.Count == 0)
{
// Arco de trás - inicia no final da tela
arcoT = new Arco(
new Vector2(
rand.Next(w),
rand.Next(h - imgArcoT.Height)),
new Vector2(-3f, 0));
}
else
{
// Arco de trás - deslocado meia tela em relação ao último arco
arcoT = new Arco(
new Vector2(
arcosT[arcosT.Count - 1].Posicao.X + w / 2,
rand.Next(h - imgArcoT.Height)),
arcosT[arcosT.Count - 1].Velocidade);
}
// Arco da frente
arcoF = new Arco(arcoT.Posicao, arcoT.Velocidade);
// Área de colisão superior
arcoF.AreaColisao.Add(new Rectangle(
(int)arcoF.Posicao.X + imgArcoF.Width / 3,
(int)arcoF.Posicao.Y,
imgArcoF.Width / 3,
imgArcoF.Height / 10));
// Área de colisão inferior
arcoF.AreaColisao.Add(new Rectangle(
(int)arcoF.Posicao.X + imgArcoF.Width / 3,
(int)arcoF.Posicao.Y + (int)(9 * imgArcoF.Height / 10),
imgArcoF.Width / 3,
imgArcoF.Height / 10));
// Visibilidade do arco
arcoF.Visivel = true;
arcoT.Visivel = true;
// Contagem de pontos
arcoF.Placar = false;
// Imagens dos arcos
arcoF.Imagem = imgArcoF;
arcoT.Imagem = imgArcoT;
// Adiciona arcos nas listas
arcosF.Add(arcoF);
arcosT.Add(arcoT);
}
else
{
// Atualiza posições dos arcos na lista
// Posição do último arco
Vector2 pos = arcosT[arcosT.Count - 1].Posicao;
// Percorre lista de arcos
for (int i = 0; i < arcosT.Count; i++)
{
// Verifica se arco deixou de ser visível
if (arcosT[i].Posicao.X <= 0 - imgArcoT.Width)
{
// Arco não está visível - Desloca meia tela a partir do último
// Atualiza posição do arco
arcosT[i].Posicao = new Vector2(
pos.X + w / 2,
rand.Next(h - imgArcoT.Height));
arcosF[i].Posicao = arcosT[i].Posicao;
// Visibilidade do arco
arcosF[i].Visivel = true;
arcosT[i].Visivel = true;
// Contagem de pontos
arcosF[i].Placar = false;
}
else
{
// Arco visível - altera a posição de acordo com a velocidade x
arcosT[i].Posicao = new Vector2(arcosT[i].Posicao.X + arcosT[i].Velocidade.X,
arcosT[i].Posicao.Y);
arcosF[i].Posicao = arcosT[i].Posicao;
}
// Redefine as áreas de colisão
arcosF[i].AreaColisao[0] = new Rectangle(
(int)arcosF[i].Posicao.X + imgArcoF.Width / 3,
(int)arcosF[i].Posicao.Y,
imgArcoF.Width / 3,
imgArcoF.Height / 10);
arcosF[i].AreaColisao[1] = new Rectangle(
(int)arcosF[i].Posicao.X + imgArcoF.Width / 3,
(int)arcosF[i].Posicao.Y + (int)(9 * imgArcoF.Height / 10),
imgArcoF.Width / 3,
imgArcoF.Height / 10);
// Atualiza posição do último arco
pos = arcosT[i].Posicao;
}
}
}