Pygame में एनिमेशन कैसे बनाएं

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

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

एक सरल गेम बनाएं

एक सरल गेम बनाकर शुरुआत करें जो खिलाड़ी को बाएँ और दाएँ घूमने की अनुमति देता है। आप गेम में एक प्लेटफ़ॉर्म भी जोड़ सकते हैं.

इस आलेख में प्रयुक्त कोड इसमें उपलब्ध है गिटहब रिपॉजिटरी और यह आपके लिए एमआईटी लाइसेंस के तहत उपयोग करने के लिए निःशुल्क है।

एक नई फ़ाइल बनाएँ Simple-game.py और खिलाड़ी और प्लेटफ़ॉर्म के लिए प्रारंभिक स्थिति और गति सहित कुछ चर परिभाषित करें। इन वेरिएबल्स का उपयोग प्लेयर के स्प्राइट की गति को नियंत्रित करने के लिए किया जाएगा।

उपयोग किए गए कीबोर्ड की स्थिति प्राप्त करके प्लेयर इनपुट को संभालें pygame.key.get_pressed(). यदि बायां तीर कुंजी दबाया जाता है, तो आप का मान कम कर सकते हैं प्लेयर_x, और यदि दायां तीर कुंजी दबाया जाता है, तो आप इसे बढ़ा सकते हैं। यह प्लेयर के स्प्राइट के लिए मूवमेंट प्रभाव पैदा करता है।

आपका प्रारंभिक गेम निम्नलिखित जैसा दिखना चाहिए:

फ़्रेम लोड करना और प्रदर्शित करना

एनिमेशन बनाने के लिए, विभिन्न छवियों को लोड करें और प्रदर्शित करें या एनीमेशन के फ्रेम. प्रत्येक फ्रेम एक विशिष्ट छवि या स्प्राइट का प्रतिनिधित्व करता है जिसे गति का भ्रम देने के लिए एक क्रम में प्रदर्शित किया जाएगा। आइए मान लें कि आपके पास तीन फ़्रेम हैं: फ़्रेम0, फ़्रेम1, और फ़्रेम2. प्रारंभ में, आप प्रदर्शित कर सकते हैं फ़्रेम0.

नामक एक नई फ़ाइल बनाएँ animate.py और नीचे दिए गए अपडेट के साथ कोड जोड़ें:

# फ़्रेम लोड करें
फ़्रेम0 = पायगेम. सतह((20, 20))
फ़्रेम0.भरण((255, 0, 0))
फ़्रेम1 = पायगेम. सतह((20, 20))
फ़्रेम1.फ़िल((0, 255, 0))
फ़्रेम2 = पायगेम. सतह((20, 20))
फ्रेम2.फिल((0, 0, 255))
# प्रारंभिक फ़्रेम सेट करें
वर्तमान_फ़्रेम = फ़्रेम0
# गेम लूप
जबकि दौड़ना:
# ...
# खेल प्रस्तुत करें
# ...
 स्क्रीन.ब्लिट (करंट_फ्रेम, (प्लेयर_एक्स, प्लेयर_वाई)) 
 pygame.display.flip()
# ...

प्लेयर इनपुट के साथ एनिमेशन को नियंत्रित करना

प्लेयर के स्प्राइट को एनिमेट करने के लिए, आप प्लेयर के इनपुट के आधार पर विभिन्न फ़्रेमों के बीच स्विच कर सकते हैं। उदाहरण के लिए, जब खिलाड़ी तीर कुंजियों का उपयोग करके बाईं या दाईं ओर जाता है, तो आप गति का भ्रम पैदा करने के लिए फ़्रेम के बीच पुनरावृति कर सकते हैं।

# गेम लूप
जबकि दौड़ना:
# ...
# प्लेयर इनपुट संभालें
 कुंजी = pygame.key.get_pressed()
अगर चाबियाँ[pygame. K_LEFT]:
 प्लेयर_एक्स - = प्लेयर_स्पीड
 वर्तमान_फ़्रेम = फ़्रेम1
एलिफ़ चाबियाँ[pygame. K_दाएं]:
 प्लेयर_एक्स += प्लेयर_स्पीड
 वर्तमान_फ़्रेम = फ़्रेम2
अन्य:
 वर्तमान_फ़्रेम = फ़्रेम0
# खेल प्रस्तुत करें
# ...
 स्क्रीन.ब्लिट (करंट_फ्रेम, (प्लेयर_एक्स, प्लेयर_वाई)) 
 pygame.display.flip()
# ...

नीचे आउटपुट है:

अतिरिक्त सुविधाओं सहित

बुनियादी एनीमेशन कार्यक्षमता के अलावा, Pygame आपके गेम विकास अनुभव को बढ़ाने के लिए कई अतिरिक्त सुविधाएँ प्रदान करता है।

स्प्राइट शीट्स

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

# स्प्राइट शीट छवि लोड करें
स्प्राइट_शीट = pygame.image.load("स्प्राइटशीट.पीएनजी")
# प्रत्येक फ़्रेम के आयाम परिभाषित करें
फ़्रेम_चौड़ाई = 32
फ़्रेम_ऊंचाई = 32
# स्प्राइट शीट से फ्रेम निकालने का कार्य
डीईएफ़निकालें_फ़्रेम(शीट, फ़्रेम_चौड़ाई, फ़्रेम_ऊंचाई):
फ़्रेम निकालने के लिए # कोड 
# स्प्राइट शीट से फ़्रेम निकालें
फ्रेम = एक्सट्रेक्ट_फ्रेम (स्प्राइट_शीट, फ्रेम_विड्थ, फ्रेम_हाइट)
# स्प्राइट शीट से एक फ्रेम प्रदर्शित करें
वर्तमान_फ़्रेम = फ़्रेम[0]
# गेम लूप
जबकि दौड़ना:
# ...
 स्क्रीन.ब्लिट (करंट_फ्रेम, (प्लेयर_एक्स, प्लेयर_वाई)) 
# ...

एनिमेशन गति

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

# एनीमेशन गति चर
एनीमेशन_देरी = 100# फ़्रेम अपडेट के बीच मिलीसेकंड में देरी
अंतिम_फ़्रेम_समय = pygame.time.get_ticks()
# गेम लूप
जबकि दौड़ना:
# ...
# जांचें कि फ़्रेम को अपडेट करने के लिए पर्याप्त समय बीत चुका है या नहीं
 current_time = pygame.time.get_ticks()
अगर वर्तमान_समय - अंतिम_फ़्रेम_समय >= एनीमेशन_देरी:
# फ़्रेम को अपडेट करें

# खेल प्रस्तुत करें
# ...
 स्क्रीन.ब्लिट (करंट_फ्रेम, (प्लेयर_एक्स, प्लेयर_वाई)) 
 pygame.display.flip()

टक्कर की पहचान हुई है

Pygame एनिमेटेड ऑब्जेक्ट्स के बीच इंटरैक्शन का पता लगाने के लिए टकराव का पता लगाने के फ़ंक्शन प्रदान करता है, जैसे यह पता लगाना कि खिलाड़ी किसी प्लेटफ़ॉर्म से कब टकराता है. अपने गेम में टकराव का पता लगाने को कैसे शामिल करें इसका एक उदाहरण यहां दिया गया है:

# टक्कर की पहचान हुई है
डीईएफ़check_collision(प्लेयर_रेक्ट, प्लेटफ़ॉर्म_रेक्ट):
अगर प्लेयर_रेक्ट.कोलाइडरेक्ट (प्लेटफॉर्म_रेक्ट):
# टक्कर हुई
वापस करनासत्य
अन्य:
वापस करनाअसत्य
# गेम लूप
जबकि दौड़ना:
# ...
# टकराव का पता लगाएं
 प्लेयर_रेक्ट = पायगेम. रेक्ट (प्लेयर_एक्स, प्लेयर_वाई, 20, 20)
 प्लेटफ़ॉर्म_रेक्ट = pygame. रेक्ट (platform_x, platform_y, 
 प्लेटफ़ॉर्म_चौड़ाई, प्लेटफ़ॉर्म_ऊंचाई)
अगर check_collision (प्लेयर_रेक्ट, प्लेटफ़ॉर्म_रेक्ट):
# टकराव को संभालें
# खेल प्रस्तुत करें
# ...
 स्क्रीन.ब्लिट (करंट_फ्रेम, (प्लेयर_एक्स, प्लेयर_वाई))
 pygame.display.flip()

इन अतिरिक्त सुविधाओं का उपयोग करके, आप अपनी गेम विकास क्षमताओं का विस्तार कर सकते हैं और अधिक गतिशील और इमर्सिव गेमिंग अनुभव बना सकते हैं। विभिन्न तकनीकों के साथ प्रयोग करें, उन्हें रचनात्मक रूप से संयोजित करें, और अपनी कल्पना को वास्तव में आकर्षक गेम बनाने में आपका मार्गदर्शन करने दें।

Pygame में एनीमेशन बनाने के लिए सर्वोत्तम अभ्यास

अपने Pygame प्रोजेक्ट्स में एनीमेशन जोड़ते समय, अपने कार्यान्वयन को अनुकूलित करने और सुचारू और कुशल एनिमेशन सुनिश्चित करने के लिए कुछ सर्वोत्तम प्रथाओं का पालन करना महत्वपूर्ण है। निम्नलिखित दिशानिर्देशों पर विचार करें:

फ़्रेम को मेमोरी में प्रीलोड और स्टोर करें

गेम लूप के दौरान डिस्क से छवियां लोड करने में देरी हो सकती है और प्रदर्शन प्रभावित हो सकता है। इससे बचने के लिए, गेम लूप शुरू होने से पहले अपने फ़्रेम को प्रीलोड करें और उन्हें मेमोरी में स्टोर करें। इस तरह, आप बिना किसी डिस्क I/O ओवरहेड के रनटाइम के दौरान फ़्रेम तक तुरंत पहुंच और प्रदर्शित कर सकते हैं।

पायगेम की अंतर्निहित स्प्राइट और एनिमेशन कक्षाओं का उपयोग करें

Pygame जैसी अंतर्निहित कक्षाएं प्रदान करता है pygame.sprite. प्रेत और pygame.sprite. समूह जो स्प्राइट और एनिमेशन के प्रबंधन को सरल बनाता है। इन कक्षाओं का उपयोग करके, आप टकराव का पता लगाने, समूह अद्यतन और अधिक कुशलता से प्रतिपादन कर सकते हैं।

छवि प्रारूप अनुकूलित करें

बेहतर प्रदर्शन के लिए अपने छवि प्रारूपों को अनुकूलित करने पर विचार करें। Pygame PNG और JPEG सहित विभिन्न छवि प्रारूपों का समर्थन करता है। पीएनजी को आम तौर पर पारदर्शिता वाली छवियों के लिए अनुशंसित किया जाता है, जबकि जेपीईजी पारदर्शिता के बिना स्थिर छवियों के लिए उपयुक्त है।

छवि गुणवत्ता और फ़ाइल आकार के बीच इष्टतम संतुलन खोजने के लिए विभिन्न छवि प्रारूपों और संपीड़न स्तरों के साथ प्रयोग करें।

उचित फ़्रेम दर का उपयोग करें

सहज एनिमेशन प्राप्त करने के लिए, उचित फ्रेम दर निर्धारित करना महत्वपूर्ण है। Pygame प्रदान करता है pygame.time. घड़ी क्लास, जो गेम लूप की गति को नियंत्रित करके फ्रेम दर को नियंत्रित करने में मदद करता है।

कॉल करके सही का निशान लगाना() प्रत्येक पुनरावृत्ति के अंत में क्लॉक ऑब्जेक्ट की विधि, आप एक सुसंगत फ्रेम दर बनाए रख सकते हैं। अपने एनिमेशन की जटिलता और अपने लक्ष्य प्लेटफ़ॉर्म की प्रदर्शन क्षमताओं के आधार पर फ़्रेम दर को समायोजित करें।

इन सर्वोत्तम प्रथाओं का पालन करके, आप अपने एनीमेशन कार्यान्वयन को अनुकूलित कर सकते हैं, अपने गेम के प्रदर्शन में सुधार कर सकते हैं और अपने खिलाड़ियों के लिए दृश्यमान रूप से आकर्षक और आकर्षक अनुभव बना सकते हैं।

एनिमेशन के साथ गेम्स को और अधिक मज़ेदार बनाएं

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

Pygame की एनीमेशन क्षमताओं का लाभ उठाकर, आप अपने खिलाड़ियों को मोहित कर सकते हैं और ऐसे गेम बना सकते हैं जो एक स्थायी प्रभाव छोड़ते हैं।