यूनिटी 3 डी में रिगिडो जंप फोर्स एंड बाउंस मैग्नेटिट्यूड के संयोजन को रोकना


10

मैं यूनिटी 3 डी में एक काफी सरल संगमरमर रेसिंग गेम बना रहा हूं। गेंद एक 3 डी भौतिकी वस्तु है जो केवल एक्स और वाई कुल्हाड़ियों पर चलती है। इसमें बाएं और दाएं रोल करने और कूदने की क्षमता है। सुंदर बुनियादी सामान, सिवाय इसके कि मैंने एक गेम-ब्रेकिंग समस्या को मारा है: जब जमीन गिरती है और स्ट्राइक होती है, तो गेंद की उछाल परिमाण को एक अतिरिक्त-उच्च कूद बनाने के लिए अपने जंपिंग बल के साथ जोड़ा जा सकता है। इसका मतलब यह है कि, अच्छी तरह से समय पर बटन दबाने के साथ, खिलाड़ी गेंद को तेजी से उछाल देने का कारण बन सकता है, अनपेक्षित ऊंचाइयों तक पहुंच सकता है। जब तक यह गड़बड़ ठीक नहीं हो जाती, तब तक मैं स्तरों को ठीक से डिज़ाइन नहीं कर सकता। मैंने इसका उदाहरण दिया है:

गेंद उछल बनाम गेंद उछल + कूद

हालाँकि, कूदना उतना आसान नहीं है, जितना कि सीधे गेंद को ऊपर की तरफ मारना। स्तर के डिजाइन में अधिक जटिलता की सुविधा के लिए, मैंने गेंद को रोल करने वाली सतह के सापेक्ष होने के लिए कूद कोण को क्रमादेशित किया है।

बॉल जंप एंगल तुलना

चित्र 3 , उस दृष्टांत में, इस तरह से मेरा खेल काम करता है; चित्र 4 नहीं । यह उछाल + कूदने की समस्या को और अधिक चुनौतीपूर्ण बनाता है, क्योंकि मैं केवल Y- अक्ष पर एक सटीक बल या वेग नहीं माप सकता / सकती हूं। ऐसा करने से अजीब व्यवहार होता है, जो नाटकीय रूप से अधिक ध्यान देने योग्य हो जाता है क्योंकि गेंद स्टिपर स्लोप पर जाती है।

अब तक, मैं इस गेम में अन्य सभी डिज़ाइन समस्याओं का समाधान करने में सक्षम हूं और फिर पता लगाऊं कि उन्हें कैसे प्रोग्राम करना है, लेकिन यह मुझे अटक गया है। मैंने कई अलग-अलग तरीकों से प्रयास किया है, लेकिन उनमें से किसी ने भी काम नहीं किया है।

यहाँ सी # स्क्रिप्ट है जो गेंद की कूद को नियंत्रित करती है:

using UnityEngine;
using System.Collections;

public class BallJumping : MonoBehaviour {

    public System.Action onJump;
    public Rigidbody objRigidbody; // Set this to the player
    public bool isGrounded; // Determines whether or not the ball is on the ground
    public Transform groundChecker; // A child object that's slightly larger than the ball
    public float groundRadius = 0.6f;
    public LayerMask whatIsGround; // Determines what layers qualify as ground
    public AudioClip jumpSFX;
    public AudioClip stickyJumpSFX;
    private float p_WillJumpTimeRemaining; // Grace periods before/after hitting the ground to trigger jump
    private float p_CanJumpTimeRemaining;
    public float earlyJumpToleranceDuration = 0.2f;
    public float lateJumpToleranceDuration = 0.2f;
    public float jump = 500f; // Jumping power
    private float halfJump = 250f; // Used for the sticky puddles
    public bool stuck = false; // Used for sticky materials
    private float contactX;
    private float contactY;


    // Input for jumping
    void Update () {
        if (Input.GetButtonDown ("Jump") && isGrounded == true) {
            ProcessJump();
        }
    }


    // Continuously checks whether or not the ball is on the ground
    void FixedUpdate () {
        if (Physics.CheckSphere (groundChecker.position, groundRadius, whatIsGround) == true) {
            isGrounded = true;
        } else {
            isGrounded = false;
        }
    }


    // Sets a grace period for before or after the ball contacts the ground for jumping input
    void ProcessJump () {
        bool boolGetJump = Input.GetButtonDown("Jump");

        if (boolGetJump && isGrounded == false) {
            p_WillJumpTimeRemaining = earlyJumpToleranceDuration;
        } else {
            if (p_WillJumpTimeRemaining > 0) {
                p_WillJumpTimeRemaining -= Time.fixedDeltaTime;
            }
        }

        if (isGrounded) {
            p_CanJumpTimeRemaining = lateJumpToleranceDuration;
        }

        if (isGrounded || p_WillJumpTimeRemaining > 0) {
            Jump();
        }

        if (p_CanJumpTimeRemaining > 0) {
            p_CanJumpTimeRemaining -= Time.fixedDeltaTime;
        }
    }


    // Sticky puddles script -- hinders jumping while in the puddle
    void OnTriggerEnter (Collider collision) {
        if (collision.gameObject.tag == "Sticky") {
            stuck = true;
        }
    }

    void OnTriggerExit (Collider collision) {
        if (collision.gameObject.tag == "Sticky") {
            stuck = false;
        }
    }


    // Calculates the normals for the jump angle
    void OnCollisionStay (Collision collision) {
        Debug.Log ("Collision.");
        foreach (ContactPoint contact in collision.contacts) {
            contactX = contact.normal.x;
            contactY = contact.normal.y;
        }
    }


    // Controls jumping
    void Jump() {
        Debug.Log ("Jump.");
        p_WillJumpTimeRemaining = 0.0f;
        p_CanJumpTimeRemaining = 0.0f;
        halfJump = jump * 0.5f; // Cuts jumping force in half while in a sticky puddle

        GetComponent<AudioSource>().volume = 1;
        GetComponent<AudioSource>().pitch = Random.Range (0.9f, 1.1f);

        if (stuck == false) {
            objRigidbody.AddForce (contactX * jump, contactY * jump, 0);
            GetComponent<AudioSource>().clip = jumpSFX;
            GetComponent<AudioSource>().Play ();
        }
        else if (stuck == true) {
            objRigidbody.AddForce (contactX * halfJump, contactY * halfJump, 0);
            GetComponent<AudioSource>().clip = stickyJumpSFX;
            GetComponent<AudioSource>().Play ();
        }


        if (onJump != null) {
            onJump();
        }
    }
}

मेरी नवीनतम कोशिश थी कि कूदने की कोशिश करना - rigidbody.velocity.magnitude * 50 , जिस गति से गेंद यात्रा कर रही है, उससे कूदने की शक्ति को कम करना। इसने उछाल + कूद की समस्या को लगभग हल कर दिया, आनुपातिक रूप से कूद बल को शून्य से कम करने के रूप में गेंद की गति तक पहुंच गई जो वेगमान गति में बराबर प्रतीत होती थी। यह एक ठहराव से काम करता है, लेकिन समस्या यह है, यह भी परिमाण के लिए जिम्मेदार है, जबकि गेंद जमीन पर है, गेंद को पूरी गति से लुढ़कने और कूदने से रोकती है। मैं करीब था, लेकिन काफी नहीं!

मैं नौसिखिया प्रोग्रामर हूं, और मैं यहां आकर रुक गया हूं। क्या कोई इस समस्या का रचनात्मक समाधान खोजने में मेरी मदद कर सकता है? जब तक खिलाड़ी लगातार उछाल और उच्चतर कूदने में सक्षम होता है, मैं किसी भी स्तर को डिजाइन नहीं कर सकता, क्योंकि वे सभी के माध्यम से धोखा देने में सक्षम होंगे। मैं आगे बढ़ना पसंद करूँगा - यह मुद्दा मुझे लंबे समय से पकड़ रहा है, इसलिए मैं कुछ सलाह देना चाहूँगा!


अच्छा सवाल :) क्या आपने भौतिक सामग्रियों के साथ खेलने की कोशिश की? आप जमीन की बाउंसनेस को शून्य (या बहुत कम मान) पर सेट कर सकते हैं। शायद खिलाड़ी भी, यह निर्भर करता है।
7:15 पर M156

जवाबों:


0

सबसे पहले, मैं यह कहना चाहता हूं कि आपका प्रश्न बहुत अच्छा लिखा गया है और यह खुशी की बात है :), आपको कोड (ऑडिओसॉर्स, इत्यादि) में जो आवश्यक नहीं है उसे निकालने की आवश्यकता होगी और यह एकदम सही होगा। उसके लिए चीयर्स।

जवाब के लिए, आप सकता क्लैंप अपने वेग जब कूद, जब कूद बटन दबाने जो बहुत अधिक गति तक पहुँचने से रोकने जाएगा।


0

जबकि मैं व्यक्तिगत रूप से बनी hopping से प्यार करता हूँ ... एक प्रारंभिक बिंदु के रूप में हमें डेल्टा वेग के रूप में "जंप स्पीड" का उद्देश्य जानना चाहिए। यह आंकड़ा एक बार कूदने के तुरंत दौरान वेग वृद्धि ("जंप नॉर्मल" के साथ लाइन में) का प्रतिनिधित्व करता है।

जो खिलाड़ी पहले से ही जंप नॉर्मल के अनुरूप है, उसे पहले से मौजूद "जंप एनर्जी" के रूप में देखा जा सकता है। यह एक सीधा समाधान की ओर जाता है: तात्कालिक डेल्टा वेग को इस तरह सीमित किया जा सकता है कि इससे खिलाड़ी कभी भी लक्ष्य वेग से आगे नहीं बढ़ पाता है।

आपकी पहले से मौजूद जम्प स्पीड को मापने के लिए, हम आपके सामान्यीकृत जम्प वेक्टर के डॉट उत्पाद को ले सकते हैं, और आपके खिलाड़ी के वेलकम पासवर्ड:

Vector2 JumpNormal = Vector2(contactX, contactY).normalized;
Vector2 PlayerVelocity = objRigidbody.velocity;
float ExistingSpeed = Vector2.Dot(PlayerVelocity, JumpNormal);
if (ExistingSpeed < 0) ExistingSpeed = 0;

"मौजूदा गति" को भी यहां गैर-नकारात्मक के लिए मजबूर किया जाता है; जब खिलाड़ी गिर रहा होता है, तो एक नकारात्मक मौजूदा कूद गति उनके गिरने की भरपाई करेगी, यदि वे गिरने पर कूद को ट्रिगर करते हैं तो उन्हें पतली हवा में उछालने की अनुमति मिलती है।

अब जब हम जानते हैं कि डेल्टा के वेग को कम करने के लिए कितना सही है, तो हम जम्प नॉर्मल को लक्ष्य डेल्टा वेग में स्केल करके प्रभावी "जम्प वेक्टर" की गणना कर सकते हैं।

float AdjustedSpeed = JumpSpeed - ExistingSpeed;
if (AdjustedSpeed < 0) AdjustedSpeed = 0;
Vector2 JumpVector = JumpNormal * AdjustedSpeed;
objRigidbody.velocity += JumpVector;

इस बार समायोजित कूद गति को गैर-नकारात्मक के लिए मजबूर किया जा रहा है; यदि खिलाड़ी पहले से ही तेजी से बढ़ रहा है तो उन्हें कूदने में सक्षम होना चाहिए, तो वे एक नकारात्मक समायोजित गति प्राप्त करेंगे, जो उन्हें ब्रेक के रूप में "कूद" कार्रवाई का उपयोग करने की अनुमति देता है। (तुरन्त इच्छित कूद गति को धीमा करने के लिए!)

नोट: मेरा मानना ​​है कि आपके संपर्क X और Y पहले से ही एक जोड़ी के रूप में सामान्यीकृत हैं। मैं हालांकि पूर्णता के लिए स्पष्ट विवरण शामिल था।


0

यह उत्तर संभवतः आपके द्वारा खोजे जा रहे डिज़ाइन परिवर्तन से अधिक है, लेकिन इसके बारे में कैसे - गेंद को छोटी अवधि के बाद जंप बटन दबाया जाता है जहाँ यह जमीन पर मजबूती से टिकता है और किसी भी उर्ध्वाधर लंबवत को रद्द करता है (शायद स्क्वाशिंग एक वसंत जैसी संपीड़न को निरूपित करने के लिए), फिर उस अवधि के बाद ऊपर की ओर छलांग लगाता है। यह उछाल की गति को कूद में जोड़ने की समस्या को हल करेगा, हालांकि यह खिलाड़ियों को नियंत्रित करने की अनुमति देगा कि वे बाउंस हुए हैं या केवल कूद गए हैं या नहीं। यह जंप फंक्शन में देरी को भी जोड़ता है, जिसे अच्छे के रूप में देखा जा सकता है (अधिक प्राकृतिक लगता है) या बुरा (खिलाड़ियों को प्रतिक्रिया देने के लिए पर्याप्त समय नहीं देता है)।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.