Я работал над этим проектом некоторое время - я пытался получить простой куб, чтобы игрок мог перемещаться влево или вправо с помощью стрелок с возможностью вращения вокруг трубы, подобно тому, как гонщики могут двигаться вокруг трубы в F-Zero GX:
https://www.youtube.com/watch?v=RlS1i7aCnvg
Теперь я знаю, что я не первый, кто пытается попытаться реализовать эту физику, поскольку я прочитал две-три темы от людей, которые пытались реализовать подобные методы. Проблема в том, что я пытался поиграть с этими разными методами или их вариациями. Один из них стал действовать ОЧЕНЬ близко к желаемому поведению, но куб игрока ОСТАЕТСЯ неожиданно вращаться вокруг своей оси X после того, как куб переместится на полпути по всей стене трубы от земли. Вот визуальный пример построения уровня, о котором я говорю:
Вся идея этого заключается в том, что куб может «двигаться» или «ходить» по всей стене трубы, как вы видите в секциях трубы в видео F-Zero, хотя, конечно, все еще движется вперед. У меня есть цилиндр, который на самом деле находится внутри того, который вы видите, который на самом деле является просто выпуклым триггером - так что он используется для того, чтобы убедиться, что гравитационный тик куба игрока выключен, когда куб находится внутри модели трубы.
Я уже близко подошел к выполнению этой работы, но это вопрос того, чтобы игрок мог двигаться полностью по кругу, т.е. двигайтесь круговыми движениями полностью назад ко дну или туда, где игрок начал входить в трубу. Тем не менее, кубу нравится «переворачиваться», когда он завершает путешествие по стене чуть более чем наполовину. В другом посте я читал, что кто-то на самом деле изменил твердое тело объекта, чтобы «корабль» остался в вертикальном положении, это как-то связано с этим?
https://forum.unity.com/threads/f-zero-esque-control-question.157909/
«По сути, я подарил своему автомобилю юбку для парения».
Должен ли я рассмотреть вопрос об изменении формы моего твердого тела соответственно? Какой лучший ресурс для этого? Или, возможно, я должен использовать вместо этого контроллер персонажа? Я все еще полагаюсь на настройку жесткого тела, но я прочитал об этом после прочтения.
Этот код Raycast очень близок к тому, что я хотел, без кубиков:
float distDown = Mathf.Infinity;
RaycastHit hitDown;
if (Physics.SphereCast(transform.position, 0.25f, -transform.up, out hitDown, 5))
{
distDown = hitDown.distance;
}
transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(Vector3.Cross(transform.right, hitDown.normal), hitDown.normal), Time.deltaTime * 1.0f);
Еще одна возможность, которую я пытался изучить, - это создание собственного гравитационного притяжения - у меня даже есть класс, который пытается это сделать, FauxGravity, который прикреплен к объекту, с которым сталкивается игрок (в данном случае цилиндр):
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class FauxGravity : MonoBehaviour {
public Transform attractor;
public Transform player;
public Transform collider;
Rigidbody attractRB;
Rigidbody playerRB;
Vector3 myNormal;
public Vector3 vectorFromPipeCenter;
public Vector3 forwardPipeVector;
Vector3 project2Center;
public Vector3 pipeGravityPull;
public int gravity = 1;
// Use this for initialization
void Start () {
//Physics.gravity.magnitude = 0;
}
// Update is called once per frame
void Update () {
}
//private void OnCollisionEnter(Collision collision)
//{
// //collision.gameObject.GetComponent<Rigidbody>().transform.up = Vector3.zero;
// //player.gameObject.GetComponent<Rigidbody>().useGravity = false;
// myNormal = playerRB.transform.up;
// //playerRB = collision.gameObject.GetComponent<Rigidbody>();
// gravity = 0;
// //playerRB.isKinematic = true;
// //player.gameObject.GetComponent<Rigidbody>().AddRelativeForce()
//}
public void FixedUpdate()
{
if (gravity == 0)
{
//playerRB.isKinematic = true;
//Debug.Log("Gravity is 0.");
attractRB = attractor.GetComponent<Rigidbody>();
playerRB = player.GetComponent<Rigidbody>();
//playerRB.AddForce(-10 * playerRB.mass * myNormal);
Debug.Log("PlayerRB position: " + playerRB.position);
Debug.Log("AttractRB position: " + attractRB.position);
vectorFromPipeCenter = playerRB.position - attractRB.position;
vectorFromPipeCenter.z = 0;
//vectorFromPipeCenter.Normalize();
Debug.Log("Player distance from pipe center: " + vectorFromPipeCenter.magnitude);
Debug.Log("Player vector from pipe center" + vectorFromPipeCenter);
//vectorFromPipeCenter = attractRB.position - playerRB.position;
Debug.Log("playerRB forward is " + playerRB.rotation.z);
Debug.Log("playerRB magnitude is " + player.forward.magnitude);
forwardPipeVector = player.forward.magnitude * Vector3.forward;
Debug.Log("Player forward vector? " + forwardPipeVector);
// or
//Vector forwardPipeVector = pipeTransform.forward;
// And finally
project2Center = Vector3.Project(vectorFromPipeCenter, forwardPipeVector);
Debug.Log("What is project2Center? " + project2Center);
float radiusFromCrossectionCenter = vectorFromPipeCenter.magnitude;
double playerY = System.Convert.ToDouble(playerRB.position.y);
double playerX = System.Convert.ToDouble(playerRB.position.x);
//float inverseTan = System.Convert.ToSingle(System.Math.Atan(playerY / playerX));
//Debug.Log("Normal is: " + Quaternion.AngleAxis(inverseTan, forwardPipeVector));
// pipe pull force = distance from pipe center to power 2
//pipeGravityPull = Quaternion.AngleAxis(inverseTan, playerRB.transform.forward) * project2Center * Mathf.Pow ( (radiusFromCrossectionCenter * 1 ), 2 );
pipeGravityPull = new Vector3(playerRB.position.x, radiusFromCrossectionCenter - playerRB.position.y, 0)/Mathf.Sqrt(Mathf.Pow(playerRB.position.x,2) + Mathf.Pow((radiusFromCrossectionCenter-playerRB.position.y),2));
Debug.Log("Pipe gravity vector? " + pipeGravityPull);
//playerRB.useGravity = true;
Debug.DrawLine(pipeGravityPull, pipeGravityPull);
Debug.Log("Adding force from FG");
//playerRB.AddForce(pipeGravityPull);
}
if (gravity == 1)
{
player.GetComponent<Rigidbody>().useGravity = true;
//playerRB.isKinematic = false;
}
}
private void OnCollisionExit(Collision collision)
{
//Debug.Log("Gravity is 1 again.");
//player.gameObject.GetComponent<Rigidbody>().useGravity = true;
//gravity = 1;
//playerRB.useGravity = true;
playerRB.isKinematic = false;
//playerRB.AddForce(10, 20, 0);
}
void gravityAttract(Collider colliderObject)
{
var rb = colliderObject.GetComponent<Rigidbody>();
rb.AddForce(Vector3.down * 30, ForceMode.Force);
rb.AddForce(Vector3.up * 30, ForceMode.Force);
}
}
Нужно ли вместо этого переместить мою логику FixedUpdate в метод Update? Последний алгоритм, который я исследовал в этом подходе, по сути, гарантирует, что тяга всегда равна 1, принимая вектор игрока с поперечным сечением трубы, по которой он / она движется, по словам моего отца (он астрофизик) .
Вот класс движения моего игрока, который имеет несколько прокомментированных и некомментированных попыток повернуть куб, чтобы нижняя сторона куба всегда была обращена к стене трубы, когда он поднимается:
using System;
using UnityEngine;
public class PlayerMovement : MonoBehaviour {
public Rigidbody rb;
public float forwardForce = 2000f;
public float sidewaysForce = 500f;
public Boolean fauxGravity = false;
public Vector3 distanceFromPipeCenter = new Vector3(0, 0, 0);
public Vector3 pipePull = new Vector3(0,0,0);
// Use this for initialization
void Start () {
}
// Update is called once per frame use fixed update for Unity Fizzix
void FixedUpdate () {
//distanceFromPipeCenter.Normalize();
//add forward force
rb.AddForce(0, 0, forwardForce * Time.deltaTime);
if (Input.GetKey(KeyCode.RightArrow)/* && !fauxGravity*/)
{
rb.AddForce(sidewaysForce * Time.deltaTime, 0, 0, ForceMode.VelocityChange);
}
if (Input.GetKey(KeyCode.LeftArrow)/* && !fauxGravity*/)
{
rb.AddForce(-sidewaysForce * Time.deltaTime, 0, 0, ForceMode.VelocityChange);
}
if (pipePull.x == 0)
{
pipePull.x = 1;
}
if (pipePull.y == 0)
{
pipePull.y = 1;
}
//transform.rotation = Quaternion.identity;
//pipePull.z = 0;
if (Input.GetKey(KeyCode.RightArrow) && fauxGravity)
{
Debug.Log("Right pressed");
//Debug.Log("Rotation before: " + rb.rotation);
//rb.rotation = rb.rotation * Quaternion.FromToRotation(rb.transform.up, pipePull);
//rb.rotation = Quaternion.Lerp(rb.rotation, Quaternion.LookRotation(Vector3.Cross(rb.transform.right, pipePull), pipePull), Time.deltaTime * 5.0f);
//Debug.Log("Rotation after: " + rb.rotation);
//if (distanceFromPipeCenter.y < 0)
//{
// Debug.Log("Right A, pull positive: " +pipePull);
//rb.AddForce(sidewaysForce * pipePull.x * Time.deltaTime, sidewaysForce * pipePull.y * Time.deltaTime, 0, ForceMode.VelocityChange);
//}
//else
//{
// Debug.Log("Right B, pull negative: " + distanceFromPipeCenter);
// rb.AddForce(sidewaysForce * pipePull.x * Time.deltaTime, -sidewaysForce * pipePull.y * Time.deltaTime, 0, ForceMode.VelocityChange);
//}
//Debug.Log(rb.angularVelocity);
//float headingDeltaAngle = Input.GetAxis("Horizontal") * Time.deltaTime * sidewaysForce;
//Quaternion headingDelta = Quaternion.AngleAxis(headingDeltaAngle, transform.up);
//align with surface normal
//transform.rotation = Quaternion.FromToRotation(transform.up, distanceFromPipeCenter) * transform.rotation;
//apply heading rotation
//transform.rotation = headingDelta * transform.rotation;
}
if (Input.GetKey(KeyCode.LeftArrow) && fauxGravity)
{
Debug.Log("Left pressed");
//Debug.Log("Rotation before: " + rb.rotation);
//rb.rotation = rb.rotation * Quaternion.FromToRotation(rb.transform.up, pipePull);
//rb.rotation = Quaternion.Lerp(rb.rotation, Quaternion.LookRotation(Vector3.Cross(rb.transform.right, pipePull), pipePull), Time.deltaTime * 5.0f);
//Debug.Log("Rotation after: " + rb.rotation);
//if (distanceFromPipeCenter.y < 0)
//{
// Debug.Log("Left A, pull positive: " +pipePull);
//rb.AddForce(-sidewaysForce * pipePull.x * Time.deltaTime, sidewaysForce * pipePull.y * Time.deltaTime, 0, ForceMode.VelocityChange);
//}
//else
//{
// Debug.Log("Left B, pull negative: " + distanceFromPipeCenter);
// rb.AddForce(-sidewaysForce * pipePull.x * Time.deltaTime, -sidewaysForce * pipePull.y * Time.deltaTime, 0, ForceMode.VelocityChange);
//}
//Debug.Log(rb.angularVelocity);
//float headingDeltaAngle = Input.GetAxis("Horizontal") * Time.deltaTime * sidewaysForce;
//Quaternion headingDelta = Quaternion.AngleAxis(headingDeltaAngle, transform.up);
//align with surface normal
//transform.rotation = Quaternion.FromToRotation(transform.up, distanceFromPipeCenter) * transform.rotation;
//apply heading rotation
//transform.rotation = headingDelta * transform.rotation;
}
if (fauxGravity)
{
rb.useGravity = false;
///*We get the user input and modifiy the direction the ship will face towards*/
//float yaw = Time.deltaTime * Input.GetAxis("Horizontal");
///*We want to save our current transform.up vector so we can smoothly change it later*/
//Vector3 prev_up = rb.transform.up;
///*Now we set all angles to zero except for the Y which corresponds to the Yaw*/
//transform.rotation = Quaternion.Euler(0, yaw, 0);
//RaycastHit hit;
//if (Physics.Raycast(transform.position, -prev_up, out hit))
//{
// Debug.DrawLine(transform.position, hit.point);
// /*Here are the meat and potatoes: first we calculate the new up vector for the ship using lerp so that it is smoothed*/
// Vector3 desired_up = Vector3.Lerp(prev_up, hit.normal, Time.deltaTime /** pitch_smooth*/);
// /*Then we get the angle that we have to rotate in quaternion format*/
// Quaternion tilt = Quaternion.FromToRotation(transform.up, desired_up);
// /*Now we apply it to the ship with the quaternion product property*/
// transform.rotation = tilt * transform.rotation;
// /*Smoothly adjust our height*/
// //smooth_y = Mathf.Lerp(smooth_y, hover_height - hit.distance, Time.deltaTime * height_smooth);
// //transform.localPosition += prev_up * smooth_y;
//}
//float distForward = Mathf.Infinity;
//RaycastHit hitForward;
//if (Physics.SphereCast(transform.position, 0.25f, -transform.up + transform.forward, out hitForward, 5))
//{
// distForward = hitForward.distance;
//}
float distDown = Mathf.Infinity;
RaycastHit hitDown;
if (Physics.SphereCast(transform.position, 0.25f, -transform.up, out hitDown, 5))
{
distDown = hitDown.distance;
}
//float distBack = Mathf.Infinity;
//RaycastHit hitBack;
//if (Physics.SphereCast(transform.position, 0.25f, -transform.up + -transform.forward, out hitBack, 5))
//{
// distBack = hitBack.distance;
//}
//if (distForward < distDown && distForward < distBack)
//{
// transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(Vector3.Cross(transform.right, hitForward.normal), hitForward.normal), Time.deltaTime * 5.0f);
//}
//else if (distDown < distForward && distDown < distBack)
//{
transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(Vector3.Cross(transform.right, hitDown.normal), hitDown.normal), Time.deltaTime * 1.0f);
//}
//else if (distBack < distForward && distBack < distDown)
//{
// transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(Vector3.Cross(transform.right, hitBack.normal), hitBack.normal), Time.deltaTime * 5.0f);
//}
//GetComponent<Rigidbody>().AddForce(-transform.up * Time.deltaTime * 10);
}
if (rb.position.y <-1f)
{
FindObjectOfType<GameManagement>().EndGame();
}
}
//void OnCollisionEnter(Collision collision)
//{
// //collision.gameObject.GetComponent<Rigidbody>().transform.up = Vector3.zero;
// //player.gameObject.GetComponent<Rigidbody>().useGravity = false;
// System.Console.WriteLine("Player has collided with: " + collision.collider.name);
// if(collision.gameObject.name == "PipeBasic 1")
// {
// System.Console.WriteLine("Player Collided with Pipe");
// fauxGravity = true;
// }
// //playerRB.isKinematic = true;
// //player.gameObject.GetComponent<Rigidbody>().AddRelativeForce()
//}
}
Может ли кто-нибудь дать дополнительные советы, подсказки и рекомендации? Я бы подумал, что использование Raycast и даже его SphereCast, вероятно, будет наиболее близким подходом к тому, что я хочу, но я просто застрял на том, как бы я его точно реализовал, не рискуя повернуть куб игрока на изнанка и испорченное физическое взаимодействие. Может быть, я слишком много думаю об этом?
Большое спасибо всем заранее.
UPDATE:
Я менял логику скорости Y игрока, поскольку движение по кругу должно включать определенную физику, например, уравнение, приведенное на странице ниже:
https://www.physicsclassroom.com/class/circles/Lesson-1/Speed-and-Velocity
Однако я все еще изо всех сил пытаюсь найти хорошее время, чтобы разделить верхнюю часть уравнения против. Вот мой код движения при движении вправо:
if (distanceFromPipeCenter.y < 0)
{
//Debug.Log("Right A, pull positive: " + pipePull);
//Debug.Log("X Pull: " + pipePull.x);
rb.AddForce(sidewaysForce /** pipePull.x*/ * Time.deltaTime, (sidewaysForce * 2 * radiusInPipe * (float)Math.PI) / Time.deltaTime, 0, ForceMode.VelocityChange);
}
else if(distanceFromPipeCenter.x>=3)
{
//Debug.Log("Right B, pull negative: " + distanceFromPipeCenter);
rb.AddForce(-sidewaysForce /** pipePull.x*/ * Time.deltaTime, (sidewaysForce * 2 * radiusInPipe * (float)Math.PI) / Time.deltaTime, 0, ForceMode.VelocityChange);
}
else if(distanceFromPipeCenter.x>0)
{
rb.AddForce(-sidewaysForce /** pipePull.x*/ * Time.deltaTime, (sidewaysForce * 2 * radiusInPipe * (float)Math.PI) / Time.deltaTime, 0, ForceMode.VelocityChange);
}
else if(distanceFromPipeCenter.y>0)
{
Debug.Log("X distance: " + distanceFromPipeCenter.x);
Debug.Log("Radius: " + radiusInPipe);
Debug.Log("Frame count? " + Time.fixedDeltaTime);
Vector3 pull = new Vector3(-sidewaysForce /** pipePull.x*/ * Time.deltaTime, ((-sidewaysForce * 2 * radiusInPipe * (float)Math.PI) / Time.fixedDeltaTime) * Time.deltaTime, 0);
Debug.Log("About to apply: " + pull );
rb.AddForce(-sidewaysForce /** pipePull.x*/ * Time.deltaTime, (-sidewaysForce * 2 * radiusInPipe * (float)Math.PI) / Time.deltaTime, 0, ForceMode.VelocityChange);
}
else
{
rb.AddForce(sidewaysForce /** pipePull.x*/ * Time.deltaTime, (-sidewaysForce * 2 * radiusInPipe * (float)Math.PI) / Time.deltaTime, 0, ForceMode.VelocityChange);
}
Кажется, что деление на Time.deltaTime просто прыгает на игрока на огромное расстояние - не то, что я хочу. Я также попытался использовать количество времени с начала игры в качестве делителя, а затем умножить весь результат на Time.deltaTime - но, как вы, вероятно, можете сделать вывод, кадры просто увеличиваются, а затем в конечном итоге замедляют скорость таким образом .
Есть еще мысли или предложения?