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();
        }
Exemple #2
0
 public Equipo(string nombre, List <Jugador> jugadores, Arco arcoPropio, Arco arcoRival)
 {
     this.nombre     = nombre;
     this.jugadores  = jugadores;
     this.arcoPropio = arcoPropio;
     this.arcoRival  = arcoRival;
 }
Exemple #3
0
    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);
    }
Exemple #4
0
        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; 
                    }
                }
            }
        }
Exemple #5
0
        private Arco ObtienePrimerArco(NodoGrafo nodo)
        {
            Arco arco = null;

            if (nodo.arcos != null && nodo.arcos.Count > 0)
            {
                arco = nodo.arcos.First();
            }

            return(arco);
        }
Exemple #6
0
    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));
        }
    }
Exemple #7
0
        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");
        }
Exemple #8
0
    // 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
        }
    }
Exemple #9
0
    /// <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);
                }
            }
        }
Exemple #12
0
        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);
        }
Exemple #13
0
 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]
Exemple #14
0
        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;
                }
            }
        }
Exemple #19
0
 public void AddInput(Arco arc)
 {
     inputs.Add(arc);
 }
Exemple #20
0
 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);
        }
Exemple #22
0
        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;
                }
            }
        }