टर्न-आधारित गेम डिज़ाइन: इवेंट-संचालित बनाम गेम लूप

Question

मैं जावा में अपना पहला गेम बना रहा हूं। खेल एकाधिकार है। मैं इस बात से जूझ रहा हूं कि मुझे अपनी बारी-आधारित संरचना (प्रबंधन खिलाड़ी को बदलकर) मॉडल करने के लिए गेम को कैसे डिजाइन करना चाहिए। मैं गेम खेलने के लिए एक एकल मानव नियंत्रित और एक या एकाधिक एआई-नियंत्रित खिलाड़ियों दोनों के लिए अनुमति देना चाहता हूं।

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

मेरे समझ है कि लागू करने के लिए मैं क्या जरूरत है की कोशिश कर के लिए मेरे विकल्प या तो करने के लिए कर रहे हैं:

1. एक पूरी तरह से घटना पर ही आधारित कार्यक्रम है जो इस तरह नहीं खेल लूप है को लागू करें, या
2. एक खेल loop- लागू ऐसा कुछ जो पृष्ठभूमि में लंबे समय से चल रहा है और जब तक खेल चल रहा है तब तक मूल रूप से कभी खत्म नहीं होता है। यह अधिक प्रक्रियात्मक दृष्टिकोण होगा।

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

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

यहाँ मेरी विशिष्ट प्रश्न हैं:

1. खेल छोरों (के रूप में मैं उन्हें का वर्णन कर रहा हूँ) जैसे बारी आधारित खेल के लिए उपयुक्त हैं एकाधिकार-विशेष रूप से खिलाड़ी कतार बदल जाता है और अपनी बारी के लिए उपयुक्त खिलाड़ी उत्साह के लिए , एक समय में एक खिलाड़ी (और एक बारी के चरणों की अनुक्रम/अनुक्रम की पूरी प्रक्रिया कतार)?
2. यदि खिलाड़ी के प्रबंधन के लिए पूरी तरह से ईवेंट-संचालित सिस्टम बनाया जाना था, तो आप प्रत्येक खिलाड़ी के माध्यम से उन्हें कैसे चालू करते हैं ताकि उन्हें बारी के लिए संकेत दिया जा सके और गेम समाप्त होने तक इसे फिर से चालू रखा जा सके?
3. यदि ऊपर वर्णित विशिष्ट समस्या को हल करने के लिए गेम लूप का उपयोग किया जाना था, तो क्या यूआई को फ्रीज करने से बचने के लिए इसे अपने स्वयं के धागे (संभावित रूप से SwingWorker का उपयोग करके) चलाने के लिए किया जाना चाहिए? मेरी स्थिति जावा-विशिष्ट है, लेकिन मुझे लगता है कि मुझे गैर-जावा-विशिष्ट परिस्थितियों के उत्तर में रुचि होगी।

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

नियंत्रक से

SwingWorker कोड:

swingWorker = new SwingWorker<Void, Model>() { 
@Override 
protected Void doInBackground() throws InterruptedException { 
gameLoopRunning = true; 
while (gameLoopRunning) { 

    //to do: use a timer instead of thread.sleep 
    Thread.sleep(1000); 

    //user turn prompt 
    if (model.getActivePlayer().isUserControlled()) { 

     boolean userRolled = false; 
     while(!userRolled) { 
      System.out.println("Roll the dice please..."); 
      Thread.sleep(3000); 
     } 

    } 
    //bot turn prompt 
    else { 
     //insert code for bot rolling dice here 
     model.rollDice(); 
    } 

    publish(model); 

    Thread.sleep(1000); 
    model.incrementPlayerTurn(); 
    publish(model); 

} 
return null; 
} 

@Override 
protected void process(List<Model> chunks) { 
Model gameModel = chunks.get(chunks.size() - 1); 
//hard-coded for 6 players 
for (int i = 0; i < 6; i++) { 
    view.getPlayerPanel(i).setTurn(gameModel.getPlayers().get(i).isTurn()); 
} 
view.getGamePanel().getDice().setDie1(model.getDie1()); 
view.getGamePanel().getDice().setDie2(model.getDie2()); 
} 

}; 
swingWorker.execute(); 

Answer 1

SirDarius से टिप्पणी स्थान पर है।

हालांकि, आगे बढ़ने वाले खिलाड़ी के रूप में सरल कुछ के लिए, आपको वास्तव में एक पूर्ण परिमित राज्य मशीन को लागू करने की परेशानी की आवश्यकता नहीं है।

MVC के संदर्भ में, यह आप मानव खिलाड़ियों के लिए क्या करना चाहिए है:

• मॉडल: अगले खिलाड़ी को सक्रिय खिलाड़ी को आगे बढ़ाने के लिए और के माध्यम से चलाने के लिए तरीकों प्रदान करें " प्रक्रिया चालू करें "(यानी पासा रोलिंग, सक्रिय खिलाड़ी के टोकन इत्यादि को स्थानांतरित करना)। चूंकि अधिकांश बारी प्रक्रिया घटना संचालित होती है, इसलिए इन विधि कॉल कंट्रोलर में ईवेंट श्रोताओं से की जाएगी।

• देखें: जब कोई सक्रिय खिलाड़ी अपनी बारी समाप्त करता है, साथ ही विभिन्न अन्य इनपुट पर ईवेंट को बढ़ाता है तो एक ईवेंट बढ़ाएं।

• नियंत्रक: जब भी कोई खिलाड़ी अपनी बारी समाप्त करता है, तो मॉडल को अगले खिलाड़ी को अग्रिम करने के लिए कहें, और फिर "बारी प्रक्रिया" शुरू करें। जब भी कोई खिलाड़ी इनपुट प्रदान करता है, तो एक कार्यक्रम निकाल दिया जाएगा जो मॉडल को मोड़ के अगले चरण तक अग्रिम करने के लिए कहता है।

ऐ खिलाड़ियों के लिए, एक ही कोड के बहुमत इस्तेमाल किया जा सकता है, लेकिन यह मतलब नहीं है बारी प्रगति देखने से संचालित किया है। इसके बजाए, मॉडल को एक और "बारी प्रक्रिया" विधि की आवश्यकता होगी जो विशेष रूप से एआई खिलाड़ियों के लिए होगी। एकमात्र अंतर यह है कि कोड सुनवाई में इनपुट के इंतजार किए बिना उत्तराधिकार में निष्पादित होगा, घटना श्रोताओं की एक श्रृंखला होने के बजाय।