Exemplo n.º 1
0
        public LinkedList <Nodo> BuscaMelhorCaminho(Nodo posAtual, List <Cell> listObj, Ambiente amb)
        {
            LinkedList <Nodo> lPontos = new LinkedList <Nodo>();

            foreach (var l in listObj)
            {
                LinkedList <Nodo> lAux = buscaCaminho(posAtual, l, amb);

                if (lAux == null)
                {
                    continue;
                }

                //Armazena menor percurso
                if (lPontos.Count == 0 || lAux.Count < lPontos.Count)
                {
                    lPontos = lAux;
                }
            }

            return(lPontos);
        }
Exemplo n.º 2
0
        internal LinkedList <Nodo> buscaCaminho(Nodo inicio, Cell objetivo, Ambiente amb)
        {
            Cell[,] map = (Cell[, ])amb.map.Clone();

            Nodo atual = inicio;

            Nodo nodo_objetivo = new Nodo(objetivo.linha, objetivo.coluna);

            List <Nodo> sucessores_objetivo = amb.BuscaSucessores(nodo_objetivo);

            LinkedList <Nodo> conjuntoAberto = new LinkedList <Nodo>();

            LinkedList <Nodo> conjuntoFechado = new LinkedList <Nodo>();

            conjuntoAberto.AddLast(inicio);


            while (true)
            {
                var listoder = conjuntoAberto.OrderBy(o => o.fscore).ToList();

                conjuntoAberto.Clear();

                conjuntoAberto = new LinkedList <Nodo>(listoder);

                atual = conjuntoAberto.First();

                if (sucessores_objetivo.Any(o => o.xy == atual.xy))
                {
                    break; // Encontrou o caminho
                }
                if (conjuntoAberto.Count == 0)
                {
                    break; //Não encontrou o caminho
                }
                conjuntoAberto.RemoveFirst();

                conjuntoFechado.AddFirst(atual);


                foreach (var vizinho in amb.BuscaSucessores(atual))
                {
                    string tipo_vizinho = amb.map[vizinho.x, vizinho.y].item.ToString();

                    //Posição vizinho é recarga e/ou lixeira não computar
                    if (tipo_vizinho == " L " || tipo_vizinho == " R " || tipo_vizinho == " P ")
                    {
                        continue;
                    }

                    //Vizinho já está na lista fechada
                    if (conjuntoFechado.Any(o => o.xy == vizinho.xy))
                    {
                        continue;
                    }

                    //Vizinho não está na lista aberta
                    if (!conjuntoAberto.Any(o => o.xy == vizinho.xy))
                    {
                        vizinho.prev = atual;

                        vizinho.gscore = atual.gscore + 1;

                        vizinho.fscore = vizinho.gscore +
                                         Heuristica(vizinho, nodo_objetivo);

                        conjuntoAberto.AddFirst(vizinho);
                    }
                    else
                    {
                        var vizinho_antigo = conjuntoAberto.FirstOrDefault(o => o.xy == vizinho.xy);

                        if (vizinho_antigo.gscore < vizinho.gscore)
                        {
                            conjuntoAberto.Remove(vizinho_antigo);

                            vizinho_antigo.gscore = atual.gscore + 1;

                            vizinho_antigo.fscore = vizinho_antigo.gscore + Heuristica(vizinho_antigo, nodo_objetivo);

                            vizinho_antigo.prev = atual;

                            conjuntoAberto.AddFirst(vizinho_antigo);
                        }
                    }
                }
            }

            LinkedList <Nodo> caminho = new LinkedList <Nodo>();

            caminho.AddFirst(atual);

            while (atual.prev != null)
            {
                caminho.AddFirst(atual.prev);

                atual = atual.prev;
            }

            return(caminho);
        }
Exemplo n.º 3
0
        static void Init(string[] args)
        {
            Console.WriteLine("Inicializa com o mínimo viável... ");
            bool bLimpouAmbiente = false;

            //Variáveis para o agente
            int capacidade_lixo_coletado = 5;
            int carga_maxima             = 20;

            //Variáveis para o ambiente
            int tamanho        = 10;
            int quant_lixeiras = 3;
            int quant_recargas = 3;

            Console.WriteLine("Tradução...");

            //(n) =(Linha,Coluna), Capacidade Lixo (T), Carga Minima (C), QuantLixeiras (l), QuantRecargas(r)
            foreach (var value in args)
            {
                var dados = value.Split('=');

                Console.WriteLine(String.Join(" | ", dados));

                switch (dados[0].ToString())
                {
                case "n":
                    tamanho = int.Parse(dados[1]);
                    break;

                case "t":
                    capacidade_lixo_coletado = int.Parse(dados[1]);
                    break;

                case "c":
                    carga_maxima = int.Parse(dados[1]);
                    break;

                case "l":
                    quant_lixeiras = int.Parse(dados[1]);
                    break;

                case "r":
                    quant_recargas = int.Parse(dados[1]);
                    break;
                }
            }


            Console.WriteLine("Inicializa o agente...");
            var oAgente = new Agente(capacidade_lixo_coletado, carga_maxima);

            Console.WriteLine("Inicializa mapa...");
            var oMapa = new Ambiente(oAgente, tamanho, quant_recargas, quant_lixeiras);

            //Print Map
            Console.WriteLine(oMapa.ToString());



            //Atualização
            while (!bLimpouAmbiente)
            {
                //Atualiza as ações do agente e o mapa
                bLimpouAmbiente = oMapa.Atualiza();

                //Limpa console
                Console.Clear();

                //Print Map
                Console.WriteLine(oMapa.ToString());

                Thread.Sleep(500);
            }

            //Informações do grupo
            StringBuilder sDadosDev = new StringBuilder();

            sDadosDev.AppendLine("\t Inteligência Artifical T1 2017/2 ");
            sDadosDev.AppendLine("\t ***Agente Coletor de Lixo*** ");
            sDadosDev.AppendLine("\t Desenvolvedores:");
            sDadosDev.AppendLine("\t Anderson Fraga, Jovani Brasil, Matheus Lima e  Renan Carvalho");
            sDadosDev.AppendLine("\n\n");
            sDadosDev.AppendLine("\t Aperte [ENTER] para fechar!");

            Console.WriteLine(sDadosDev.ToString());

            Console.Read();
        }