💋 💇🏽 🍩 आकस्मिक यांत्रिकी 🕋 💔 🕵🏻

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

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

अनुप्रयोग चक्र

कार्यक्रम को व्यवस्थित करने का सही तरीका चुनने के लिए, आपको मुख्य चक्र में प्रतिभागियों पर निर्णय लेने की आवश्यकता है। किसी भी आकस्मिक (और सबसे गैर-आकस्मिक) खेल में उनमें से कम से कम तीन हैं:

गेमप्ले की घड़ी
निरंतरता सिम्युलेटर
दृश्य प्रतिपादन

अन्य बिंदु भी संभव हैं - एनीमेशन प्रबंधक, कृत्रिम बुद्धि, आदि। उदाहरण के लिए, ये तीन हमारे लिए पर्याप्त होंगे।

वे किस तरह के प्रतिभागी हैं?

गेमप्ले क्लॉक को टाइमर ... um ... गेमप्ले क्लॉक से जोड़ा जाता है। यह खेल के मैदान पर वस्तुओं की गति को नियंत्रित करता है। इसका मुख्य उद्देश्य खेल प्रक्रिया की अखंडता और इसकी पहचान सुनिश्चित करना है । यह बहुत महत्वपूर्ण है - न केवल इसलिए ताकि गेम की गति कंप्यूटर के प्रदर्शन पर निर्भर न हो, लेकिन नेटवर्क पर खेलते समय सिंक्रनाइज़ेशन सुनिश्चित करने के लिए भी।

निरंतरता सिम्युलेटर एक सहायक फ़ंक्शन है, जिसका मुख्य उद्देश्य यह सुनिश्चित करना है कि गेम जनरेटर के कॉल के बीच कुछ महत्वपूर्ण नहीं होता है। उदाहरण के लिए, ऐसे खेल के क्षण पर विचार करें:

बाएँ और दाएँ, गेमप्ले घड़ी की लगातार दो कॉल दिखाई जाती हैं। मान लीजिए कि पीले सर्कल की गति = 3. सर्कल और आयत के बीच की दूरी, जैसा कि आंकड़े से देखा जा सकता है, = 2. यह पता चलता है कि सर्कल और आयताकार टकरा नहीं जाएंगे यदि उनकी मदद नहीं की जाती है। निरंतरता सिम्युलेटर भी यह सहायता प्रदान करता है।

दृश्य प्रतिपादन - यहाँ सब कुछ स्पष्ट प्रतीत होता है। यह एक अलग आइटम है, क्योंकि:

गेमप्ले की गति पर निर्भर नहीं होना चाहिए;
छवि की चिकनाई सुनिश्चित करनी चाहिए (स्क्रीन और ऑब्जेक्ट आवृत्ति पर = 10 बिंदुओं पर = गेम की आवृत्ति = 30, एक चलती ऑब्जेक्ट के झटके दिखाई देंगे यदि फ्रेम केवल तभी प्रदान किए जाते हैं जब गेमप्लेयर जनरेटर कहा जाता है)

लूप को व्यवस्थित करने के संभावित तरीके

प्रत्येक प्रतिभागी के लिए एक अलग धारा बनाने के लिए तुरंत मेरे दिमाग में आता है। हालाँकि, यह दृष्टिकोण इष्टतम नहीं है, क्योंकि:

लूप में प्रतिभागियों के बीच डिफ़ॉल्ट सिंक्रनाइज़ेशन प्रदान नहीं करता है। नेटवर्क लड़ाइयों के समानार्थीवाद को बनाए रखने के लिए अचानक आपको प्रतिपादन और एनीमेशन का त्याग करना होगा?
महत्वपूर्ण रूप से विकास को जटिल बनाता है और परिणामस्वरूप त्रुटियों की संख्या बढ़ जाती है। विभिन्न सूत्र = विभिन्न संसाधन, सिंक्रनाइज़ेशन और साझा करने के मुद्दे, और मल्टीथ्रेडेड प्रोग्राम के अन्य प्रसन्न।

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

खेल स्ट्रीम

प्रवाह संरचना को चित्र में दिखाया गया है:

अब स्पष्टीकरण के साथ एक छोटा कोड।
सबसे पहले, आवृत्तियों को सेट करें। मोटे तौर पर, कितने एमएस को प्रसंस्करण तर्क के लिए कॉल के बीच गुजरना चाहिए, प्रतिपादन:

कॉपी सोर्स | HTML कॉपी करें
// घड़ी: FREQ - तर्क, एफपीएस - प्रतिपादन
const int FREQ = 1000/40; // 1000 / एफपीएस
const int MAX_FPS = 1000/180;

और यहां मुख्य लूप कोड है - सभी प्रतिभागियों को कॉल के साथ, समय की जांच आदि।

कॉपी सोर्स | HTML कॉपी करें
जबकि ( सच )
{
qint64 time_cur_tick = QDateTime :: currentMSecsSinceEpoch ();
int numLoops = 0 ;
बूल फुट = सच;
जबकि ( time_prev_tick <time_cur_tick && numLoops <MAX_LOOPS )
{
// कॉल लॉजिक
w-> UpdateLogic ( 1 / FREQ );
संख्या;
अगर ( फीट )
{
फुट = झूठी;
last_freq = time_cur_tick;
}
time_prev_tick + = FREQ;
// अधिक सटीक समय के लिए time_cur_tick अपडेट करें
time_cur_tick = QDateTime :: currentMSecsSinceEpoch ();
}
time_tmp = QDateTime :: currentMSecsSinceEpoch ();
w-> SimulateConsistLogic ( (फ्लोट ) ( time_tmp - last_freq ) / FREQ);
time_tmp = QDateTime :: currentMSecsSinceEpoch ();
अगर ( time_tmp - time_lastrender> = MAX_FPS &&
w-> paint_mx.tryLock ( ))
{
time_lastrender = time_tmp;
फ्लोट फ्रीक_बिट = 0 ;
अगर ( time_tmp! = last_freq )
freq_bit = ( float ) ( time_tmp - last_freq ) / FREQ;
emit signalGUI ( freq_bit );
w-> paint_mx.unlock ();
}
}

(नोट - यदि आप स्रोत कोड को देखते हैं - वहां सब कुछ थोड़ा और अधिक जटिल है। प्रति सेकंड की गिनती के लिए एक फ्रेम है, घिसी हुई जानकारी का उत्पादन, आदि)

निश्चित रूप से सवाल उठता है - प्रतिपादन और निरंतरता सिम्युलेटर को गेम लॉजिक के अंतिम अपडेट के बाद से जो समय बीत चुका है वह क्यों पता है? सब कुछ सरल है - दृश्य की तात्कालिक स्थिति की गणना करने के लिए, और इसे सही ढंग से संसाधित करें और इसे स्क्रीन पर प्रदर्शित करें। संसाधनों को बचाने के लिए, निरंतरता सिम्युलेटर को कॉल करना इसके अंतिम कॉल के समय को भी स्थानांतरित कर सकता है।

यह सब कैसे काम करता है

हमारे उदाहरण में, तीन प्रकार की वस्तुएँ हैं:

खिलाड़ी जहाज
गोली
उल्कापिंड

उनके लिए संबंधित वर्ग (CShip, CBullet, CMeteorite) बनाए जाते हैं। गोलियों और उल्कापिंडों के लिए, QVector भंडारण कंटेनर निर्दिष्ट हैं।
उपयोगकर्ता इनपुट को संसाधित करने के लिए, "आंदोलन की दिशा" का एक सरणी बनाया गया था और फ़ंक्शन keyReleaseEvent और keyPressEvent को फिर से परिभाषित किया गया था:
keyReleaseEvent यह देखने के लिए जांचता है कि क्या जारी की गई कुंजियों की सरणी में कोई जारी कुंजी है और यदि कोई है तो उसे हटा देता है।
keyPressEvent तदनुसार दबाए गए कुंजी को दबाए गए कुंजियों के सरणी में डाल देता है (यदि यह वहां नहीं है)। इस सरणी का प्रसंस्करण खेल प्रक्रिया के घड़ी जनरेटर के कार्य में होता है। खेल की गतिमान वस्तुएं हैं, जहाज की गति के दौरान जड़ता की गणना, उल्कापिंडों का निर्माण:

कॉपी सोर्स | HTML कॉपी करें
शून्य मेनवॉइड :: अपडेटलॉगिक ( फ्लोट फ़ाइम )
{
फ्लोट गति = 2 ;
for ( int i = 0; मैं <m_dir.size ( ); i ++)
{
अगर ( m_dir [i] == MainWindow :: यूपी )
अभिनेता 1. अन्याय निर्देश ( QVector2D (0, -speed ));
अगर ( m_dir [i] == MainWindow :: DOWN )
अभिनेता 1. अन्याय निर्देश ( QVector2D (0, गति ));
अगर ( m_dir [i] == MainWindow :: LEFT )
अभिनेता 1. अन्याय निर्देश ( QVector2D ( -एसपीड, 0 ));
अगर ( m_dir [i] == MainWindow :: RIGHT )
अभिनेता 1. अन्याय निर्देश ( QVector2D (गति, 0 ));
अगर ( m_dir [i] == MainWindow :: SPACE &&
m_allowbullet == 0 )
{
m_bullets.push_back ( CBullet (actor1.getX ( ), actor1.getY () - 1 , QVector2D ( 0, -15 )));
qDebug (QString ( "बुलेट जोड़ी गई। Pos% 1" ) .arg ( m_bullets.size ( ) - 1 ) .toAscii ());
m_allowbullet = 5 ;
निकाल दिया ++;
}
}
actor1.step दिशा ();
बूल dir_touched = false;
for ( int i = 0; मैं <m_dir.size ( ); i ++)
{
अगर ( m_dir [i]! = MainWindow :: SPACE )
{
dir_touched = true;
तोड़;
}
}
अगर ( dir_touched )
{
m_allowmove = 0 ;
फ्लोट जड़ता = ० । 5 ;
अगर ( अभिनेता 1 .getSpeed ( ) < 0 । 5 )
जड़ता = 1 ;
actor1.adjustSpeed ( जड़ता );
}
for ( int i = 0; मैं <m_bullets.size ( ); i ++)
m_bullets [ i ] .step दिशा ();
के लिए ( int x = 0; x <m_enemy1.size ( ); x ++)
m_enemy1 [x] .step दिशा ();
CheckGameRules ();
अगर ( m_enemy1.size ( ) <max_enemy)
{
CMeteorite weather ( मकर) (field_ident + CMeteorite :: weather_size,
field_ident + field_w - CMeteorite :: weather_size ),
-मृंद ( 0, 20 ),
QVector2D ( 0, 1 ));
जबकि ( सच )
{
int i = 0 ;
जबकि ( i <m_enemy1.size ( ))
{
अगर ( weather.getBoundsT ) ( ) .intersects ( m_enemy1 [i] .getBoundsT ( ))
तोड़;
मैं ++;
}
अगर ( i == m_enemy1.size ( ))
तोड़;
मौसम = सीएमटोराइट ( मकर (1, 100 ), -मंद्र ( 0, 20 ),
QVector2D ( 0, 1 ));
}
m_enemy1.push_back ( मौसम );
}
UpdateBullet ();
}

CheckGameRules फ़ंक्शन गेम के नियमों की जांच करता है - जो किसी में दुर्घटनाग्रस्त हो गया, जो उससे आगे निकल गया, और इसी तरह। वैसे, 2D में यह QPolygon, QRect classes और उनके जैसे अन्य लोगों के कार्यों द्वारा बहुत आसानी से किया जाता है।

कॉपी सोर्स | HTML कॉपी करें
शून्य मेनवॉइड :: चेकगैमRules ( कॉन्स्ट फ्लोट फ़ाइम )
{
फ़ील्ड फ़ील्ड सही करें ( field_ident, field_ident,
field_w,
field_h );
for ( int i = 0; मैं <m_bullets.size ( ); i ++)
{
CBullet blt = m_bullets [ i ];
फ्लोट tx = 0 , ty = 0 ;
blt.getTickCoords ( ftime, tx, ty );
blt.setX ( tx );
blt.setY ( ty );
if ( field_rect.contains (m_bullets [i] .getX ( ), m_bul] [ i ] .getY ())।
{
m_bullets.remove (i--);
}
अन्यथा
{
for ( int j = 0; j <m_enemy1.size ( ); j ++)
{
CMeteorite enm = m_enemy1 [j];
फ्लोट एटैक्स = 0 , ईटीआई = 0 ;
enm.getTickCoords ( ftime, etx, ety );
enm.setX ( etx );
enm.setY ( ety );
अगर ( blt.checkCollision (enm.getBodyT ( )))
{
m_enemy1.remove ( j-- );
m_bullets.remove (i--);
स्कोर ++;
तोड़;
}
} // के लिए
}
}
for ( int j = 0; j <m_enemy1.size ( ); j ++)
{
CMeteorite enm = m_enemy1 [j];
अगर ( field_rect.contains (enm.getBoundsT ( )) &&
field_rect। bottomRight () .y () <enm.getBoundsT ()। topLeft () .y ())
{
m_enemy1.remove ( j-- );
}
अगर ( अभिनेता 1 चेककॉलिशन (enm.getBodyT ( )))
{
m_enemy1.remove ( j-- );
हिट्स ++;
}
}
अगर ( field_rect.contains (actor1.getBoundsT ( ), true))
{
जबकि ( field_rect.x ( )> = actor1.getBoundsT ()। बाएँ ()
actor1.setX ( actor1.getX ( ) + 1 );
जबकि ( field_rect.x ( ) * 2 + field_rect। चौड़ाई () <= actor1.getBoundsT ()। x () + actor1.getBoundsT ()। चौड़ाई ()।
actor1.setX ( actor1.getX ( ) - 1 );
जबकि ( field_rect.top ( )> = actor1.getBoundsT ()। शीर्ष ()
actor1.setY ( actor1.getY ( ) + 1 );
जबकि ( field_rect.y ( ) * 2 + field_rect. height () <= actor1.getBoundsT ()। y () + actor1.getBoundsT () ( ऊंचाई ) ()।
actor1.setY ( actor1.getY ( ) - 1 );
actor1.s शीर्ष ();
}
}

तदनुसार, निरंतरता के सिम्युलेटर का आह्वान अपमान के लिए सरल है। बस एक छोटे से कदम के साथ, हम खेल तर्क की जाँच करते हैं:

कॉपी सोर्स | HTML कॉपी करें
शून्य मेनवॉइड :: SimulateConsistLogic ( फ्लोट फ़ाइम )
{
के लिए ( फ्लोट बीटी = 0; बीटी <फ़ाइम; बीटी = बीटी + 0.1 )
{
CheckGameRules ( bt );
}
}

रेंडरिंग गेम फ़ील्ड को ड्रॉ करता है और गेम जनरेटर घड़ी के अंतिम कॉल से वर्तमान इंडेंटेशन के पैरामीटर के साथ सभी ऑब्जेक्ट्स के ड्रॉ () कॉल करता है। सेवा की जानकारी का प्लस उत्पादन:

कॉपी सोर्स | HTML कॉपी करें
शून्य मेनवूड :: रेंडर ()
{
QPainter qpainter ( यह );
const int bgw = 2 ;
qpainter.setPen ( QPen (Qt :: black, bgw ));
qpainter.setBrush ( QBrush (Qt :: darkGray ));
qpainter.drawRect ( field_ident, field_ident,
field_w + field_ident,
field_h + field_ident );
for ( int i = 0; मैं <m_bullets.size ( ); i ++)
{
CBullet blt = m_bullets [ i ];
blt.Draw ( qpainter, freq_bit );
}
for ( int i = 0; मैं <m_enemy1.size ( ); i ++)
{
CMeteorite enm = m_enemy1 [ i ];
enm.Draw ( qpainter, freq_bit );
}
actor1.Draw ( क्यूपैंटर, फ्रीक_बिट );
क्यूप्लेट पाल;
qpainter.setBrush ( pal.brush (QPalette :: Window ));
qpainter.setPen ( QPen (pal.color (QPalette :: Window ), 1 ));
qpainter.drawRect ( field_ident - bgw / 2, 0,
field_w + field_ident + bgw / 2,
field_ident - bgw );
qpainter.setPen ( QPen (Qt :: black, bgw ));
qpainter.setBrush ( QBrush (Qt :: darkGray, Qt :: NoBrush ));
qpainter.drawRect ( field_ident, field_ident,
field_w + field_ident,
field_h + field_ident );
ui-> label_freq-> setText (QString ("% 1" ) .arg ( freq ) .toAscii ());
ui-> label_fps-> setText (QString ("% 1" ) .arg ( एफपीएस ) .toAscii ());
ui-> label_speed-> setText (QString ("% 1" ) .arg ( actor1.getSpeed ( )) .toAscii ());
ui-> label_score-> setText (QString ("% 1" ) .arg ( स्कोर ) .toAscii ());
ui-> label_fired-> setText (QString ("% 1" ) .arg ( निकाल दिया गया ) .toAscii ());
ui-> label_hits-> setText (QString ("% 1" ) .arg ( हिट्स ) .toAscii ());
}

वास्तव में, बाकी तुच्छ प्रोग्रामिंग है। आवेदन कंकाल विच्छिन्न है, और कार्यान्वयन विवरण संलग्न स्रोत कोड में पाया जा सकता है। परिणामस्वरूप - मुझे जो मिला, उसकी उपस्थिति:

यहां के सूत्र हम तीर के साथ उड़ते हैं, एक स्थान के साथ शूट करते हैं।
गीथूब पर सूत्र ।

आकस्मिक यांत्रिकी

अनुप्रयोग चक्र

लूप को व्यवस्थित करने के संभावित तरीके

खेल स्ट्रीम

यह सब कैसे काम करता है

More articles: