सी। में गेम कैसे प्रोग्राम करें ट्यूटोरियल एक

यह पूरी तरह से शुरुआती के लिए सी में कई गेम प्रोग्रामिंग ट्यूटोरियल का पहला है। C को पढ़ाने पर ध्यान केंद्रित करने के बजाय उदाहरण के कार्यक्रमों को दिखाते हुए वे C को आपको C में पूर्ण कार्यक्रम (यानी गेम) प्रदान करके सिखाते हैं

श्रृंखला में पहला गेम एक कंसोल (यानी पाठ आधारित खेल जिसे स्टार एम्पायर कहा जाता है) है। स्टार एम्पायर एक सरल गेम है जिसमें आपको अपने AI प्रतिद्वंद्वी को ऐसा करने से रोकते हुए गैलेक्सी में सभी 10 सिस्टम कैप्चर करने होंगे।

आप अपना सिस्टम 9 शुरू करते हैं, जबकि आपका दुश्मन 9 सिस्टम का मालिक है। शेष आठ सिस्टम (1-8) सभी तटस्थ शुरू होते हैं। सभी सिस्टम एक 5 पार्सके x 5 पार्सेक वर्ग के भीतर शुरू होते हैं, इसलिए कोई भी सिस्टम 6 पारसेक से अधिक नहीं है। सबसे पहले दो बिंदु (0,0) और (4,4) हैं। पाइथागोरस प्रमेय द्वारा, किसी भी दो प्रणालियों के अलावा सबसे दूर की दूरी वर्गमूल (4) है² + (4)²) जो 32 का वर्गमूल है जो लगभग 5.657 है।

कृपया ध्यान दें, यह अंतिम संस्करण नहीं है और इसमें संशोधन किया जाएगा। अंतिम परिवर्तन: 21 अगस्त, 2011

खेल बारी आधारित है और प्रत्येक मोड़ आप किसी भी प्रणाली से किसी भी अन्य प्रणाली के लिए किसी भी संख्या में बेड़े को स्थानांतरित करने के आदेश देते हैं। यदि आप एक से अधिक सिस्टम के मालिक हैं, तो आप अपने सभी सिस्टम से लक्ष्य प्रणाली में जाने के लिए बेड़े को ऑर्डर कर सकते हैं। यदि आप तीन प्रणालियों (1,2,3) के साथ 20, 10 और 5 बेड़े मौजूद हैं, तो यह प्रो रटा हुआ है और आप 10 फ्लेट्स को सिस्टम 4 में जाने का आदेश देते हैं, फिर 6 सिस्टम 1 से, 3 सिस्टम 2 से और 1 सिस्टम से जाएगा 3. प्रत्येक फ्लीट 1 परसेक प्रति मोड़ पर चलती है।

प्रत्येक मोड़ 5 सेकंड तक रहता है, हालांकि आप इसे गति देने के लिए गति को बदल सकते हैं या कोड की इस पंक्ति में 5 को 3 या 7 या जो भी आप चुनते हैं, उसे बदलकर धीमा कर सकते हैं। कोड की इस पंक्ति को देखें:

onesec = clock () + (5 * CLOCKS_PER_SEC);

इस गेम को प्रोग्राम किया गया है और माना जाता है कि आप किसी भी सी प्रोग्रामिंग को नहीं जानते हैं। मैं सी प्रोग्रामिंग सुविधाओं को इसमें और अगले दो या तीन ट्यूटोरियल पेश करूंगा क्योंकि वे आगे बढ़ रहे हैं। हालांकि पहले आपको विंडोज के लिए एक कंपाइलर की आवश्यकता होगी। यहाँ दो स्वतंत्र हैं:

• प्रयत्न CC386
• या विजुअल C ++ 2010 एक्सप्रेस

CC386 लेख एक परियोजना बनाने के माध्यम से चलता है। यदि आप उस संकलक को स्थापित करते हैं तो आपको बस इतना करना है कि हैलो वर्ल्ड प्रोग्राम को वर्णित के रूप में लोड करें, उदाहरण के ऊपर स्रोत कोड को कॉपी और पेस्ट करें, इसे सहेजें और फिर इसे संकलित करने और चलाने के लिए F7 मारा। इसी तरह Visual C ++ 2010 लेख एक हैलो वर्ल्ड प्रोग्राम बनाता है। इसे अधिलेखित करें और स्टार एम्पायर्स के निर्माण के लिए F7 दबाएं। इसे चलाने के लिए F5।

अगले पेज पर - स्टार एम्पायर वर्क बनाना

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

• उत्पत्ति प्रणाली (1-10)।
• गंतव्य प्रणाली (1-10)
• कितने जहाज (1-कई)
• आगमन होता है
• किसकी फ्लीट है? 0 = खिलाड़ी, 9 = दुश्मन

इसे धारण करने के लिए हम C में एक संरचना का उपयोग करेंगे:

एक संरचना डेटा का एक संग्रह है, इस मामले में 5 नंबर जो हम एक के रूप में हेरफेर करते हैं। प्रत्येक संख्या का एक नाम होता है, उदाहरण के लिए सिस्टम से, सिस्टम से। ये नाम C में परिवर्तनशील नाम हैं और अंडरस्कोर हो सकते हैं जैसे_थिस लेकिन स्पेस नहीं। सी में, संख्याएं पूर्णांक हैं; 2 या 7 जैसे संपूर्ण संख्याओं को इन्ट्स या संख्याओं को दशमलव भागों के साथ 2.5 या 7.3333 कहा जाता है और इन्हें फ़्लोट्स कहा जाता है। पूरे स्टार साम्राज्यों में, हम केवल एक बार झांकियों का उपयोग करते हैं। कोड के एक हिस्से में दो स्थानों के बीच की दूरी की गणना। हर दूसरी संख्या एक इंट है।

तो बेड़े पांच अंतर चर धारण करने वाले डेटा संरचना का नाम है। अब वह एक बेड़े के लिए है। हम नहीं जानते हैं कि कितने बेड़े की आवश्यकता होगी ताकि हम एक सरणी का उपयोग करके 100 के लिए उदार कमरा आवंटित कर सकें। पांच लोगों (ints) के लिए कमरे के साथ खाने की मेज की तरह एक संरचना के बारे में सोचो। एक सरणी डिनर टेबल की लंबी पंक्ति की तरह है। 100 टेबल का मतलब है कि इसे 100 x 5 लोग पकड़ सकते हैं।

यदि हम वास्तव में उन 100 डिनर टेबल की सेवा कर रहे थे, तो हमें यह जानना होगा कि कौन सी तालिका थी और हम इसे क्रमबद्ध करके करते हैं। सी में, हम हमेशा 0 से शुरू होने वाले सरणियों के तत्वों को संख्या देते हैं। पहला डिनर टेबल (बेड़ा) नंबर 0 है, अगला अगला 1 है और आखिरी 99 है। मुझे हमेशा यह याद रहता है कि यह डिनर टेबल शुरू से ही कितनी है? पहला वाला शुरुआत में है इसलिए 0 साथ है।

इस तरह से हम बेड़े की घोषणा करते हैं (यानी हमारी डिनर टेबल)।

इसे बाएं से दाएं पढ़ें। स्ट्रक्चर फ्लीट हमारे ढांचे को संदर्भित करता है एक बेड़े को रखने के लिए। नाम बेड़ा वह नाम है जो हम सभी बेड़े को देते हैं और [100] हमें बताता है कि बेड़े के चर में 100 x संरचना का बेड़ा है। प्रत्येक इंट मेमोरी में 4 स्थान रखता है (जिसे बाइट्स कहा जाता है) इसलिए एक बेड़े में 20 बाइट्स होते हैं और 100 बेड़े 2000 बाइट्स होते हैं। यह जानना हमेशा एक अच्छा विचार है कि हमारे प्रोग्राम को अपने डेटा को रखने के लिए कितनी मेमोरी चाहिए।

संरचना के बेड़े में, प्रत्येक पुट्ठे में एक पूर्णांक संख्या होती है। यह संख्या 4 बाइट्स में संग्रहीत है और इस की सीमा -2,147,483,647 से 2,147,483,648 है। अधिकांश समय हम छोटे मूल्यों का उपयोग करेंगे। वहाँ दस प्रणालियाँ हैं, ताकि दोनों तंत्र और tosystem 0 से 9 मानों को धारण करेंगे।

अगले पेज पर: सिस्टम और रैंडम नंबर

तटस्थ प्रणालियों में से प्रत्येक (1-8) 15 जहाजों से शुरू होती है (एक संख्या जिसे मैंने हवा से बाहर उठाया है!) के साथ शुरू करने के लिए और अन्य दो (तुम्हारा: सिस्टम 0 और सिस्टम 9 में आपके कंप्यूटर प्रतिद्वंद्वी) में 50 जहाज प्रत्येक हैं। प्रत्येक प्रणाली में जहाजों की संख्या में 10% की वृद्धि हुई है और नीचे गोल किया गया है। तो एक मोड़ के बाद यदि आप उन्हें स्थानांतरित नहीं करते हैं, तो आपका 50 55 हो जाएगा और प्रत्येक तटस्थ सिस्टम में 16 (15 + 1.5 नीचे गोल) होंगे। ध्यान दें कि दूसरे सिस्टम में जाने वाले बेड़े संख्या में नहीं बढ़ते हैं।

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

शुरुआत में हमें सभी प्रणालियों को जेनरेट करना होगा और उन्हें अधिकतम एक सिस्टम के साथ मैप पर रखना होगा प्रत्येक स्थान, जैसा कि हमारे ५ x ५ ग्रिड पर २५ स्थान हैं, हमारे पास दस सिस्टम और १५ खाली होंगे स्थानों। हम उन्हें फ़ंक्शन GenMapSystems () का उपयोग करके उत्पन्न करते हैं, जिसे हम अगले पृष्ठ पर देखेंगे।

एक प्रणाली एक संरचना में संग्रहीत की जाती है, जिसमें निम्नलिखित 4 फ़ील्ड हैं जो सभी इंट हैं।

आकाशगंगा (सभी 10 सिस्टम) को एक और सरणी में संग्रहीत किया जाता है, जैसे कि बेड़े में केवल 10 सिस्टम हैं।

सभी खेलों को यादृच्छिक संख्या की आवश्यकता होती है। C में बिल्ट इन फंक्शन रैंड () है जो एक यादृच्छिक इंट देता है। हम% ऑपरेटर द्वारा अधिकतम संख्या में और उसका उपयोग करके इसे एक सीमा में बाध्य कर सकते हैं। (मापांक)। यह घड़ी की गणित की तरह है सिवाय 12 या 24 के हम एक अधिकतम संख्या में गुजरते हैं जिसे अधिकतम कहा जाता है।

यह एक फ़ंक्शन का एक उदाहरण है जो एक कंटेनर के अंदर लिपटा हुआ कोड का एक टुकड़ा है। यहां पहली पंक्ति जो शुरू होती है / * और अंत * / एक टिप्पणी है। यह कहता है कि कोड क्या करता है लेकिन संकलक द्वारा अनदेखा किया जाता है जो सी निर्देशों को पढ़ता है और उन्हें निर्देशों में परिवर्तित करता है जो कंप्यूटर समझता है और बहुत तेजी से निष्पादित कर सकता है।

• आश्चर्य है कि एक संकलक क्या है? पढ़ें एक कंपाइलर क्या है? (लेख)

एक फ़ंक्शन एक गणितीय फ़ंक्शन जैसे पाप (x) की तरह है। इस फ़ंक्शन के तीन भाग हैं:

इंट का कहना है कि यह किस प्रकार की संख्या देता है (आमतौर पर इंट या फ्लोट)। रैंडम फ़ंक्शन का नाम है और (int max) कहता है कि हम एक इंट संख्या में गुजर रहे हैं। हम इसे इस तरह उपयोग कर सकते हैं:

रेखा:

अगले पेज पर: रैंडम स्टार्ट मैप बनाना

नीचे दिया गया यह कोड स्टार्ट मैप तैयार करता है। यह ऊपर दिखाया गया है।

जनरेटिंग सिस्टम खिलाड़ी और प्रतिद्वंद्वी सिस्टम (0,0 पर) और (4,4) को जोड़ने और फिर शेष 23 खाली स्थानों में 8 सिस्टम को जोड़ने का मामला है।

कोड लाइन द्वारा परिभाषित तीन अंतर चर का उपयोग करता है

एक चर स्मृति में एक स्थान है जो एक अंतर मूल्य रखता है। वेरिएबल्स x और y सिस्टम के निर्देशांक रखते हैं और रेंज 0-4 में एक मान रखेंगे। चर का उपयोग मैं छोरों में गिनती के लिए किया जाता है।

5x5 ग्रिड में 8 रैंडम सिस्टम रखने के लिए हमें यह जानना होगा कि क्या किसी लोकेशन में सिस्टम पहले से मौजूद है और उसी स्थान पर किसी दूसरे को रखा जा रहा है। इसके लिए हम सरल दो आयामी वर्णों का उपयोग करते हैं। प्रकार चार C में एक अन्य प्रकार का चर है और 'B' या 'x' जैसे एकल वर्ण रखता है।

C में वैरिएबल के मूल प्रकार int (46 जैसे पूर्णांक), char ('A' जैसे एकल वर्ण), और फ्लोट (3.567 जैसे फ्लोटिंग पॉइंट वाले नंबर रखने के लिए) हैं। Arrays [] एक ही तत्व की सूची रखने के लिए हैं। तो चार [5] [5] सूचियों की एक सूची को परिभाषित करता है; वर्णों की एक दो आयामी सरणी। इसे ऐसे समझें जैसे 5 x 5 ग्रिड में 25 स्क्रैबल टुकड़े की व्यवस्था की गई है।

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

• एक्स = 0; यह इनिशियलाइज़ेशन पार्ट है।
• एक्स
• एक्स ++। यह बदलाव का हिस्सा है। यह 1 से x जोड़ता है।

तो (के लिए (x = 0; x)

अंदर के लिए (x लूप y लूप के लिए है जो y के लिए समान है। यह y लूप X के प्रत्येक मान के लिए होता है। जब X 0 है, तो Y 0 से 4 तक लूप करेगा, जब X 1 है, तो Y लूप वगैरह लेगा। इसका मतलब यह है कि लेआउट सरणी में 25 स्थानों में से प्रत्येक को एक स्थान पर आरंभीकृत किया गया है।

लूप के लिए फ़ंक्शन के बाद InitSystem को पांच इंटिमेट पैरामीटर के साथ कहा जाता है। किसी फ़ंक्शन को कॉल करने से पहले परिभाषित करना होगा या कंपाइलर को यह पता नहीं होगा कि उसके कितने पैरामीटर होने चाहिए। InitSystem में ये पांच पैरामीटर हैं।

अगले पेज पर: एक रैंडम स्टार्ट मैप कंटिन्यू जनरेट करना ...

ये InitSystem के पैरामीटर हैं।

• systemindex - 0 -9 से एक मान।
• x और y - सिस्टम का निर्देशांक (0-4)।
• numships - इस प्रणाली में कितने जहाज हैं।
• मालिक। जो एक प्रणाली का मालिक है। 0 का मतलब है खिलाड़ी, 9 का मतलब है दुश्मन।

तो लाइन InitSystem (0,0,0,50,0) स्थानों 0 = 0 के लिए 50 जहाजों के साथ x = -0, y = 0 स्थानों पर सिस्टम 0 को प्रारंभ करता है।

C में तीन प्रकार के लूप हैं, जबकि लूप्स, लूप्स के लिए और लूप्स हैं और हम फ़ंक्शन GenMapSystems में उपयोग करते हैं और करते हैं। यहां हमें शेष 8 प्रणालियों को आकाशगंगा में कहीं रखना होगा।

इस कोड में दो नेस्टेड लूप हैं। बाहर का लूप एक स्टेटमेंट है जो 1 के शुरुआती मूल्य से 8 के अंतिम मान तक i चर को गिनता है। हम सिस्टम का उल्लेख करने के लिए i का उपयोग करेंगे। याद रखें कि हमने पहले ही सिस्टम 0 और 9 को इनिशियलाइज़ कर दिया है, इसलिए अब हम सिस्टम 1-8 को इनिशियलाइज़ कर रहे हैं।

Do से सब कुछ {the जबकि (लेआउट [x] [y] दूसरा लूप है। यह वाक्यविन्यास है {कुछ} जबकि (स्थिति सत्य है); इसलिए हम x और y के लिए यादृच्छिक मान प्रदान करते हैं, प्रत्येक मान रेंज 0-4 में। रैंडम (5) रेंज 1 से 5 में मान लौटाता है, 1 घटाकर रेंज 0-4 हो जाता है।

हम एक ही निर्देशांक पर दो सिस्टम नहीं लगाना चाहते हैं, इसलिए यह लूप एक यादृच्छिक स्थान की तलाश में है जिसमें एक स्थान हो। यदि वहां कोई सिस्टम है, तो लेआउट [x] [y] एक स्थान नहीं होगा। जब हम InitSystem कहते हैं, तो यह वहां एक अलग मूल्य रखता है। BTW! = का मतलब नहीं के बराबर और == के बराबर का मतलब है।

जब कोड InitSystem में पहुँचता है जबकि (लेआउट [x] [y]! = ’’), X और y निश्चित रूप से लेआउट में एक जगह को संदर्भित करता है जिसमें एक स्थान होता है। इसलिए हम InitSystem को कॉल कर सकते हैं और फिर अगले सिस्टम के लिए एक यादृच्छिक स्थान खोजने के लिए लूप के लिए राउंड पर जा सकते हैं जब तक कि सभी 8 सिस्टम को रखा नहीं गया है।

InitSystem की पहली कॉल 50 बेड़े के साथ सिस्टम 0,0 (ग्रिड के शीर्ष बाएं) पर सिस्टम 0 सेट करती है और मेरे द्वारा जीती गई। दूसरा कॉल 50 बेड़े के साथ सिस्टम 4,4 (नीचे दाएं) पर सिस्टम 9 को इनिशियलाइज़ करता है और यह प्लेयर 1 के स्वामित्व में है। हम अगले ट्यूटोरियल में वास्तव में क्या करता है, इस पर बारीकी से विचार करेंगे।

ये पंक्तियाँ शाब्दिक मूल्यों की घोषणा करती हैं। उन्हें ऊपरी मामले में रखने की प्रथा है। हर जगह कंपाइलर MAXFLEETS देखता है, यह मान 100 का उपयोग करता है। उन्हें यहां बदलें और यह हर जगह लागू होता है:

• # डेफिन WIDTH 80
• # डेफ़िन ऊँचाई 50
• # डेफिन मैक्सलेन 4
• # डेफिन मैक्सफ्लेट्स 100
• #define MAXSYSTEMS 10
• # डेफ़िन फाइटमेकर 999

इस ट्यूटोरियल में, हमने सूची बनाने के लिए उन्हें और अधिक सरणी में समूहित करने के लिए चर, और चर का उपयोग किया है। तब के लिए और का उपयोग कर सरल लूपिंग। यदि आप स्रोत कोड की जांच करते हैं, तो समान संरचनाएं समय-समय पर देखी जाती हैं।

• के लिए (i = 0; i)
• के लिए (i = 0; i)

इस ट्यूटोरियल में उल्लिखित C के पहलुओं पर ट्यूटोरियल Twowill दिखेगा।