दो बिंदुओं के बीच एक रेखा पर अंक प्राप्त करें

9

मैं जावास्क्रिप्ट में एक साधारण स्थान का खेल बना रहा हूं, लेकिन अब मैंने वैक्टर के संबंध में एक दीवार को मारा है।

खेल का दृश्य 2d ग्रिड पर टॉप-डाउन है। जब उपयोगकर्ता ग्रिड पर क्लिक करता है, तो अंतरिक्ष जहाज उस स्थान पर उड़ान भरेगा।

इसलिए, अगर मेरे पास दो बिंदु हैं:

{ x : 100.2, y : 100.6 }; // the ship
{ x : 20.5,  y : 55.95 }; // the clicked coordinates

यदि गेम लूप प्रति सेकंड 60 पुनरावृत्तियों पर टिक जाता है, और वांछित जहाज वेग 0.05 अंक प्रति टिक (3 अंक प्रति सेकंड) है, तो मैं गेम लूप के प्रत्येक टिक के लिए जहाज के लिए निर्देशांक के नए सेट की गणना कैसे करूं?

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

javascript vector coordinates

— स्टीफन
स्रोत

8

स्यूडोकोड में:

speed_per_tick = 0.05
delta_x = x_goal - x_current
delta_y = y_goal - y_current
goal_dist = sqrt( (delta_x * delta_x) + (delta_y * delta_y) )
if (dist > speed_per_tick)
{
    ratio = speed_per_tick / goal_dist
    x_move = ratio * delta_x  
    y_move = ratio * delta_y
    new_x_pos = x_move + x_current  
    new_y_pos = y_move + y_current
}
else
{
    new_x_pos = x_goal 
    new_y_pos = y_goal
}

— ट्रिस्टन
स्रोत

@ ट्रिस्टन: क्या आप goal_distअपनी ifस्थिति से मतलब रखते हैं?

— नैट डब्ल्यू।

21

एलईआरपी - रैखिक इंटरपोलेशन

मैंने कुछ दिन पहले इसी तरह की समस्या के लिए यह जवाब दिया था, लेकिन यहाँ हम जाते हैं:

रैखिक प्रक्षेप एक ऐसा कार्य है जो आपको प्रगति के आधार पर दो संख्याओं के बीच एक संख्या प्रदान करता है। आप वास्तव में दो बिंदुओं के बीच एक बिंदु प्राप्त कर सकते हैं।

महान सूत्र - इसकी गणना कैसे करें

सामान्य LERP फॉर्मूला द्वारा दिया जाता है pu = p0 + (p1 - p0) * u। कहाँ पे:

पु: परिणाम संख्या
p0: प्रारंभिक संख्या
p1: अंतिम संख्या
u: प्रगति। यह 0 और 1 के बीच प्रतिशत में दिया जाता है।

प्रतिशत कैसे प्राप्त करें

आप सोच रहे होंगे, "मुझे यह प्रतिशत कैसे मिल सकता है !?"। चिंता मत करो। यह इस तरह है: शुरू करने के लिए वेक्टर को खत्म करने के लिए यात्रा करने में कितना समय लगेगा? ठीक है, इसे उस समय तक विभाजित करें जो पहले ही बीत चुका है। यह आपको प्रतिशत देगा।

देखिए, कुछ इस तरह: percentage = currentTime / finalTime;

वैक्टरों की गणना

परिणामी वेक्टर प्राप्त करने के लिए, आपको बस दो बार फार्मूला लागू करना होगा, एक एक्स घटक के लिए और एक वाई घटक के लिए। कुछ इस तरह:

point.x = start.x + (final.x - start.x) * progress;
point.y = start.y + (final.y - start.y) * progress;

परिवर्तनशील समय की गणना

आप 0.5 अंक की गति से यात्रा करने के लिए अपने अंक चाहते हैं, हाँ? तो चलिए बताते हैं, एक लंबी दूरी की यात्रा कितनी लंबी होगी।

आप इसे निम्नानुसार कर सकते हैं:

दूरी की लंबाई प्राप्त करें इसके लिए, आपको दो चीजों की आवश्यकता होगी। दूरी वेक्टर प्राप्त करें, फिर इसे लंबाई मान में बदलें।

distancevec = final - start;
distance = distancevec.length();

मुझे आशा है कि आप वैक्टर गणित जानते हैं। यदि आप नहीं करते हैं, तो आप इस फॉर्मूले के द्वारा वेक्टर की गणना कर सकते हैं d = sqrt(pow(v.x, 2) + pow(v.y, 2));।

अंतिम समय में इसे प्राप्त करें और अपडेट करें। यह एक आसान है। जैसा कि आप चाहते हैं कि प्रत्येक टिक आपको एक 0.5 लंबाई मिले, हमें बस विभाजित करना है और हमें कितने टिक मिले हैं।

finalTime = distance / 0.5f;

किया हुआ।

सूचना: हो सकता है, यह आपके लिए अपेक्षित गति न हो, लेकिन यह सही है। तो आपके पास एक रैखिक आंदोलन है, यहां तक कि विकर्ण चाल पर भी। यदि आप x + = 0.5f, y + = 0.5f करना चाहते हैं, तो एक वेक्टर गणित पुस्तक पढ़ें और अपनी योजनाओं की फिर से जाँच करें।

— गुस्तावो मैकिएल
स्रोत

क्या होगा यदि आप अपनी स्थिति से गंतव्य के लिए बचे हुए% को चाहते हैं? यदि आप डेल्टा समय का उपयोग नहीं कर सकते, बल्कि x: y सह निर्देशांक।

— डेव

यदि आप progressइस उत्तर में बताए अनुसार गणना करते हैं, तो यह 0..1सीमा में होना चाहिए । बस करो:progressLeft = 1.0 - progress;

— गुस्तावो मैकिएल

3

यह दिशा की सामान्य गणना करके और फिर पैरामीट्रिक समीकरण के माध्यम से वर्तमान स्थिति की गणना करके किया जा सकता है

newPoint = startPoint + directionVector * velocity * t

जहां जहाज वांछित दिशा में यात्रा शुरू करने के बाद से t समय समाप्त हो गया है। आप इस अपडेट को प्रति अपडेट भी कर सकते हैं

newPoint = currentPoint + directionVector * velocity * timeDelta

और आप बस हर फ्रेम / भौतिकी / आदि पर यह गणना करते हैं। जहाज के अपने गंतव्य तक पहुंचने तक अद्यतन।

— hatboyzero
स्रोत