वहाँ एक पूल गेम के लिए एक एल्गोरिथ्म है?

Question

मैं एक पूल गेम में गेंदों की दिशा और गति की गणना करने के लिए एल्गोरिथ्म की तलाश कर रहा हूं। मुझे यकीन है कि इसके लिए कुछ प्रकार के ओपन सोर्स कोड होने चाहिए क्योंकि पूल गेम कुछ सबसे पुराने कंप्यूटर गेम हैं जिन्हें मैं याद रख सकता हूं।

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

मैं जावा कोडिंग का अभ्यास करना चाहता हूं, इसलिए मैं जावा कोड या पैकेज की तलाश कर रहा हूं जिसमें इस प्रकार का कोड हो।

Comments

यदि आप इसे स्वयं हल करना चाहते हैं, हालांकि, आपको संभवतः वैक्टर के कुछ ज्ञान की आवश्यकता है। सौभाग्य से, किसी ने इस दिन सिर्फ दूसरे दिन रैखिक गणित पर एक महान walkthrough पोस्ट किया ।

— doppelgreener

शायद इस साइट मदद कर सकते हैं archive.ncsa.illinois.edu/Classes/MATH198/townsend/...

Answer 1

जबकि बुनियादी क्षेत्र-क्षेत्र टक्कर का पता लगाने / प्रतिक्रिया काफी सरल है, यह एक अच्छा पूल सिमुलेशन के लिए सटीक रूप से पर्याप्त करना अधिक मुश्किल होगा, क्योंकि आपको स्पिन से निपटना होगा।

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

2 डी में

Box2D: http://www.box2d.org

चिपमंक: http://code.google.com/p/chipmunk-physics/

3 डी में

बुलेट: http://bulletphysics.org/

ODE: http://www.ode.org

यदि आप एक बड़े बजट का व्यावसायिक खेल बना रहे थे:

हॉक: http://www.havok.com

Comments

हालांकि इनमें से कौन से जावा भौतिकी इंजन हैं?

— Ricket

जावा के बंदरगाह हैं, या Box2D, Chipmunk, Bullet, और ODE के लिए कम से कम बाइंडिंग हैं

— bluescrn

Answer 2

यदि आप "रोल अपना खुद का" मार्ग चुनने के लिए चुनते हैं, तो आप " पूल हॉल सबक: तेज, सटीक टकराव का पता लगाने सर्किलों या क्षेत्रों के बीच " लेख में दिलचस्पी ले सकते हैं । यह जावा-विशिष्ट नहीं है, लेकिन सरल सिमुलेशन के लिए शामिल कुछ एल्गोरिदम पर चर्चा करता है।

Answer 3

एक सरल पूल गेम के लिए जहां स्पिन को मॉडल नहीं किया जाता है एल्गोरिथ्म काफी सरल है।

1. यदि कोई टक्कर होती है, तो यह जांचने के लिए कि क्या गेंदों के बीच की दूरी उनकी त्रिज्या के योग से छोटी है।
2. प्रभाव की सामान्य गणना करें
3. प्रभाव अंतर, सामान्य, प्रभाव गुणांक और द्रव्यमान के आधार पर प्रभाव बल की गणना करें
4. दोनों गेंदों पर प्रभाव बल लागू करें

छद्म कोड में यह बन जाता है:

vector difference = ball2.position - ball1.position
float distance = sqrt(difference)
if (distance < ball1.radius + ball2.radius) {
    vector normal = difference / distance
    //vector velocityDelta = ball2.velocity - ball1.velocity
    vector velocityDelta = ball1.velocity - ball2.velocity

    float dot = dotProduct(velocityDelta, normal)

    if (dot > 0) {
        float coefficient = 0.5
        float impulseStrength = (1 + coefficient) * dot * (1 / ball1.mass + 1 / ball2.mass)
        vector impulse = impulseStrength * normal
        ball1.velocity -= impulse / ball1.mass
        ball2.velocity += impulse / ball2.mass
    }
}

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

कोड इस ट्यूटोरियल पर आधारित है , लेकिन मुझे याद है कि आवेग गुणन वहां गलत था।

Comments

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

@ पोल्डी अगर डॉट नेगेटिव है, तो बॉल पहले से ही एक-दूसरे से दूर जा रही हैं। उस मामले में टकराव को संभालने की आवश्यकता नहीं है।

— मिसेल जूल

मैंने आपके कोड के मेरे संस्करण को यहाँ खटखटाया है: ideone.com/DhsAoW और मुझे 110,90 और 100,100 के पदों के लिए -0.707 मिल रहा है, और 0,2 और 0, -3 के वेग हैं। यह कमोबेश सिर पर होने वाली टक्कर है। (मान लें कि प्रारंभिक त्रिज्या-आधारित टक्कर का पता लगाने की जाँच पहले ही हो चुकी है)।