3 डी गेम में लक्ष्य पर शूट करने के लिए एल्गोरिदम

Question

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

मैंने /programming/4107403/ai-algorithm-to-shoot-at-a-target-in-a-2d-game?lq=1 से उत्तर का उपयोग करने की कोशिश की, लेकिन यह 2 डी के लिए है इसलिए मैंने कोशिश की इसे स्वीकार करना।

मैंने पहले XZZ विमान के लिए चौराहे के बिंदु को हल करने के लिए गणना को विघटित किया और x और z निर्देशांक को बचाया और फिर XoY विमान के लिए प्रतिच्छेदन बिंदु को हल करने और y को अंतिम xyz में जोड़ते हुए कहा कि मैंने तब क्लिपस्पेस में बदल दिया और उन पर एक बनावट डाल दी। निर्देशांक। लेकिन निश्चित रूप से यह काम नहीं करता है क्योंकि यह होना चाहिए या मैं सवाल पोस्ट नहीं होता।

XoZ प्लेन में X ढूंढने के बाद और XoY में x को मैंने जो देखा है, वही नहीं है, इसलिए कुछ गलत होना चाहिए।

    float a = ENG_Math.sqr(targetVelocity.x) + ENG_Math.sqr(targetVelocity.y) -
            ENG_Math.sqr(projectileSpeed);
    float b = 2.0f * (targetVelocity.x * targetPos.x + 
            targetVelocity.y * targetPos.y);
    float c = ENG_Math.sqr(targetPos.x) + ENG_Math.sqr(targetPos.y);
    ENG_Math.solveQuadraticEquation(a, b, c, collisionTime);

पहली बार targetVelocity.y वास्तव में targetVelocity.z (targetPos के लिए समान) है और दूसरी बार यह वास्तव में targetVelocity.y है।

XoZ के बाद अंतिम स्थिति है

    crossPosition.set(minTime * finalEntityVelocity.x + finalTargetPos4D.x, 0.0f, 
                minTime * finalEntityVelocity.z + finalTargetPos4D.z);

और XoY के बाद

    crossPosition.y = minTime * finalEntityVelocity.y + finalTargetPos4D.y;

क्या मेरा दृष्टिकोण 2 विमानों को अलग करने और किसी भी अच्छे की गणना करने का है? या 3 डी के लिए एक अलग दृष्टिकोण है?

• sqr () वर्ग है sqrt नहीं - एक भ्रम से बचने।

Comments

"लक्ष्य का नेतृत्व" वह वाक्यांश हो सकता है जिसे आप ढूंढ रहे हैं।

— MichaelHouse

Answer 1

इसे 2 2 डी कार्यों में तोड़ने की कोई आवश्यकता नहीं है। यह द्विघात समीकरण आप 3 डी में भी ठीक काम करता है। यहाँ 2d या 3D के लिए छद्म कोड है। इसका मतलब है कि एक टॉवर (टॉवर रक्षा) प्रक्षेप्य की शूटिंग कर रहा है:

Vector totarget =  target.position - tower.position;

float a = Vector.Dot(target.velocity, target.velocity) - (bullet.velocity * bullet.velocity);
float b = 2 * Vector.Dot(target.velocity, totarget);
float c = Vector.Dot(totarget, totarget);

float p = -b / (2 * a);
float q = (float)Math.Sqrt((b * b) - 4 * a * c) / (2 * a);

float t1 = p - q;
float t2 = p + q;
float t;

if (t1 > t2 && t2 > 0)
{
    t = t2;
}
else
{
    t = t1;
}

Vector aimSpot = target.position + target.velocity * t;
Vector bulletPath = aimSpot - tower.position;
float timeToImpact = bulletPath.Length() / bullet.speed;//speed must be in units per second 

'लक्ष्यस्पॉट' वह वेक्टर हो सकता है जिसके बारे में आप पूछ रहे हैं।

Comments

तुम जीनियस हो और मेरी गांड बचा ली !! धिक्कार है, मुझे ऊपर

— उठने के

@SebastianBugiu मैंने आपके लिए किया।

— AgentFire

@SebastianBugiu धन्यवाद, मुझे खुशी हुई जब मैंने इस अवधारणा को सीखा और मुझे खुशी है कि आपने इसकी मदद की। इसकी एक और खासियत यह है कि आपको टक्कर का पता लगाने वाले एल्गोरिदम के साथ गड़बड़ करने की जरूरत नहीं है। कोई सीडी कोड नहीं लिखा जाना चाहिए। चूंकि लक्ष्य और प्रक्षेप्य पथ अनुमानित हैं, इसलिए प्रभाव timeToImpactशून्य होने पर गिना जाएगा।

— स्टीव एच

Answer 2

उसी विषय के बारे में एक अच्छा ब्लॉग पोस्ट भी है: http://playtechs.blogspot.kr/2007/04/aiming-at-moving-target.html । इसमें अधिक जटिल नमूने भी शामिल हैं जिनमें गुरुत्वाकर्षण शामिल है।

लेखक ने अधिक सरलीकरण किया है, जिसके परिणामस्वरूप अधिक कॉम्पैक्ट कोड है:

double time_of_impact(double px, double py, double vx, double vy, double s)
{
    double a = s * s - (vx * vx + vy * vy);
    double b = px * vx + py * vy;
    double c = px * px + py * py;

    double d = b*b + a*c;

    double t = 0;
    if (d >= 0)
    {
        t = (b - sqrt(d)) / a;
        if (t < 0) 
        {
            t = (b + sqrt(d)) / a;
            if (t < 0)
                t = 0;
        }
    }

    return t;
}

अद्यतन: मूल लेखक ने केवल बड़ी जड़ को ध्यान में रखा। लेकिन छोटी जड़ के गैर-नकारात्मक होने की स्थिति में, इसका परिणाम बेहतर होता है, क्योंकि प्रभाव का समय छोटा होता है। मैंने इसी कोड को अपडेट किया है।