गोल्डन टी गेम इंजन (GTGE) - पहला डेटिंग

ऐसा हुआ कि मुझे जावा में एक 2 डी एप्लिकेशन - एक गेम लिखने की आवश्यकता थी। मुझे एक तैयार इंजन की तलाश करनी थी जो स्प्राइट्स लोड कर सके, वस्तुओं के टकराव को संभाल सके, टाइल्स और बैकग्राउंड के साथ काम कर सके। यह मेरे लिए आवश्यक कार्यों का न्यूनतम सेट था। विकल्प " गोल्डन टी गेम इंजन (GTGE) " पर गिर गया। इसे स्पष्ट रूप से समझने के बाद, मैं अपने अनुभव को हैबर्स के साथ साझा करना चाहूंगा ।

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

आयात java.awt। * ;
आयात com.golden.gamedev। * ;

सार्वजनिक वर्ग का मुख्य खेल {
सार्वजनिक स्थैतिक शून्य मुख्य ( स्ट्रिंग [ ] args ) {
GameLoader खेल = नया GameLoader ( ) ; // क्लास जो एप्लिकेशन इनिशियलाइज़ेशन को नियंत्रित करती है
खेल। सेटअप ( नया मुख्य ) , नया आयाम ( 640 , 480 ) , गलत ) ; // ग्राफिक्स इंजन को इनिशियलाइज़ करें
खेल। शुरू ( ) ;
}

@Override
सार्वजनिक शून्य initResources ( ) {
// प्रारंभिक खेल चर और संसाधनों
}

@Override
सार्वजनिक शून्य रेंडर ( Graphics2D g ) {
// ग्राफिक्स रेंडरिंग
}

@Override
सार्वजनिक शून्य अद्यतन ( लंबे समय तक समाप्त ) {
// चर और संसाधनों के लिए अद्यतन
}
}

अब, आप शुरू कर सकते हैं। एक विंडो GTGE लोगो और FPS काउंटर के साथ दिखाई देती है। लेकिन तस्वीर अपडेट नहीं है। सीधे शब्दों में कहें, एक दूसरे पर आरोपित। इसे एफपीएस काउंटर पर जाकर देखा जा सकता है। अगला, आपको पृष्ठभूमि के साथ खेल के क्षेत्र को शुरू करने की आवश्यकता है। पृष्ठभूमि के रूप में, कोई भी आरजीबी रंग, चित्र हो सकता है। खेल का मैदान क्या है? खेल मैदान उस पर ग्राफिक्स रेंडर करने के लिए एक मंच है। एक खेल मैदान बनाने के लिए और उसके बाद की पृष्ठभूमि के लिए, आपको कुछ और फाइलें जोड़ने की जरूरत है:

आयात com.golden.gamedev.object। * ;
आयात com.golden.gamedev.object.background। * ;

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

पृष्ठभूमि वापस = नया ColorBackground ( नया रंग ( 255 , 255 , 255 ) ) ;

अब, खेल का मैदान बनाने का समय आ गया है। पृष्ठभूमि को शुरू करने के तुरंत बाद, हम लिखते हैं:

PlayField pf = नया PlayField ( पीछे ) ;

PlayField वर्ग के निर्माता के लिए एक तर्क पृष्ठभूमि है, जो डिफ़ॉल्ट रूप से स्थापित किया जाएगा। और अंत में, सबसे महत्वपूर्ण बात खेल के मैदान को अद्यतन करना और प्रदान करना है।
ग्राफिक्स रेंडरिंग फंक्शन में, निम्नलिखित लिखें:

पीएफ। रेंडर ( जी ) ;

और अद्यतन समारोह में -

पीएफ। अद्यतन ( elapsedTime ) ;

आप दौड़ सकते हैं। हम क्या देखते हैं? सफेद खाली खेल मैदान। कुछ याद आ रहा है। आगे, हम एक गेम ऑब्जेक्ट बनाएंगे, जिसे तीर द्वारा नियंत्रित किया जाता है।
एक खेल के मैदान पर स्प्राइट खींचने के लिए, आपको पहले इसे लोड करने और इसे स्प्राइट समूह में रखने की आवश्यकता है। अब हम यह करेंगे हमें तीन चर की आवश्यकता होगी जो स्प्राइट समूह , अपलोड की गई छवि और वास्तव में स्प्राइट के लिए जिम्मेदार हैं।
कक्षा की शुरुआत में इन चरों की घोषणा करें:

स्प्राइटग्रुप spr_group ;
बफ़रेडइमेज स्प्रे_बफ़र ;
स्प्राइट स्प्रेयर ;

अगला, चित्र अपलोड करने के लिए फ़ाइल कनेक्ट करें:

आयात java.awt.image.BufferedImage ;

स्प्राइट लोड करने के लिए सब कुछ अब पूरी तरह से चालू है। "मुख्य पात्र" के रूप में मैंने यह चित्र चुना:

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

// स्प्राइट ग्रुप बनाएं
spr_group = नया SpriteGroup ( "grp_player" ) ;
// एक तस्वीर अपलोड करें
spr_buffer = getImage ( "plane1.png" ) ;
// एक खिलाड़ी स्प्राइट बनाएँ
spr_player = नया स्प्राइट ( spr_buffer, 100 , 100 ) ;
// खिलाड़ी के स्प्राइट को समूह में जोड़ें
spr_group। add ( spr_player ) ;
// खेल के मैदान पर स्प्राइट्स का एक समूह रखें
पीएफ। addGroup ( spr_group ) ;

अब, आप खेल शुरू कर सकते हैं और देख सकते हैं कि वहां क्या हुआ था? हमारे पास खेल के मैदान पर एक प्रेत है। इसे कैसे प्रबंधित किया जाए, यह "सीखना" अच्छा होगा। इसके लिए हम क्या कर रहे हैं?
हमारे पास स्प्राइट ऑब्जेक्ट का लिंक है। इस ऑब्जेक्ट में फ़ंक्शंस xX और मूव है । इसलिए हम उनमें फेरबदल करेंगे।
कीस्ट्रोक को संभालने के लिए, हमें निम्नलिखित फ़ाइल को शामिल करना होगा:

आयात java.awt.event.KeyEvent ;

अपडेट फ़ंक्शन में, निम्नलिखित लिखें:

if ( कीडाउन ( KeyEvent । VK_W ) ) spr_player। मूव ( - 3 ) ;
if ( कीडाउन ( KeyEvent । VK_S ) ) spr_player। मूव ( 3 ) ;
if ( कीडाउन ( KeyEvent । VK_A ) ) spr_player। MoveX ( - 3 ) ;
if ( कीडाउन ( KeyEvent । VK_D ) ) spr_player। MoveX ( 3 ) ;

अब, हम अपने मुख्य चरित्र को नियंत्रित कर सकते हैं।

एनीमेशन

अगला, मैं लोडिंग एनिमेशन के बारे में बात करना चाहूंगा। एनीमेशन के लिए, मैं निम्नलिखित स्प्राइट का उपयोग करूंगा:

एक एनिमेटेड स्प्राइट बनाने के लिए, आपको विशेष फ़ंक्शन getImage s के साथ एक चित्र लोड करने की आवश्यकता है। आप एक तस्वीर के रूप में अपलोड कर सकते हैं जिसमें कई फ्रेम होते हैं, और प्रत्येक फ्रेम व्यक्तिगत रूप से। यहाँ दो छोटे उदाहरण दिए गए हैं:
उदाहरण 1:

बफ़रेडइमेज [ ] aspr_buffer = getImages ( "plane2.png" , 3 , 1 ) ;

उदाहरण 2:

बफ़रेडइमेज [ ] aspr_buffer = {
getImage ( "plane1.png" ) ,
getImage ( "plane2.png" ) ,
getImage ( "plane3.png" )
} ;

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

aspr_player = new AnimatedSprite ( aspr_buffer, 100 , 100 ) ;

इस ऑब्जेक्ट में कई फ़ंक्शन हैं। मुख्य वाले, मैं अब विस्तार से वर्णन करूंगा।

// फ़ंक्शन एक टाइमर ऑब्जेक्ट का संदर्भ देता है
aspr_player। getAnimationTimer ( ) ;

एनीमेशन की गति को बदलने के लिए, हमें टाइमर को चालू करना होगा। यह ऊपर के फ़ंक्शन द्वारा किया जाता है। फिर, हम सेटलेले फ़ंक्शन को कॉल करते हैं, जिसका तर्क एक नंबर है - स्प्राइट फ्रेम में परिवर्तन के बीच एमएस की संख्या।

aspr_player। getAnimationTimer ( ) । setDelay ( 100 ) ;

प्रत्येक फ्रेम 100ms के बाद बदल जाएगा।
एक एनिमेटेड स्प्राइट के फ्रेम की संख्या को बदलने के लिए, आपको setAnimationFrame फ़ंक्शन को कॉल करना होगा
एक उदाहरण:

aspr_player। setAnimationFrame ( 0 , aspr_buffer। लंबाई - 1 ) ;

पहला तर्क पहला फ्रेम है, दूसरा आखिरी है। अंतिम फ्रेम - डाउनलोड की गई छवियों के साथ सरणी में तत्वों की संख्या - 1 । इस प्रकार, आप स्प्राइट में फ्रेम के अनुक्रम को बदल सकते हैं।
सेटअनैम फ़ंक्शन का उपयोग करके, आप स्प्राइट एनीमेशन को सक्षम / अक्षम कर सकते हैं।

// एनिमेशन ऑन
aspr_player। setAnimate ( सच ) ;

और setLoopAnim फ़ंक्शन का उपयोग करके, आप फ़्रेम के " लूप " को बदल सकते हैं। यानी एनीमेशन के अंत के बाद, इसे रोका नहीं जाएगा, लेकिन स्वचालित रूप से फिर से शुरू होगा।

aspr_player। setLoopAnim ( सच ) ;

आइए अपने मुख्य उदाहरण पर वापस जाएं।
छवियों को लोड करने और स्प्राइट बनाने के लिए कोड बदलें

aspr_buffer = getImages ( "plane2.png" , 3 , 1 ) ;
aspr_player = new AnimatedSprite ( aspr_buffer, 100 , 100 ) ;
aspr_player। getAnimationTimer ( ) । setDelay ( 80 ) ;
aspr_player। setAnimationFrame ( 0 , aspr_buffer। लंबाई - 1 ) ;
aspr_player। setAnimate ( सच ) ;
aspr_player। setLoopAnim ( सच ) ;
spr_group। add ( aspr_player ) ;

और कक्षा की शुरुआत में, कई चर घोषित करें:

बफ़रेडइमेज [ ] aspr_buffer ;
एनिमेटेडएस्प्रेसित aspr_player ;

और इसके अलावा, स्प्राइट के आंदोलन को बदल दें

if ( कीडाउन ( KeyEvent । VK_W ) ) aspr_player। मूव ( - 2 ) ;
if ( कीडाउन ( KeyEvent । VK_S ) ) aspr_player। मूव ( 2 ) ;
if ( कीडाउन ( KeyEvent । VK_A ) ) aspr_player। MoveX ( - 2 ) ;
if ( कीडाउन ( KeyEvent । VK_D ) ) aspr_player। MoveX ( 2 ) ;

अब आप दौड़ कर देख सकते हैं। खेल के मैदान पर "घूर्णन ब्लेड" के साथ विमान का एक प्रेत होता है।

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

लेख लिखने के लिए मैंने इंजन की आधिकारिक वेबसाइट से जानकारी का उपयोग किया।
एक उदाहरण से लिंक करें।