Para simplificar la respuesta, Vector3es una costumbre structproporcionada por el UnityEngineespacio de nombres. Cuando creamos tipos classo structtipos personalizados , también debemos definir sus operadores . Como tal, no existe una lógica predeterminada para el >=operador. Como ha señalado Evgeny Vasilyev , _rect_tfm.position == _positionBtiene sentido, como podemos comprobar directamente los Vector3.x, Vector3.yy Vector3.zlos valores. _rect_tfm.position >= _positionBno tiene tanto sentido, debido al hecho de que a Vector3está representado por tres valores separados.
Podríamos sobrecargar la Vector3clase para contener los operadores adecuados en teoría , pero eso parece bastante complicado. En cambio, sería más fácil simplemente extender la Vector3clase con un método adecuado . Dicho esto, parece que tienes la intención de utilizar esta lógica para el movimiento. Como tal, puede resultarle mucho más fácil usar el Vector3.Lerpmétodo; Si es así, lea más abajo.
Agregar métodos de extensión a Vector3
Como se mencionó anteriormente, aplicar <=o >=a Vector3menudo es ilógico. Para el movimiento, probablemente desee leer más sobre el Vector3.Lerpmétodo. Dicho esto, es posible que desee aplicar la <= =>aritmética por otras razones, por lo que le daré una alternativa fácil.
En lugar de aplicar la lógica de Vector3 <= Vector3o Vector3 >= Vector3, propongo extender la Vector3clase para incluir métodos para isGreaterOrEqual(Vector3 other)y isLesserOrEqual(Vector3). Podemos añadir los métodos de extensión a una structo classdeclarándolos en una staticclase que no hereda. También incluimos el objetivo classo structcomo primer parámetro, usando la thispalabra clave. Tenga en cuenta que en mi ejemplo, supongo que quiere asegurarse de que los tres valores principales ( x, yy z) son todos mayores o iguales, o menores o iguales, respectivamente. Puede proporcionar su propia lógica, aquí, según lo requiera.
public static class ExtendingVector3
{
public static bool IsGreaterOrEqual(this Vector3 local, Vector3 other)
{
if(local.x >= other.x && local.y >= other.y && local.z >= other.z)
{
return true;
}
else
{
return false;
}
}
public static bool IsLesserOrEqual(this Vector3 local, Vector3 other)
{
if(local.x <= other.x && local.y <= other.y && local.z <= other.z)
{
return true;
}
else
{
return false;
}
}
}
Cuando intentemos llamar a estos métodos desde la Vector3clase, localrepresentaremos la Vector3instancia desde la que estamos llamando al método. Notarás que los métodos son static; los métodos de extensión deben ser static, pero aún debe llamarlos desde una instancia. Dado los métodos de extensión anteriores, ahora puede aplicarlos directamente a sus Vector3tipos.
Vector3 left;
Vector3 right;
// Is left >= right?
bool isGreaterOrEqual = left.IsGreaterOrEqual(right);
// Is left <= right?
bool isLesserOrEqual = left.IsLesserOrEqual(right);
Moviéndose Vector3conVector3.Lerp
Llamar al Vector3.Lerpmétodo nos permite determinar la posición exacta entre dos Vector3valores en un momento dado. Un beneficio adicional de este método es que el Vector3no sobrepase su objetivo . Vector3.Lerptoma tres parámetros; la posición inicial, la posición final y la posición actual representada como un valor entre 0 y 1. Produce la posición resultante como a Vector3, que podemos establecer directamente como la posición actual.
Para resolver su problema, propongo usar Vector3.Lerppara pasar a a targetPosition. Después de llamar al Movemétodo en cada uno Update, podemos verificar si hemos alcanzado dicho objetivo; Lerp.Vector3lo hará sin exceso, por lo que transform.position == targetPositionse convierte en fiable. Ahora podemos comprobar la posición y cambiar el targetPositiona leftPositiono rightPositioninvertir el movimiento, en consecuencia.
public Vector3 leftPosition, rightPosition;
public float speed;
public Vector3 targetPosition;
private void Awake()
{
targetPosition = rightPosition;
}
private void Update()
{
Move();
if(transform.position == targetPosition)
{
// We have arrived at our intended position. Move towards the other position.
if(targetPosition == rightPosition)
{
// We were moving to the right; time to move to the left.
targetPosition = leftPosition;
}
else
{
// We were moving to the left; time to move to the right.
targetPosition = rightPosition;
}
}
}
private void Move()
{
// First, we need to find out the total distance we intend to move.
float distance = Vector3.Distance(transform.position, targetPosition);
// Next, we need to find out how far we intend to move.
float movement = speed * Time.deltaTime;
// We find the increment by simply dividing movement by distance.
// This will give us a decimal value. If the decimal is greater than
// 1, we are moving more than the remaining distance. Lerp
// caps this number at 1, which in turn, returns the end position.
float increment = movement / distance;
// Lerp gives us the absolute position, so we pass it straight into our transform.
transform.position = Vector3.Lerp(transform.position, targetPosition, increment);
}
Puede ver esto demostrado en la siguiente animación. Traduzco el cubo azul con Vector3.LerpUnclamped, lo que nos da un resultado similar a la traducción simple no verificada. Traduzco el cubo rojo usando Vector3.Lerp. Si no se controla, el cubo azul se va al olvido; mientras que el cubo rojo se detiene exactamente donde lo pretendo. Puede leer más sobre este tipo de movimiento en la documentación de Stack Overflow .
Boolsgusta_atPosAy_atPosB. Inevitablemente, cometerá un error manteniéndolos sincronizados a ambos, y dará lugar a errores. Es mejor hacer un queenumcontenga todas las posiciones (A, B, quizás otras en el futuro), y usar eso