mcq - what is algorithm in hindi




आप प्रदर्शन से गेम तर्क कैसे अलग करते हैं? (6)

आप अपना गेम लूप देख सकते हैं:

int lastTime = GetCurrentTime();
while(1) {
    // how long is it since we last updated?
    int currentTime = GetCurrentTime();
    int dt = currentTime - lastTime;
    lastTime = currentTime;

    // now do the game logic
    Update(dt);

    // and you can render
    Draw();
}

फिर आपको समय के अंतर को ध्यान में रखने के लिए अपना Update() फ़ंक्शन लिखना होगा; उदाहरण के लिए, यदि आपके पास कुछ गति v चलने वाला कोई ऑब्जेक्ट मिलता है, तो प्रत्येक फ्रेम v * dt द्वारा अपनी स्थिति को अपडेट करें

आप खेल तर्क से प्रति सेकंड प्रदर्शित फ्रेम स्वतंत्र कैसे बना सकते हैं? ऐसा इसलिए है कि गेम लॉजिक उसी गति को चलाता है, चाहे कितनी तेज़ी से वीडियो कार्ड रेंडर कर सके।


कोएन विटर्स के पास विभिन्न गेम लूप सेटअप के बारे में बहुत विस्तृत लेख है

वह कवर करता है:

  • लगातार गेम गति पर निर्भर एफपीएस
  • व्हेरेबल एफपीएस पर गेम स्पीड निर्भर
  • अधिकतम एफपीएस के साथ लगातार गेम स्पीड
  • लगातार गेम गतिशील एफपीएस से स्वतंत्र

(यह वांछनीयता के क्रम में लेख से निकाले गए शीर्षलेख हैं।)


दिन में इस पीठ पर फ्लिपकोड पर एक उत्कृष्ट लेख था। मैं इसे खुदाई करना चाहता हूं और इसे आपके लिए पेश करना चाहता हूं।

http://www.flipcode.com/archives/Main_Loop_with_Fixed_Time_Steps.shtml

गेम चलाने के लिए यह अच्छी तरह से सोचा गया है:

  1. एकल थ्रेडेड
  2. एक निश्चित गेम घड़ी पर
  3. इंटरपोलेटेड घड़ी का उपयोग करते हुए जितनी जल्दी हो सके ग्राफिक्स के साथ

खैर, कम से कम यही मुझे लगता है कि यह है। :-) इस पोस्टिंग के बाद अपनाई जाने वाली चर्चा को खोजने के लिए कठिन है शायद रास्ताबैक मशीन वहां मदद कर सकता है

time0 = getTickCount();
do
{
  time1 = getTickCount();
  frameTime = 0;
  int numLoops = 0;

  while ((time1 - time0)  TICK_TIME && numLoops < MAX_LOOPS)
  {
    GameTickRun();
    time0 += TICK_TIME;
    frameTime += TICK_TIME;
    numLoops++;
// Could this be a good idea? We're not doing it, anyway.
//    time1 = getTickCount();
  }
  IndependentTickRun(frameTime);

  // If playing solo and game logic takes way too long, discard pending
time.
  if (!bNetworkGame && (time1 - time0)  TICK_TIME)
    time0 = time1 - TICK_TIME;

  if (canRender)
  {
    // Account for numLoops overflow causing percent  1.
    float percentWithinTick = Min(1.f, float(time1 - time0)/TICK_TIME);
    GameDrawWithInterpolation(percentWithinTick);
  }
}
while (!bGameDone);

मुझे लगता है कि सवाल से पता चलता है कि गेम इंजन कैसे डिजाइन किया जाना चाहिए। जो बिल्कुल ठीक है, क्योंकि वे जटिल चीजें हैं जो सही पाने के लिए मुश्किल हैं;)

आप सही धारणा के तहत हैं कि आप चाहते हैं कि जिसे फ़्रेम दर स्वतंत्रता कहा जाता है लेकिन यह न केवल रेन्डरिंग फ्रेम्स को संदर्भित करता है

एकल थ्रेडेड गेम इंजन में एक फ़्रेम को आमतौर पर टिक के रूप में जाना जाता है प्रत्येक टिक आप इनपुट प्रक्रिया, खेल तर्क प्रक्रिया, और प्रसंस्करण के परिणामों के आधार पर एक फ़्रेम प्रदान करते हैं।

आप क्या करना चाहते हैं, आपके गेम लॉजिक को किसी भी एफपीएस (फ़्रेम्स प्रति सेकंड) पर संसाधित करने में सक्षम होंगे और एक नियतात्मक परिणाम होगा।

यह निम्न मामले में एक समस्या बन जाता है:

इनपुट की जांच करें: - इनपुट कुंजी है: 'डब्ल्यू' जिसका अर्थ है कि हम खिलाड़ी के चरित्र को आगे 10 इकाइयों में ले जाते हैं:

खिलाड़ी पद + = 10;

अब जब आप यह हर फ्रेम कर रहे हैं, अगर आप 30 एफपीएस पर चल रहे हैं तो आप प्रति सेकंड 300 यूनिट्स को स्थानांतरित करेंगे।

लेकिन अगर आप इसके बदले 10 एफपीएस पर चल रहे हैं, तो आप केवल प्रति सेकंड 100 यूनिट्स को स्थानांतरित करेंगे। और इस तरह आपका गेम तर्क फ़्रेम दर स्वतंत्र नहीं है

खुशी की बात है, इस समस्या को हल करने के लिए और अपने खेल खेलने के तर्क फ्रेम दर स्वतंत्र बनाने के लिए एक नहीं बल्कि आसान काम है।

सबसे पहले, आपको एक टाइमर की आवश्यकता होती है जो प्रत्येक फ्रेम को रेंडर करने के लिए समय की गणना करेगा। सेकेंड के मामले में यह संख्या (इतनी 0.001 सेकेंड टिकी भरने के लिए) तब गुणा होती है जब तक आप यह फ़्रेम दर स्वतंत्र होना चाहते हैं। तो इस मामले में:

'डब्ल्यू'

खिलाड़ी पद + = 10 * फ्रेमटाइम डेलटा;

(डेल्टा "परिवर्तन में कुछ" के लिए एक फैंसी शब्द है)

तो आपका खिलाड़ी एक अंश में 10 के कुछ अंश को आगे बढ़ाएगा, और टिक्क्स के पूर्ण दूसरे के बाद, आप पूर्ण 10 इकाइयों को स्थानांतरित कर देंगे।

हालांकि, जब संपत्ति की बात आती है, तो समय गिरने पर यह गिरावट आती है, उदाहरण के लिए, एक तेज वाहन यह एक अधिक उन्नत संपूर्नकर्ता का उपयोग करके हल किया जा सकता है, जैसे "वर्लेट"

मल्टीथ्रेटेड दृष्टिकोण

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

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

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

फिक्स्ड टाइम चरण दृष्टिकोण

अन्त में, एक और टिप्पणीकार के रूप में, एक निश्चित आकार के समय के चरण के साथ, और यह नियंत्रित करने के लिए कि आप गेम लॉजिक कितनी बार "कदम" कई लाभों के साथ इसे संभालने का एक बहुत प्रभावी उपाय भी हो सकते हैं

यहां पूर्णता के लिए लिंक किया गया है, लेकिन अन्य टिप्पणीकार इसके साथ भी लिंक करते हैं: फिक्स आपका टाइम चरण


यह उच्च कार्यक्रम अमूर्त सामान, अर्थात राज्य मशीनों आदि को कवर करता है।

आपके फ़्रेम समय व्यतीत होने वाले लोगों को समायोजित करके आंदोलन और त्वरण को नियंत्रित करने के लिए ठीक है लेकिन यह कैसे के बारे में एक ध्वनि 2.55 सेकंड ट्रिगर की तरह इस के बारे में या वह, या खेल के स्तर को बदलने 18.25 सेकंड बाद में, आदि

यह एक बीते समय के समय संचयकर्ता (काउंटर) तक बंधे जा सकते हैं, लेकिन यदि आपका फ्रेम दर आपके राज्य स्क्रिप्ट संकल्प के नीचे आ जाती है तो यह समय खराब हो सकता है अगर आपके उच्च तर्क को 0.05 सेकंड ग्रैन्युलैरिटी की आवश्यकता होती है और आप 20 एफपीएस से नीचे गिरते हैं।

यदि तर्क तर्क एक अलग "थ्रेड" (सॉफ़्टवेयर स्तर पर, जिसे मैं इसके लिए पसंद करता है, या ओएस स्तर) पर तय समय-टुकड़ा, एफपीएस से स्वतंत्र के साथ तय किया जा सकता है।

जुर्माना यह हो सकता है कि सीपीयू के समय बीच में तबाह नहीं हो सकता है, अगर ऐसा नहीं हो रहा है, लेकिन मुझे लगता है कि यह संभवतः इसके लायक है।


इंजिनियिटी में थोड़ा अलग है, लेकिन दिलचस्प दृष्टिकोण: टास्क पूल।





algorithm