कैसे PyGame का उपयोग करके दुश्मनों को अलग-अलग तरीकों से स्थानांतरित करें

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

PyGame में, आप आसानी से विभिन्न प्रकार के दुश्मन आंदोलन व्यवहारों को प्रोग्राम कर सकते हैं, जैसे कि खिलाड़ी का अनुसरण करना, यादृच्छिक रूप से आगे बढ़ना, या विशिष्ट पथ लेना।

एक साधारण खेल बनाना

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

आप इसमें पूरा कोड पा सकते हैं गिटहब रेपो.

आवश्यक PyGame मॉड्यूल को आयात करके और इसे प्रारंभ करके प्रारंभ करें।

आयात pygame
pygame.init ()

इसके बाद, स्क्रीन सेट करें और pygame. आयत () समारोह।

# स्क्रीन सेट करें
स्क्रीन = pygame.display.set_mode ((800, 600))
# रंग सेट करें
काला = (0, 0, 0)
सफेद = (255, 255, 255)
# खिलाड़ी आयत और शत्रु वस्तु को सेट करें
प्लेयर = पायगम. आयत(350, 500, 50, 50)
शत्रु = पायगम. आयत(350, 0, 50, 50)

उसके बाद, एक गेम लूप बनाएं जो तब तक चलता है जब तक कि खिलाड़ी या तो दुश्मन से टकरा न जाए या गेम से बाहर न निकल जाए। साथ ही, के लिए जाँच करें खिलाड़ी और दुश्मन के बीच टक्कर, और स्क्रीन पर गेम ऑब्जेक्ट्स को ड्रा करें।

# गेम लूप सेट करें
चल रहा है = सत्य
जबकि दौड़ना:
के लिए आयोजन में pygame.event.get ():
अगर event.type == pygame. छोड़ना:
 चल रहा है = असत्य
# स्क्रीन को सफेद रंग से भरें
 स्क्रीन.फिल (सफेद)
# खिलाड़ी को आयत में ले जाएँ
 कुंजी = pygame.key.get_pressed ()
अगर कुंजियाँ [pygame. K_LEFT]:
 प्लेयर.एक्स - = 5
अगर कुंजियाँ [pygame. के_राइट]:
 प्लेयर.एक्स += 5
अगर कुंजियाँ [pygame. के_यूपी]: 
 खिलाड़ी.वाई -= 5
अगर कुंजियाँ [pygame. के_डाउन]: 
 खिलाड़ी.वाई += 5
# खिलाड़ी और दुश्मन के बीच टकराव की जाँच करें
अगर प्लेयर.कोलाइडरेक्ट (दुश्मन):
 चल रहा है = असत्य
# स्क्रीन पर खिलाड़ी की आयत और दुश्मन की वस्तु को ड्रा करें
 pygame.draw.rect (स्क्रीन, ब्लैक, प्लेयर)
 pygame.draw.rect (स्क्रीन, काला, दुश्मन)
# स्क्रीन को अपडेट करें
 pygame.display.update ()
#खेल छोड़ो
pygame.quit ()

सीधे दुश्मन खिलाड़ी की ओर

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

इसे लागू करने के लिए, एक गति चर बनाएं और इसका उपयोग खिलाड़ी की ओर दुश्मन की स्थिति को अपडेट करने के लिए करें।

# दुश्मन और खिलाड़ी के बीच की दूरी की गणना करें
दूरी_x = खिलाड़ी.एक्स - दुश्मन.एक्स
दूरी_y = खिलाड़ी.वाई - दुश्मन.वाई
दूरी = (दूरी_x ** 2 + दूरी_y ** 2) ** 0.5
# दुश्मन को खिलाड़ी की ओर ले जाएं
गति = 2
अगर दूरी! = 0:
 शत्रु.x += गति * दूरी_x / दूरी
 शत्रु.वाई + = गति * दूरी_वाई / दूरी

स्क्रीन पर दुश्मन की हरकत को रैंडमाइज करें

आप खेल को और अधिक चुनौतीपूर्ण बनाने के लिए स्क्रीन पर दुश्मन को बेतरतीब ढंग से ले जाने के लिए भी कह सकते हैं।

ऐसा करने के लिए, पायथन में यादृच्छिक मॉड्यूल का उपयोग करके दुश्मन को स्थानांतरित करने के लिए एक यादृच्छिक दिशा उत्पन्न करें। उपयोग पसंद() उन दिशाओं की सूची से एक यादृच्छिक दिशा का चयन करने के लिए कार्य करता है जिसमें दुश्मन आगे बढ़ सकता है। फिर चुनी हुई दिशा के आधार पर दुश्मन की स्थिति को अपडेट करें।

आयात अनियमित
# स्क्रीन पर दुश्मन को बेतरतीब ढंग से घुमाएं
दिशा = यादृच्छिक। पसंद (['बाएं', 'सही', 'ऊपर', 'नीचे'])
अगर दिशा == 'बाएं':
 शत्रु.x -= 5
elif दिशा == 'सही':
 शत्रु .x += 5
elif दिशा == 'ऊपर':
 शत्रु.वाई - = 5
elif दिशा == 'नीचे':
 शत्रु.वाई += 5

निकटता-आधारित शत्रु आंदोलन

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

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

# खिलाड़ी के करीब होने पर दुश्मन को खिलाड़ी की ओर ले जाएं
गति = 2
अगर दूरी < 300:
अगर दूरी! = 0:
 शत्रु.x += गति * दूरी_x / दूरी
 शत्रु.वाई + = गति * दूरी_वाई / दूरी

शत्रु खिलाड़ी के आक्रमण से बचता है

आप खिलाड़ी की चाल से दुश्मन को चकमा भी दे सकते हैं। दुश्मन खिलाड़ी की स्थिति के लंबवत चलते हुए खिलाड़ी से बचने की कोशिश करेगा।

इसे प्राप्त करने के लिए, पहले की गणना की गई दूरी_x और दूरी_y का उपयोग करके खिलाड़ी की ओर इकाई वेक्टर की गणना करें। फिर, इकाई वेक्टर के लंबवत दुश्मन को स्थानांतरित करने के लिए लंबवत वेक्टर की गणना करें। अंत में, दुश्मन के आंदोलन की दिशा निर्धारित करने के लिए लंबवत वेक्टर और यूनिट वेक्टर के डॉट उत्पाद की गणना करें।

इसे लागू करने के लिए, दूरी की गणना के बाद नीचे कोड स्निपेट जोड़ें।

गति = 2
अगर दूरी < 400:
अगर दूरी! = 0:
# प्लेयर की ओर यूनिट वेक्टर की गणना करें
 यूनिट_वेक्टर_एक्स = दूरी_एक्स / दूरी
 Unit_vector_y = दूरी_y / दूरी
# लंबवत वेक्टर की गणना करें
 लंबवत_वेक्टर_एक्स = -यूनिट_वेक्टर_वाई
 लंबवत_वेक्टर_वाई = इकाई_वेक्टर_एक्स
# लंबवत वेक्टर के डॉट उत्पाद की गणना करें और
# इकाई वेक्टर
 डॉट_प्रोडक्ट = लंबवत_वेक्टर_एक्स * यूनिट_वेक्टर_एक्स
 + लंबवत_वेक्टर_वाई * यूनिट_वेक्टर_वाई
# यूनिट वेक्टर के लिए दुश्मन को सीधा ले जाएं
अगर dot_product > 0:
 शत्रु.x += गति * लंबवत_वेक्टर_x
 शत्रु.वाई += गति * लंबवत_वेक्टर_वाई
अन्य:
 शत्रु.x -= गति * सीधा_वेक्टर_x
 शत्रु.वाई = गति * लंबवत_वेक्टर_वाई

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

अतिरिक्त सुविधाएँ जोड़ना

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

तुम कर सकते हो फ्रेम दर सेट करने के लिए क्लॉक मॉड्यूल का उपयोग करें अपने खेल के और इसे और अधिक सुचारू रूप से चलाने के लिए। नीचे कार्यान्वयन है:

# कई दुश्मन जोड़ें जो स्क्रीन पर बेतरतीब ढंग से चलते हैं
शत्रु = []
के लिए मैं में श्रेणी(5):
 शत्रु = पायगम. रेक्ट (रैंडम.रैंडिंट (0, 750), रैंडम.रैंडिंट (0, 550), 50,
50)
 दुश्मन। संलग्न (दुश्मन)
# उन बाधाओं को जोड़ें जिनसे खिलाड़ी को बचना है
बाधा = पायगम. आयत(200, 250, 50, 50)
# गेम लूप सेट करें
घड़ी = pygame.time. घड़ी()
चल रहा है = सत्य
जबकि दौड़ना:
के लिए आयोजन में pygame.event.get ():
अगर event.type == pygame. छोड़ना:
 चल रहा है = असत्य
# स्क्रीन को सफेद रंग से भरें
 स्क्रीन.फिल (सफेद)
# खिलाड़ी को आयत में ले जाएँ
 कुंजी = pygame.key.get_pressed ()
अगर कुंजियाँ [pygame. K_LEFT]:
 प्लेयर.एक्स - = 5
अगर कुंजियाँ [pygame. के_राइट]:
 प्लेयर.एक्स += 5
अगर कुंजियाँ [pygame. के_यूपी]:
 खिलाड़ी.वाई -= 5
अगर कुंजियाँ [pygame. के_डाउन]:
 खिलाड़ी.वाई += 5
# दुश्मनों को स्क्रीन पर बेतरतीब ढंग से ले जाएं
के लिए दुश्मन में दुश्मन:
 दिशा = यादृच्छिक। पसंद (['बाएं', 'सही', 'ऊपर', 'नीचे'])
अगर दिशा == 'बाएं':
 शत्रु.x -= 5
elif दिशा == 'सही':
 शत्रु .x += 5
elif दिशा == 'ऊपर':
 शत्रु.वाई - = 5
elif दिशा == 'नीचे':
 शत्रु.वाई += 5
# खिलाड़ी और दुश्मन के बीच टकराव की जाँच करें
अगर प्लेयर.कोलाइडरेक्ट (दुश्मन):
 चल रहा है = असत्य
# खिलाड़ी आयत, दुश्मन वस्तुओं और बाधा को ड्रा करें
# पर्दा डालना
 pygame.draw.rect (स्क्रीन, ब्लैक, प्लेयर)
के लिए दुश्मन में दुश्मन:
 pygame.draw.rect (स्क्रीन, काला, दुश्मन)
 pygame.draw.rect (स्क्रीन, काला, बाधा)
# स्क्रीन को अपडेट करें
 pygame.display.update ()
# गेम का फ्रेम रेट सेट करें
 घड़ी.टिक (60)
#खेल छोड़ो
pygame.quit ()

दुश्मनों के साथ अपने गेमिंग अनुभव को बेहतर बनाएं

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