(Dúvida) Encontrar o objeto mais próximo partindo do ponto inicial ao final.

Olá, estou fazendo um sistema de pathfinding 2D baseado em checkpoints. O sistema de editor para criar o cenário com os checkpoints etá praticamente feito, porém enfrento dificuldades em fazer o "Navedador (objeto que seguirá entre os checkpoints)". Minha lógica seria  calcular a distância entre o ponto atual (A) e o ponto final (Z), e depois calcular qual checkpoint está mais próximo do (A) porém com menor distancia do mesmo que no caso seria o (B):

Código:

   void CalcularProximoPonto () {
      for (int x = 0; x < checkpoints.Count; x++) {
         distancia = Vector2.Distance (checkpoints[atual], checkpoints [final]);
         float distanciaGlobal = Vector2.Distance (checkpoints [x], checkpoints [final]);
         if ((distanciaGlobal) < distancia && x != final) {
             atual = x;
         }
      }
   }

Nesta situação ele pega o checkpoint (Y) e não o checkpoint (B), usaria um break no "for" para ele pegar o objeto (B), porém não funcionaria quando eu alterasse o destino final.

Só queria dar um Up nesse tópico, por que eu não faço a menor ideia de como resolver

up

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ObjetoProximo : MonoBehaviour {

    public GameObject[] CheckPoints;
    public float[] Dist;
    public GameObject Player;

    public GameObject CheckPointProximo;

    //Valores
    public float Menor;
    public float Maior;

    void Start()
    {

        Dist = new float[CheckPoints.Length]; //Ajusta o tamanho da array de acordo com o numero de CheckPoints 
    }

    void Update()
    {



        for (int i = 0; i < CheckPoints.Length; i++)
        { //Pegar a menor posi


            Dist[i] = Vector3.Distance(CheckPoints[i].transform.position, Player.transform.position);

            if (i == 0)
            {
                Maior = Dist[i];
                Menor = Dist[i];
            }

            if (Dist[i] > Maior)
            {
                Maior = Dist[i];
            }
            if (Dist[i] < Menor)
            {
                Menor = Dist[i];
                CheckPointProximo = CheckPoints[i];
            }

        }


    }

}

Tenta isso

Matrirxp escreveu:

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ObjetoProximo : MonoBehaviour {

    public GameObject[] CheckPoints;
    public float[] Dist;
    public GameObject Player;

    public GameObject CheckPointProximo;

    //Valores
    public float Menor;
    public float Maior;

    void Start()
    {

        Dist = new float[CheckPoints.Length]; //Ajusta o tamanho da array de acordo com o numero de CheckPoints 
    }

    void Update()
    {



        for (int i = 0; i < CheckPoints.Length; i++)
        { //Pegar a menor posi


            Dist[i] = Vector3.Distance(CheckPoints[i].transform.position, Player.transform.position);

            if (i == 0)
            {
                Maior = Dist[i];
                Menor = Dist[i];
            }

            if (Dist[i] > Maior)
            {
                Maior = Dist[i];
            }
            if (Dist[i] < Menor)
            {
                Menor = Dist[i];
                CheckPointProximo = CheckPoints[i];
            }

        }


    }

}

Tenta isso

Não deu certo :/, mas me deu uma idéia, vlw.

Eu achei um meio resultado:

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Destinador : MonoBehaviour {

 public MapEditor mapaDeCheckpoints;
 public int posicaoAtual;
 public int posicaoFinal;
 private int posicaoAnterior;
 private int proximoPonto;
 private float distanciaAtual;
 public float velocidade = 5;
 public bool podeMover;

 [Space(20)]
 public List<Vector3> checkpoints = new List<Vector3>();
 public List<float> pontosSecundarios = new List<float> ();

 void Awake () {
 checkpoints = mapaDeCheckpoints.checkpoints;

 }

 void Update () {
 if (transform.position != checkpoints[posicaoAtual] && podeMover) {
 if (proximoPonto == 0) {
 transform.position = Vector3.MoveTowards(transform.position, checkpoints [posicaoAtual], velocidade * Time.deltaTime);
 } else {
 transform.position = Vector3.MoveTowards(transform.position, checkpoints [proximoPonto], velocidade * Time.deltaTime);
 }
 }

 if (podeMover) {
 if (transform.position == checkpoints [posicaoAtual] && proximoPonto == 0) {
 ProcurarPontoPrimario ();
 } else if (proximoPonto != 0) {
 if (transform.position == checkpoints [proximoPonto]) {
 ProcurarPontoPrimario ();
 }
 }
 }

 if (Input.GetKeyDown(KeyCode.C)) {
 ResetarResultados ();
 }
 }

 void ProcurarPontoPrimario () {
 /* Esta void ela é responsavel por pegar os pontos inícias que estão mais próximos
 * do ponto de partida, ou seja, praticamente ela irá pegar somente os pontos que
 * estão paralelo, ou seja, lado a lado
 */
 for (int x = 0; x < checkpoints.Count; x++) {
 if (x != posicaoAtual) {
 float distanceCP = Vector2.Distance (checkpoints [posicaoAtual], checkpoints [posicaoFinal]); //Pega a distância entre o ponto atual e final
 float distanceX = Vector2.Distance (checkpoints [x], checkpoints [posicaoFinal]); //Pega a distância entre cada ponto em relação a posição final
 if (distanceX < distanceCP) { //Se o ponto[x] for menor que a distancia entre a minha posição e a posição final ele pega este valor
 posicaoAnterior = posicaoAtual;
 posicaoAtual = x; //Aqui ele atribui a posição atual ao ponto encontrado
 VerificarIntegridade ();
 distanciaAtual = distanceX;
 break;
 }
 }
 }
 }
 void VerificarIntegridade () {
 /* Aqui ele vai verificar se o ponto encontrado da void anterior é realmente o mais próximo entre o ponto anterior
 * e o ponto final
 */
 for (int i = 0; i < checkpoints.Count; i++) {
 if (i != posicaoAnterior && i != posicaoAtual) {
 float distancePC = Vector2.Distance (checkpoints [posicaoAtual], checkpoints [posicaoAnterior]);
 float distanceI = Vector2.Distance (checkpoints [i], checkpoints [posicaoAnterior]);
 if (distanceI < distancePC) {
 Debug.Log(i + " PONTO ENCONTRADO: " + checkpoints[i] + " DISTANCIA: >>>>>>>>> " + distanceI);
 pontosSecundarios.Add (distanceI); //Caso o ponto encontrado não for o menor ele adiciona todos os pontos mais próximos entre o ponto atual e o ponto final em uma lista.
 UltimaChecagem ();
 }
 }
 }
 }

 void UltimaChecagem () {
 /* Aqui é onde ocorre a ultima verificação, onde ele verifica qual desses pontos encontrados qual tem a menor distancia
 */
 for (int i = 0; i < pontosSecundarios.Count; i++) {
 if (pontosSecundarios[i] < distanciaAtual) {
 distanciaAtual = pontosSecundarios [i];
 Debug.Log ("RESULTADO FINAL: " + (i) + " DISTANCIA: " + pontosSecundarios [i] + " PONTO ORIGINAL: " + (posicaoAtual + (i + 1)));
 proximoPonto = posicaoAtual + (i + 1); //Após a verificação o ponto mais próximo encontrado sera o proximo local a ir
 }
 }
 }

 void ResetarResultados () { //É utilizado quando chega ao ponto final.
 pontosSecundarios.Clear (); //Limpa a lista.
 Debug.Log ("RESULTADOS DELETADOS");
 proximoPonto = 0;
 }
}


Basicamente ele na primeira vez quando vai, ele vai respeitando tudo perfeitamente, porém quando valor final é alterado, buga - se tudo kkkk. HELP!

Não entendi muito bem você quer fazer  
Quer que o player percorra todos os checkpoints ????

Matrirxp escreveu:Não entendi muito bem você quer fazer  
Quer que o player percorra todos os checkpoints ????

Sim, praticamente é um sistema de pathfinding com checkpoints, ele basicamente escolhe o checkpoint mais proximo de sí em relação ao ponto final e traça um caminho, porém está sendo bem complicado.

rafaelllsd escreveu:

Matrirxp escreveu:Não entendi muito bem você quer fazer  
Quer que o player percorra todos os checkpoints ????

Sim, praticamente é um sistema de pathfinding com checkpoints, ele basicamente escolhe o checkpoint mais proximo de sí em relação ao ponto final e traça um caminho, porém está sendo bem complicado.

Porque tem que ser em relação ao ponto final?
Quer que ele vá ao ponto final e depois volte ao inicial ??

Matrirxp escreveu:

rafaelllsd escreveu:

Matrirxp escreveu:Não entendi muito bem você quer fazer  
Quer que o player percorra todos os checkpoints ????

Sim, praticamente é um sistema de pathfinding com checkpoints, ele basicamente escolhe o checkpoint mais proximo de sí em relação ao ponto final e traça um caminho, porém está sendo bem complicado.

Porque tem que ser em relação ao ponto final?
Quer que ele vá ao ponto final e depois volte ao inicial ??

Ponto final por que é o 'destino'

Pathfinding é pra escolher a rota mais curta da sua posição atual até o ponto de destino, criando uma lista de checkpoints para o jogador percorrer até o destino.

Entendi 

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Object2 : MonoBehaviour {

    public List<GameObject> CheckPoints = new List<GameObject>();//Checkpoint (Nao colocar o destino aqui)
    public GameObject Destino;//Destino
    float[] Dist;
    public GameObject Player;//Player

    public float Speed;

    //Valores
    float Menor;
    GameObject MenorObjeto;

    float Maior;

    bool Check;
    int Index;

    void Start()
    {

        Dist = new float[CheckPoints.Count]; //Ajusta o tamanho da array de acordo com o numero de CheckPoints 
        Check = true;//Checar CheckPoint

    }

    void Update()
    {


        if (CheckPoints.Count > 1)//Se o tamanho da lista for maior que 1 -> checar lista a procura do checkpoint mais proximo
        {

            if (MenorObjeto == null) //Se a variavel "MenorObjeto" for igual a null --> Verificar Chekpoints novamente (Assim e possivel evitar bugs como o "NullReferenceException")
            {
                Check = true;//Checar CheckPoint
            }

            if (Check == true)//Checar CheckPoint
            {

                for (int i = 0; i < CheckPoints.Count; i++)//Pegar o CheckPoint Mais Proximo
                { 


                    Dist[i] = Vector3.Distance(CheckPoints[i].transform.position, Player.transform.position);

                    if (i == 0)
                    {
                        Maior = Dist[i];
                        Menor = Dist[i];
                    }

                    if (Dist[i] > Maior)
                    {
                        Maior = Dist[i];
                    }
                    if (Dist[i] < Menor)
                    {
                        Menor = Dist[i];
                        MenorObjeto = CheckPoints[i];
                        Index = i;
                    }

                }
                Check = false;
            }
            else
            {
                float DistA = Vector3.Distance(MenorObjeto.transform.position, Player.transform.position);//Verifica a distancia entre o "MenorObjeto" e o "Player"
                float DistB = Vector3.Distance(MenorObjeto.transform.position, Destino.transform.position);//Verifica a distancia entre o "MenorObjeto" e o "Destino"
                float DistC = Vector3.Distance(Player.transform.position, Destino.transform.position);//Verifica a distancia entre o "Player" e o "Destino"

                if (DistB < DistC) //Verifica o Checkpoint escolhido (Evita a escolha de um Checkpoint fora de rota) [Se a distancia entre o "MenorObjeto" e o "Destino" e menor que a distancia entre o "Player" e o "Destino" -> Direcionar player]
                {

                    Player.transform.position = Vector3.MoveTowards(Player.transform.position, MenorObjeto.transform.position, Speed * Time.deltaTime);//Direcionar player ao proximo Checkpoint

                    if (DistA < 3)//Deletar checkpoint quando o player estiver nele 
                    {
                        CheckPoints.RemoveAt(Index);//Remover Checkpoint atual 
                        Index = 0;//Limpar variavel "Index" para uma nova checagem
                        Check = true;//Checar CheckPoint
                    }
                }
                else
                {
                    CheckPoints.RemoveAt(Index);//Remover Checkpoint fora de destino 
                    Index = 0;//Limpar variavel "Index" para uma nova checagem
                    Check = true;//Checar CheckPoint
                }
            }

        }
        else
        {
            Player.transform.position = Vector3.MoveTowards(Player.transform.position, Destino.transform.position, Speed * Time.deltaTime);//Apos passar por todos os checkpoints direcionar player ao destino
        }


    }

}

Acho que agora esta certo !

Não deu muito certo :/
https://imgur.com/a/wiOBaqR -> Tive que fazer a alteração de GameObject para vector3 porque a lista é feita de "Vector3", mas acho que não fiz nada de errado, praticamente ele não passa pelos checkpoints ele vai cortando pelo meio. Estou dando uma olhada em sistema de pathdinfing que geram uma "Surface" vou tentar extrair algo dela. Agradeço a ajuda.