यूनिटी के लिए रिगिडबॉडी-आधारित प्लैनेटरी प्लेयर कंट्रोलर

प्लेयर कंट्रोलर बनाते समय, गुरुत्वाकर्षण आमतौर पर केवल एक दिशा में लागू होता है, जो नीचे है।

लेकिन केंद्रीय बिंदु वाले गुरुत्वाकर्षण के बारे में क्या? यह ग्रहों पर चलने वाले का काम है।

ग्रहीय वॉकर एक प्रकार का नियंत्रक है जो खिलाड़ी को गोलाकार वस्तु (बिल्कुल ग्रहों की तरह) पर चलने की अनुमति देता है, जिसका गुरुत्वाकर्षण केंद्र गोले के केंद्र में होता है।

कदम

गुरुत्वाकर्षण के एक केंद्रीय बिंदु के साथ एक ग्रहीय कठोर बॉडी वॉकर बनाने के चरण नीचे दिए गए हैं Unity:

• दृश्य को अपने वृत्ताकार स्तर से खोलें (मेरे मामले में मेरे पास दृश्य में एक कस्टम-निर्मित ग्रह मॉडल और एक कस्टम स्काईबॉक्स है)

• एक नई स्क्रिप्ट बनाएं, उसे कॉल करें "SC_RigidbodyWalker" और उसके अंदर नीचे दिया गया कोड पेस्ट करें:

SC_RigidbodyWalker.cs

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

[RequireComponent(typeof(Rigidbody))]
[RequireComponent(typeof(CapsuleCollider))]

public class SC_RigidbodyWalker : MonoBehaviour
{
    public float speed = 5.0f;
    public bool canJump = true;
    public float jumpHeight = 2.0f;
    public Camera playerCamera;
    public float lookSpeed = 2.0f;
    public float lookXLimit = 60.0f;

    bool grounded = false;
    Rigidbody r;
    Vector2 rotation = Vector2.zero;
    float maxVelocityChange = 10.0f;

    void Awake()
    {
        r = GetComponent<Rigidbody>();
        r.freezeRotation = true;
        r.useGravity = false;
        r.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
        rotation.y = transform.eulerAngles.y;

        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;
    }

    void Update()
    {
        // Player and Camera rotation
        rotation.x += -Input.GetAxis("Mouse Y") * lookSpeed;
        rotation.x = Mathf.Clamp(rotation.x, -lookXLimit, lookXLimit);
        playerCamera.transform.localRotation = Quaternion.Euler(rotation.x, 0, 0);
        Quaternion localRotation = Quaternion.Euler(0f, Input.GetAxis("Mouse X") * lookSpeed, 0f);
        transform.rotation = transform.rotation * localRotation;
    }

    void FixedUpdate()
    {
        if (grounded)
        {
            // Calculate how fast we should be moving
            Vector3 forwardDir = Vector3.Cross(transform.up, -playerCamera.transform.right).normalized;
            Vector3 rightDir = Vector3.Cross(transform.up, playerCamera.transform.forward).normalized;
            Vector3 targetVelocity = (forwardDir * Input.GetAxis("Vertical") + rightDir * Input.GetAxis("Horizontal")) * speed;

            Vector3 velocity = transform.InverseTransformDirection(r.velocity);
            velocity.y = 0;
            velocity = transform.TransformDirection(velocity);
            Vector3 velocityChange = transform.InverseTransformDirection(targetVelocity - velocity);
            velocityChange.x = Mathf.Clamp(velocityChange.x, -maxVelocityChange, maxVelocityChange);
            velocityChange.z = Mathf.Clamp(velocityChange.z, -maxVelocityChange, maxVelocityChange);
            velocityChange.y = 0;
            velocityChange = transform.TransformDirection(velocityChange);

            r.AddForce(velocityChange, ForceMode.VelocityChange);

            if (Input.GetButton("Jump") && canJump)
            {
               r.AddForce(transform.up * jumpHeight, ForceMode.VelocityChange);
            }
        }

        grounded = false;
    }

    void OnCollisionStay()
    {
        grounded = true;
    }
}

• एक नई स्क्रिप्ट बनाएं, उसे कॉल करें "SC_PlanetGravity" और उसके अंदर नीचे दिया गया कोड पेस्ट करें:

SC_PlanetGravity.cs

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

public class SC_PlanetGravity : MonoBehaviour
{
    public Transform planet;
    public bool alignToPlanet = true;

    float gravityConstant = 9.8f;
    Rigidbody r;

    void Start()
    {
        r = GetComponent<Rigidbody>();
    }

    void FixedUpdate()
    {
        Vector3 toCenter = planet.position - transform.position;
        toCenter.Normalize();

        r.AddForce(toCenter * gravityConstant, ForceMode.Acceleration);

        if (alignToPlanet)
        {
            Quaternion q = Quaternion.FromToRotation(transform.up, -toCenter);
            q = q * transform.rotation;
            transform.rotation = Quaternion.Slerp(transform.rotation, q, 1);
        }
    }
}

• एक नया गेमऑब्जेक्ट बनाएं और उसे कॉल करें "Player"
• एक नया कैप्सूल बनाएं, इसे "Player" ऑब्जेक्ट के अंदर ले जाएं और इसकी स्थिति को (0, 1, 0) में बदलें
• कैप्सूल से कैप्सूल कोलाइडर घटक निकालें
• मुख्य कैमरे को "Player" ऑब्जेक्ट के अंदर ले जाएं और उसकी स्थिति को (0, 1.64, 0) में बदलें
• ऑब्जेक्ट में SC_RigidbodyWalker स्क्रिप्ट संलग्न करें "Player" (आप देखेंगे कि यह Rigidbody और कैप्सूल कोलाइडर जैसे अतिरिक्त घटक जोड़ देगा)।
• कैप्सूल कोलाइडर की ऊंचाई को 2 और केंद्र को (0, 1, 0) में बदलें
• SC_RigidbodyWalker में प्लेयर कैमरा वेरिएबल को मुख्य कैमरा असाइन करें
• अंत में, SC_PlanetGravity स्क्रिप्ट को ऑब्जेक्ट से जोड़ें और अपने ग्रह मॉडल को प्लैनेट वेरिएबल पर असाइन करें "Player"

प्ले दबाएँ और प्लेयर को ग्रह की सतह पर संरेखित होते हुए देखें: