बॉल फिजिक्स: गेंद को आराम आते ही अंतिम बाउंस को स्मूथ करना


12

मैं अपनी छोटी उछाल वाली गेंद के खेल में एक और मुद्दे के खिलाफ आया हूं।

मेरी गेंद अंतिम क्षणों को छोड़कर ठीक-ठीक उछल रही है, जब वह आराम करने आने वाली है। गेंद की गति मुख्य भाग के लिए चिकनी होती है, लेकिन अंत में, गेंद थोड़ी देर के लिए झटका देती है क्योंकि यह स्क्रीन के तल पर बैठ जाती है।

मैं समझ सकता हूं कि ऐसा क्यों हो रहा है लेकिन मैं इसे सुचारू नहीं कर सकता।

मैं किसी भी सलाह के लिए आभारी रहूंगा जिसे पेश किया जा सकता है।

मेरा अपडेट कोड है:

public void Update()
    {
        // Apply gravity if we're not already on the ground
        if(Position.Y < GraphicsViewport.Height - Texture.Height)
        {
            Velocity += Physics.Gravity.Force;
        }            
        Velocity *= Physics.Air.Resistance;
        Position += Velocity;

        if (Position.X < 0 || Position.X > GraphicsViewport.Width - Texture.Width)
        {
            // We've hit a vertical (side) boundary
            // Apply friction
            Velocity *= Physics.Surfaces.Concrete;

            // Invert velocity
            Velocity.X = -Velocity.X;
            Position.X = Position.X + Velocity.X;
        }

        if (Position.Y < 0 || Position.Y > GraphicsViewport.Height - Texture.Height)
        {
            // We've hit a horizontal boundary
            // Apply friction
            Velocity *= Physics.Surfaces.Grass;

            // Invert Velocity
            Velocity.Y = -Velocity.Y;
            Position.Y = Position.Y + Velocity.Y;
        }
    }

शायद मुझे यह भी इंगित करना चाहिए Gravity, Resistance Grassऔर Concreteसभी प्रकार के हैं Vector2


बस इसकी पुष्टि करने के लिए: जब गेंद हिट होती है तो आपका "घर्षण" एक मूल्य <1 होता है, जो मूल रूप से विश्राम का गुणांक है ?
जॉर्ज लेइताओ

@ JCLeitão - सही है।
Ste

कृपया इनाम और सही जवाब देने पर वोटों का पालन करने की कसम न खाएं। जो भी आपकी मदद के लिए जाए।
आआआआआआआआआआ आआआआ

यह एक बुरी तरह से निपटने का एक बुरा तरीका है, मूल रूप से आप कह रहे हैं कि आप खुद को न्याय नहीं कर सकते हैं ताकि आप अपवोट्स को तय कर सकें ... वैसे भी, जो आप अनुभव कर रहे हैं वह एक आम टक्कर टक्कर है। यह एक अधिकतम इंटरपेनेट्रेशन राशि, एक न्यूनतम वेग या 'सीमा' के किसी भी अन्य रूप को सेट करके हल किया जा सकता है जो एक बार पहुंच जाने पर आपकी दिनचर्या को गति को रोक देगा और ऑब्जेक्ट को आराम करने के लिए डाल देगा। आप बेकार की जाँच से बचने के लिए अपनी वस्तुओं में आराम की स्थिति जोड़ना चाहते हैं।
डार्कविंग्स

@Darkwings - मुझे लगता है कि इस परिदृश्य में समुदाय मुझसे बेहतर जानता है कि सबसे अच्छा जवाब क्या है। यही कारण है कि upvotes मेरे निर्णय को प्रभावित करेगा। जाहिर है, अगर मैंने सबसे अधिक उत्थान के साथ समाधान की कोशिश की और इससे मुझे मदद नहीं मिली, तो मैं उस जवाब को नहीं दूंगा।
Ste

जवाबों:


19

यहाँ आपके भौतिकी सिमुलेशन पाश में सुधार के लिए आवश्यक कदम हैं।

1. टाइमस्टेप

आपके कोड के साथ मैं जो मुख्य समस्या देख सकता हूं, वह यह है कि यह भौतिक विज्ञान के चरण समय के लिए नहीं है। यह स्पष्ट होना चाहिए कि कुछ गड़बड़ है Position += Velocity;क्योंकि इकाइयां मेल नहीं खाती हैं। या तो Velocityवास्तव में एक वेग नहीं है, या कुछ गायब है।

अपने वेग और गुरुत्वाकर्षण मूल्यों ऐसी है कि प्रत्येक फ्रेम एक समय इकाई में क्या होता है छोटा कर रहे हैं यहां तक कि अगर 1(जिसका अर्थ है कि जैसे। Velocity वास्तव में इसका मतलब दूरी एक सेकंड में कूच), समय कहीं भी दिखाई देना चाहिए अपने कोड में, या तो परोक्ष चर ताकि फिक्सिंग द्वारा ( उनके नाम प्रतिबिंबित करते हैं कि वे वास्तव में क्या स्टोर करते हैं) या स्पष्ट रूप से (टाइमस्टेप शुरू करके)। मेरा मानना ​​है कि सबसे आसान काम समय इकाई घोषित करना है:

float TimeStep = 1.0;

और हर जगह उस मूल्य का उपयोग करें, जिसकी आवश्यकता है:

Velocity += Physics.Gravity.Force * TimeStep;
Position += Velocity * TimeStep;
...

ध्यान दें कि कोई भी सभ्य संकलक गुणा को सरल बना देगा 1.0, जिससे वह भाग धीमी नहीं होगा।

अब Position += Velocity * TimeStepभी बहुत सटीक नहीं है ( इस सवाल को समझने के लिए देखें क्यों) लेकिन यह शायद अब के लिए करेंगे।

इसके अलावा, इस पर ध्यान देने की आवश्यकता है:

Velocity *= Physics.Air.Resistance;

इसे ठीक करना थोड़ा मुश्किल है; एक संभावित तरीका है:

Velocity -= Vector2(Math.Pow(Physics.Air.Resistance.X, TimeStep),
                    Math.Pow(Physics.Air.Resistance.Y, TimeStep))
          * Velocity;

2. डबल अपडेट

अब चेक करें कि उछलते समय आप क्या करते हैं (केवल प्रासंगिक कोड दिखाया गया है):

Position += Velocity * TimeStep;
if (Position.Y < 0)
{
    Velocity.Y = -Velocity.Y * Physics.Surfaces.Grass;
    Position.Y = Position.Y + Velocity.Y * TimeStep;
}

आप देख सकते हैं कि TimeStepउछाल के दौरान दो बार उपयोग किया जाता है। यह मूल रूप से गेंद को खुद को अपडेट करने के लिए दो बार जितना समय दे रहा है। इसके बजाय ऐसा होना चाहिए:

Position += Velocity * TimeStep;
if (Position.Y < 0)
{
    /* First, stop at Y = 0 and count how much time is left */
    float RemainingTime = -Position.Y / Velocity.Y;
    Position.Y = 0;

    /* Then, start from Y = 0 and only use how much time was left */
    Velocity.Y = -Velocity.Y * Physics.Surfaces.Grass;
    Position.Y = Velocity.Y * RemainingTime;
}

3. गुरुत्वाकर्षण

अब कोड के इस भाग की जाँच करें:

if(Position.Y < GraphicsViewport.Height - Texture.Height)
{
    Velocity += Physics.Gravity.Force * TimeStep;
}            

आप फ्रेम की पूरी अवधि के लिए गुरुत्वाकर्षण जोड़ते हैं। लेकिन क्या होगा अगर गेंद वास्तव में उस फ्रेम के दौरान उछलती है? तब वेग उल्टा हो जाएगा, लेकिन जो गुरुत्वाकर्षण जोड़ा गया था, वह गेंद को जमीन से दूर गति देगा! तो अतिरिक्त गुरुत्वाकर्षण जब उछल हटाया जा करना होगा , तो सही दिशा में फिर से जोड़ दिया।

ऐसा हो सकता है कि सही दिशा में गुरुत्वाकर्षण को फिर से जोड़ने से वेग बहुत अधिक बढ़ जाएगा। इससे बचने के लिए, आप या तो गुरुत्वाकर्षण जोड़ को छोड़ सकते हैं (आखिरकार, यह इतना अधिक नहीं है और यह केवल एक फ्रेम तक रहता है) या शून्य के वेग को जकड़ें।

4. निश्चित कोड

और यहाँ पूरी तरह से अद्यतन कोड है:

public void Update()
{
    float TimeStep = 1.0;
    Update(TimeStep);
}

public void Update(float TimeStep)
{
    float RemainingTime;

    // Apply gravity if we're not already on the ground
    if(Position.Y < GraphicsViewport.Height - Texture.Height)
    {
        Velocity += Physics.Gravity.Force * TimeStep;
    }
    Velocity -= Vector2(Math.Pow(Physics.Air.Resistance.X, RemainingTime),
                        Math.Pow(Physics.Air.Resistance.Y, RemainingTime))
              * Velocity;
    Position += Velocity * TimeStep;

    if (Position.X < 0 || Position.X > GraphicsViewport.Width - Texture.Width)
    {
        // We've hit a vertical (side) boundary
        if (Position.X < 0)
        {
            RemainingTime = -Position.X / Velocity.X;
            Position.X = 0;
        }
        else
        {
            RemainingTime = (Position.X - (GraphicsViewport.Width - Texture.Width)) / Velocity.X;
            Position.X = GraphicsViewport.Width - Texture.Width;
        }

        // Apply friction
        Velocity -= Vector2(Math.Pow(Physics.Surfaces.Concrete.X, RemainingTime),
                            Math.Pow(Physics.Surfaces.Concrete.Y, RemainingTime))
                  * Velocity;

        // Invert velocity
        Velocity.X = -Velocity.X;
        Position.X = Position.X + Velocity.X * RemainingTime;
    }

    if (Position.Y < 0 || Position.Y > GraphicsViewport.Height - Texture.Height)
    {
        // We've hit a horizontal boundary
        if (Position.Y < 0)
        {
            RemainingTime = -Position.Y / Velocity.Y;
            Position.Y = 0;
        }
        else
        {
            RemainingTime = (Position.Y - (GraphicsViewport.Height - Texture.Height)) / Velocity.Y;
            Position.Y = GraphicsViewport.Height - Texture.Height;
        }

        // Remove excess gravity
        Velocity.Y -= RemainingTime * Physics.Gravity.Force;

        // Apply friction
        Velocity -= Vector2(Math.Pow(Physics.Surfaces.Grass.X, RemainingTime),
                            Math.Pow(Physics.Surfaces.Grass.Y, RemainingTime))
                  * Velocity;

        // Invert velocity
        Velocity.Y = -Velocity.Y;

        // Re-add excess gravity
        float OldVelocityY = Velocity.Y;
        Velocity.Y += RemainingTime * Physics.Gravity.Force;
        // If velocity changed sign again, clamp it to zero
        if (Velocity.Y * OldVelocityY <= 0)
            Velocity.Y = 0;

        Position.Y = Position.Y + Velocity.Y * RemainingTime;
    }
}

5. आगे के अतिरिक्त

यहां तक ​​कि बेहतर सिमुलेशन स्थिरता के लिए, आप अपने भौतिकी सिमुलेशन को उच्च आवृत्ति पर चलाने का निर्णय ले सकते हैं। इसमें ऊपर दिए गए बदलावों द्वारा इसे तुच्छ बनाया गया है TimeStep, क्योंकि आपको अपने फ्रेम को अपनी इच्छानुसार कई टुकड़ों में विभाजित करना होगा। उदाहरण के लिए:

public void Update()
{
    float TimeStep = 1.0;
    Update(TimeStep / 4);
    Update(TimeStep / 4);
    Update(TimeStep / 4);
    Update(TimeStep / 4);
}

"समय आपके कोड में कहीं दिखाई देगा।" आप विज्ञापन कर रहे हैं कि सभी जगह 1 से गुणा करना एक अच्छा विचार नहीं है, यह अनिवार्य है? निश्चित रूप से एक समायोज्य टाइमस्टेप एक अच्छी सुविधा है, लेकिन यह निश्चित रूप से अनिवार्य नहीं है।
आआआआआआआआआआ आआआआआ

@eBusiness: मेरा तर्क स्थिरता और समायोज्य टाइमस्टेप्स की तुलना में त्रुटियों का पता लगाने के बारे में बहुत अधिक है। मैं यह नहीं कह रहा हूं कि 1 से गुणा करना आवश्यक है, मैं कह रहा हूं कि velocity += gravityयह गलत है और केवल velocity += gravity * timestepसमझ में आता है। यह अंत में एक ही परिणाम दे सकता है, लेकिन एक टिप्पणी के बिना "मुझे पता है कि मैं यहां क्या कर रहा हूं" यह अभी भी एक कोडिंग त्रुटि, एक मैला प्रोग्रामर, भौतिकी के बारे में ज्ञान की कमी, या सिर्फ प्रोटोटाइप कोड का मतलब है सुधरने के लिये।
सैम होसेवर

आप कहते हैं कि यह गलत है , जब आपके कहने का मतलब यह है कि यह बुरा अभ्यास है। इस विषय पर आपकी व्यक्तिपरक राय है, और यह ठीक है कि आप इसे व्यक्त करते हैं, लेकिन यह व्यक्तिपरक है क्योंकि इस संबंध में कोड बिल्कुल वैसा ही है जैसा कि इसका मतलब है। मैं केवल यह पूछता हूं कि आप अपनी पोस्ट में व्यक्तिपरक और उद्देश्य के बीच अंतर स्पष्ट करें।
आआआआआआआआआआ आआआआ

2
@eBusiness: ईमानदारी से, यह है किसी भी समझदार मानक द्वारा गलत। कोड "ऐसा नहीं करता है जैसा कि" इसका मतलब है, क्योंकि 1) वेग और गुरुत्वाकर्षण को जोड़ने का वास्तव में कोई मतलब नहीं है; और 2) अगर यह एक उचित परिणाम देता है तो यह है क्योंकि इसमें संग्रहीत मूल्य gravityवास्तव में है ... गुरुत्वाकर्षण नहीं । लेकिन मैं उस पोस्ट में स्पष्ट कर सकता हूं।
सैम होसेवर

इसके विपरीत, इसे गलत कहना किसी भी मानक द्वारा गलत है। आप सही हैं कि गुरुत्वाकर्षण गुरुत्वाकर्षण नाम के चर में संग्रहीत नहीं है, इसके बजाय एक संख्या है, और वह सब कुछ है जो कभी भी होने वाला है, इसका भौतिकी से कोई संबंध नहीं है कि हम किस संबंध की कल्पना करते हैं, उससे गुणा करके एक अन्य संख्या में परिवर्तन नहीं होता है। यह जो प्रतीत होता है कि परिवर्तन होता है वह आपकी क्षमता और / या कोड और भौतिकी के बीच मानसिक संबंध बनाने की इच्छा है। वैसे एक दिलचस्प मनोवैज्ञानिक अवलोकन।
आआआआआआआआ आआआआआ

6

न्यूनतम ऊर्ध्वाधर वेग का उपयोग करते हुए, उछाल को रोकने के लिए एक चेक जोड़ें। और जब आपको न्यूनतम उछाल मिलता है, तो गेंद को जमीन में सेट करें।

MIN_BOUNCE = <0.01 e.g>;

if( Velocity.Y < MIN_BOUNCE ){
    Velocity.Y = 0;
    Position.Y = <ground position Y>;
}

3
मुझे यह समाधान पसंद है, लेकिन मैं वाई अक्ष पर उछाल को सीमित नहीं करूंगा। मैं टक्कर बिंदु पर कोलाइडर के सामान्य की गणना करता हूं और जांचता हूं कि टक्कर के वेग की तीव्रता उछाल सीमा से अधिक है या नहीं। यहां तक ​​कि अगर ओपी की दुनिया केवल वाई बाउंस की अनुमति देती है, तो अन्य उपयोगकर्ता अधिक सामान्य समाधान उपयोगी हो सकते हैं। (यदि मैं स्पष्ट नहीं हो रहा हूं, तो एक यादृच्छिक बिंदु पर दो क्षेत्रों को एक साथ उछालने के बारे में सोचें)
ब्रैंडन

@ब्रांडन, महान, इसे सामान्य के साथ बेहतर काम करना चाहिए।
जेन

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

इन समाधानों में से किसी को भी किसी भी वेग को सेट नहीं करना चाहिए। आप केवल बाउंस सीमा के आधार पर वेक्टर के सामान्य परावर्तन को सीमित करते हैं
ब्रैंडन

1

इसलिए, मुझे लगता है कि ऐसा होने की समस्या यह है कि आपकी गेंद एक सीमा तक पहुंच रही है। गणितीय रूप से, गेंद सतह पर कभी नहीं रुकती है, यह सतह पर पहुंचती है।

हालाँकि, आपका गेम निरंतर समय का उपयोग नहीं कर रहा है। यह एक नक्शा है, जो विभेदक समीकरण के लिए एक सन्निकटन का उपयोग कर रहा है। और वह सन्निकटन इस सीमित स्थिति में मान्य नहीं है (आप कर सकते हैं, लेकिन आपको स्मेलर और छोटे समय के कदम उठाने होंगे, जो मुझे लगता है कि संभव नहीं है।

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

@ जब आपका सिस्टम सजातीय हो, तो ठीक नहीं होगा। यह y अक्ष पर कुछ गुरुत्वाकर्षण है।

इसलिए, मैं यह कहूंगा कि समाधान यह नहीं होगा कि वेग किसी दिए गए सीमा से अधिक होना चाहिए, लेकिन अद्यतन के बाद गेंद पर लगाया गया कुल बल किसी दिए गए सीमा पर होना चाहिए।

यह बल गेंद + गुरुत्वाकर्षण पर दीवार द्वारा लगाए गए बल का योगदान है।

हालत तो कुछ इस तरह होनी चाहिए

अगर (newVelocity + Physics.Gravity.Force <थ्रेशोल्ड)

ध्यान दें कि newVelocity.y एक सकारात्मक मात्रा है यदि बाउंस बोतल की दीवार पर है, और गुरुत्वाकर्षण एक नकारात्मक मात्रा है।

यह भी ध्यान दें कि newVelocity और Physics.Gravity.orce में समान आयाम नहीं हैं, जैसा कि आपने लिखा है

Velocity += Physics.Gravity.Force;

इसका मतलब है कि, आप की तरह, मैं यह मान रहा हूं कि delta_time = 1 और ballMass = 1।

उम्मीद है की यह मदद करेगा


1

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

अब आप एक अलग मुद्दा देख सकते हैं, कि गेंद निर्दिष्ट क्षेत्र के बाहर "अटक" जाती है, लगातार आगे और पीछे उछलती है।

इस मुद्दे को हल करने का एक सरल तरीका यह जांचना है कि गेंद इसे बदलने से पहले सही दिशा में चलती है।

इस प्रकार आपको बनाना चाहिए:

if (Position.X < 0 || Position.X > GraphicsViewport.Width - Texture.Width)

में:

if ((Position.X < 0 && Velocity.X < 0) || (Position.X > GraphicsViewport.Width - Texture.Width && Velocity.X > 0))

और वाई दिशा के लिए समान है।

गेंद को अच्छी तरह से रोकने के लिए आपको किसी बिंदु पर गुरुत्वाकर्षण को रोकने की आवश्यकता होती है। आपका वर्तमान कार्यान्वयन यह सुनिश्चित करता है कि गेंद हमेशा पुनरुत्थान करेगी क्योंकि गुरुत्वाकर्षण इसे तब तक ब्रेक नहीं करता है जब तक यह भूमिगत है। आपको हमेशा गुरुत्वाकर्षण को लागू करने के लिए बदलना चाहिए। यह हालांकि गेंद को धीरे-धीरे जमीन में बसने के बाद डूब जाता है। इसके लिए एक त्वरित सुधार गुरुत्वाकर्षण लागू करने के बाद है, अगर गेंद सतह के स्तर से नीचे है और नीचे की ओर बढ़ रही है, तो इसे रोकें:

Velocity += Physics.Gravity.Force;
if(Position.Y > GraphicsViewport.Height - Texture.Height && Velocity.Y > 0)
{
    Velocity.Y = 0;
}

कुल मिलाकर ये बदलाव आपको एक अच्छा सिमुलेशन देना चाहिए। लेकिन ध्यान दें कि यह अभी भी एक बहुत ही सरल अनुकरण है।


0

किसी भी और सभी वेग परिवर्तनों के लिए एक उत्परिवर्ती विधि है, तो उस पद्धति के भीतर आप निर्धारित वेग की जांच कर सकते हैं कि यह धीमा चल रहा है या नहीं इसे आराम से रखें। अधिकांश भौतिकी प्रणालियां जिन्हें मैं इस 'पुनर्स्थापन' के नाम से जानता हूं।

public Vector3 Velocity
{
    public get { return velocity; }
    public set
    {
        velocity = value;

        // We get the direction that gravity pulls in
        Vector3 GravityDirection = gravity;
        GravityDirection.Normalize();

        Vector3 VelocityDirection = velocity;
        VelocityDirection.Normalize();

        if ((velocity * GravityDirection).SquaredLength() < 0.25f)
        {
            velocity.Y = 0.0f;
        }            
    }
}
private Vector3 velocity;

उपरोक्त विधि में हम जब भी गुरुत्वाकर्षण के समान धुरी के साथ उछलते हैं, तो इसे सीमित करते हैं।

जब कोई गेंद जमीन से टकराती है, तब कुछ और पता लगाया जाएगा, और अगर यह टकराव के समय काफी धीमी गति से आगे बढ़ रही है, तो गुरुत्वाकर्षण के अक्ष के साथ वेग को शून्य पर सेट करें।


मैं इसे कम नहीं करूंगा क्योंकि यह मान्य है, लेकिन सवाल बाउंस थ्रेसहोल्ड के बारे में पूछ रहा है, वेग थ्रेसहोल्ड नहीं। ये मेरे अनुभव में लगभग हमेशा अलग हैं क्योंकि उछलते समय घबराहट का प्रभाव आम तौर पर वेग की गणना करने के लिए जारी रहने के प्रभाव से अलग होता है, क्योंकि यह नेत्रहीन है।
ब्रैंडन

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

@ न्यूफोस्टर: मैं उलझन में हूं, क्योंकि मेरे दिमाग में एक वस्तु बहुत तेजी से क्षैतिज रूप से घूम सकती है और शायद ही सभी लंबवत रूप से उस स्थिति में हो सकती है जब आपकी विधि ट्रिगर नहीं होगी। मुझे लगता है कि ओपी वेग की लंबाई अधिक होने के बावजूद ऊर्ध्वाधर दूरी को शून्य पर सेट करना चाहेगा।
जॉर्ज डकेट

@GeorgeDuckett: आह धन्यवाद, मैंने मूल प्रश्न गलत समझा। ओपी नहीं चाहता कि गेंद हिलना बंद करे, बस लंबवत गति को रोकें। मैंने केवल उछलते वेग के लिए जवाब देने के लिए अद्यतन किया है।
निक फोस्टर

0

एक और बात: आप एक घर्षण स्थिरांक से गुणा कर रहे हैं। बदलें कि - घर्षण स्थिर कम लेकिन एक उछाल पर एक निश्चित ऊर्जा अवशोषण जोड़ें। यह उन आखिरी बाउंस को बहुत तेजी से कम करेगा।

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