सी ++ में सरल टिक-आधारित इंजन को कैसे कार्यान्वित करें?

Question

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

इसके लिए संभावित वाक्यविन्यास क्या होगा?

double lastTickTime; 
double currentTime; 

void eventsPile(int event, int target) 
{ 
// how do i implement stack of events? And send them to execute() when time is up? 
} 

void execute(int event, int target) 
{ 
    if ((currentTime - lastTickTime) == 2) 
    { 
     eventsHandler(event, target); 
    }  
    else 
    { // How do I put events on stack? 
    } 
} 

Answer 1

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

Answer 2

, एक टाइमर को क्रियान्वित हर एक्स एमएस (जबकि एक्स अपने ticktime है) का उपयोग करें कि विधि में ढेर पर डाल किसी भी कार्रवाई को अंजाम।

Answer 3

जो मैंने देखा है, उससे अधिकतर इंजन समय के बजाए ईवेंट हैं। पिछले tick के अंत के बाद एक नया tick कुछ अंतराल ट्रिगर किया जा रहा है। (इस प्रकार ज्यादातर tick एस अंतराल से अधिक समय लेते हुए)

यह कार्यान्वयन को भी सरल बनाता है; आपके पास बस एक गेम लूप है जो tick ईवेंट ट्रिगर करता है, फिर sleep एस/yield एस आवश्यक अंतराल के लिए ट्रिगर करता है। जो तुच्छ है।

इसे दुनिया को एक पेड़ के रूप में मॉडलिंग करके सरल बनाया जा सकता है, जहां प्रत्येक तत्व अपने बच्चों को प्रचारित घटनाओं (जैसे) का प्रबंधन करता है। जब तक आप 'लूप' से बचें/प्रबंधित करें, यह अच्छी तरह से काम करता है (मैंने इसे किया है)।

यह प्रभावी रूप से इस (psudocode) की तरह कुछ करने के लिए tick प्रणाली कम कर देता है:

while (isRunning) { 
    world->tick(); 
    sleep(interval); 
} 

ज्यादातर मामलों में, थोड़ा पिछले अवधि की लंबाई को समायोजित करने की तुलना में बहुत अधिक सजावटी पाने के लिए की जरूरत theres।

कोई भी व्यक्तिगत संस्थाएं क्रियाएं स्वयं की कार्य कतार का हिस्सा होंगी, और अपने स्वयं के "टिक" कार्यक्रमों के दौरान संभाली जाएंगी।

आमतौर पर उपयोगकर्ता कमांड को "ingame" और "मेटा" कमांड में विभाजित किया जाएगा, किसी भी अन्य चीज को किसी अन्य इकाई के लिए सामान्य के अनुसार, उनके अगले टिक में संसाधित होने के लिए, उनके चरित्र की क्रिया कतार में केवल संशोधन किया जाएगा।

सरल दौर-आधारित मुकाबला इस नींव से स्वाभाविक रूप से पालन करता है। रीयलटाइम को वैकल्पिक 'टाइम-पूलिंग' के साथ tick एस के बेहतर डिवीजन के साथ मॉडलिंग किया जा सकता है।