अपने पायगेम गेम्स में स्क्रॉलिंग कैमरा जोड़ें

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

PyGame में स्क्रॉलिंग कैमरे को लागू करने के कई अलग-अलग तरीके हैं, इसलिए सुनिश्चित करें कि आप उनके अंतरों को समझते हैं।

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

शुरू करने से पहले, अपने डिवाइस पर पिप स्थापित करें और PyGame मॉड्यूल को स्थापित करने के लिए निम्न आदेश का उपयोग करें:

पाइप स्थापित करें

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

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

pygame मॉड्यूल आयात करके प्रारंभ करें। फिर, इसे इनिशियलाइज़ करें, और गेम विंडो का उपयोग करके बनाएँ pygame.display.set_mode () समारोह। फिर, विंडो का कैप्शन सेट करें और फ्रेम दर को प्रबंधित करने के लिए क्लॉक ऑब्जेक्ट.

आयात pygame
pygame.init ()
WINDOW_WIDTH = 800
विन्डो_हाइट = 600
स्क्रीन = pygame.display.set_mode ((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("मेरा सरल खेल")
घड़ी = pygame.time. घड़ी()
पृष्ठभूमि_रंग = (255, 255, 255)

इसके बाद, प्लेयर और स्टेटिक प्लेटफॉर्म सेट करें। खिलाड़ी के आकार और उसकी प्रारंभिक स्थिति को परिभाषित करें।

PLAYER_WIDTH = 50
PLAYER_HEIGHT = 50
खिलाड़ी_x = WINDOW_WIDTH // 2 - PLAYER_WIDTH // 2
खिलाड़ी_y = WINDOW_HEIGHT - PLAYER_HEIGHT - 20
PLAYER_SPEED = 10
RECTANGLE_COLOR_1 = (255, 0, 0)
RECTANGLE_COLOR_2 = (0, 0, 255)
आयत_1 = पायगम. आयत(200, 200, 100, 100)
आयत_2 = पायगम. आयत(500, 300, 150, 50)

फिर, एक गेम लूप बनाएं जो इवेंट्स को हैंडल करता है और स्क्रीन को अपडेट करता है। लूप में, तीर कुंजियों का उपयोग करके खेल को छोड़ने या खिलाड़ी को स्थानांतरित करने जैसी घटनाओं की जाँच करें।

जबकिसत्य:
# घटनाओं को संभालें
के लिए आयोजन में pygame.event.get ():
अगर event.type == pygame. छोड़ना:
 pygame.quit ()
 छोड़ना()
# पृष्ठभूमि ड्रा करें
 स्क्रीन.फिल (BACKGROUND_COLOR)
# स्थैतिक आयतों को ड्रा करें
 pygame.draw.rect (स्क्रीन, RECTANGLE_COLOR_1, आयत_1)
 pygame.draw.rect (स्क्रीन, RECTANGLE_COLOR_2, आयत_2)
# खिलाड़ी को ड्रा करें
 प्लेयर_रेक्ट = पायगेम. आयत (खिलाड़ी_x, खिलाड़ी_य, PLAYER_WIDTH,
 PLAYER_HEIGHT)
 pygame.draw.rect (स्क्रीन, (0, 0, 0), खिलाड़ी_रेक्ट)
# डिस्प्ले अपडेट करें
 pygame.display.update ()
# फ्रेम दर सीमित करें
 घड़ी.टिक (30)

कैमरा सेट करना

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

कैमरा सेट अप करने के लिए, आपको सबसे पहले कैमरे के X ऑफ़सेट को होल्ड करने के लिए एक वेरिएबल परिभाषित करना होगा। इस चर को कॉल करें कैमरा_ऑफ़सेट_x और इसे 0 पर इनिशियलाइज़ करें।

# कैमरा ऑफ़सेट सेट करें
कैमरा_ऑफ़सेट_एक्स = 0

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

# खिलाड़ी को ड्रा करें
प्लेयर_रेक्ट = पायगेम. आयत (खिलाड़ी_x + कैमरा_ऑफ़सेट_x, खिलाड़ी_य, PLAYER_WIDTH,
 PLAYER_HEIGHT)
pygame.draw.rect (स्क्रीन, (0, 0, 0), खिलाड़ी_रेक्ट)

इसी तरह, आप स्थिर प्लेटफॉर्म की स्थिति को निम्नानुसार अपडेट कर सकते हैं:

# स्थैतिक आयतों को ड्रा करें
आयत_1_ड्रा_पोस = आयत_1.चाल (कैमरा_ऑफ़सेट_एक्स, 0)
pygame.draw.rect (स्क्रीन, RECTANGLE_COLOR_1, आयत_1_draw_pos)

आयत_2_ड्रा_पोस = आयत_2.चाल (कैमरा_ऑफ़सेट_एक्स, 0)
pygame.draw.rect (स्क्रीन, RECTANGLE_COLOR_2, आयत_2_draw_pos)

कीबोर्ड इनपुट के साथ कैमरे को मूव करना

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

ऐसा करने के लिए, कीबोर्ड इनपुट को हैंडल करने वाले ईवेंट लूप में निम्न कोड जोड़ें:

अगर event.type == pygame. चाबी नीचे:
अगर event.key == pygame. K_LEFT:
 कैमरा_ऑफ़सेट_एक्स -= PLAYER_SPEED
elif event.key == pygame. के_दाएं:
 कैमरा_ऑफ़सेट_x += PLAYER_SPEED

दूसरा तरीका यह है कि कीबोर्ड प्रेस पर खिलाड़ी के x निर्देशांक को बदल दिया जाए और फिर कैमरा ऑफ़सेट को अपडेट कर दिया जाए। आप इसे इस प्रकार कार्यान्वित कर सकते हैं:

# घटनाओं को संभालें
के लिए आयोजन में pygame.event.get ():
अगर event.type == pygame. छोड़ना:
 pygame.quit ()
 छोड़ना()
अगर event.type == pygame. चाबी नीचे:
अगर event.key == pygame. K_LEFT:
 खिलाड़ी_x - = PLAYER_SPEED
elif event.key == pygame. के_दाएं:
 खिलाड़ी_x += PLAYER_SPEED

फिर, आप खिलाड़ी के x निर्देशांक के संबंध में कैमरा ऑफ़सेट को निम्नानुसार अपडेट कर सकते हैं:

कैमरा_ऑफ़सेट_x = WINDOW_WIDTH // 2 - खिलाड़ी_x - PLAYER_WIDTH // 2

माउस इनपुट के साथ कैमरा चलाना

कैमरे को स्थानांतरित करने का दूसरा तरीका माउस का उपयोग करना है। आप माउस को क्लिक करके और खींचकर खिलाड़ी को स्क्रीन को इधर-उधर खींचने की अनुमति दे सकते हैं।

ऐसा करने के लिए, माउस की स्थिति को ट्रैक करें जब खिलाड़ी बाईं माउस बटन दबाता है। जब वे माउस को हिलाते हैं, तो प्लेयर के x निर्देशांक को अपडेट करें। यह वर्तमान माउस स्थिति और आपके द्वारा ट्रैक की गई प्रारंभिक स्थिति के बीच के अंतर से बदलना चाहिए, माउस_स्टार्ट_पोस.

# घटनाओं को संभालें
के लिए आयोजन में pygame.event.get ():
अगर event.type == pygame. छोड़ना:
 pygame.quit ()
 छोड़ना()
अगर event.type == pygame. माउसबटनडाउन:
अगर घटना बटन == 1:
 माउस_स्टार्ट_पोस = pygame.mouse.get_pos ()
अगर event.type == pygame. माउसमोशन:
अगर pygame.mouse.get_pressed () [0]:
 mouse_current_pos = pygame.mouse.get_pos ()
 माउस_ऑफ़सेट_एक्स = माउस_करंट_पोज़ [0] - माउस_स्टार्ट_पोस [0]
 प्लेयर_एक्स - = माउस_ऑफसेट_एक्स
 माउस_स्टार्ट_पोस = माउस_करंट_पोस

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

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

ऐसा करने के लिए, एक ज़ूम वेरिएबल परिभाषित करें जो गेम के वर्तमान ज़ूम स्तर को संग्रहीत करेगा। इसके प्रारंभिक मान को 1.0 पर सेट करें, जो बिना ज़ूम का प्रतिनिधित्व करता है। फिर, एक फ़ंक्शन परिभाषित करें जो वर्तमान ज़ूम स्तर के आधार पर किसी वस्तु के स्केल किए गए आकार की गणना करेगा।

जूम = 1.0
डीईएफ़get_scaled_size(आकार):
वापस करना int (आकार * ज़ूम)

अगला, का उपयोग करके स्क्रीन पर खींची गई वस्तुओं की स्थिति और आकार को अपडेट करें get_scaled_size समारोह। उदाहरण के लिए, आप खिलाड़ी की स्थिति और आकार को निम्नानुसार अपडेट कर सकते हैं:

प्लेयर_रेक्ट = पायगेम. आयत(
 get_scaled_size (खिलाड़ी_x + कैमरा_ऑफ़सेट_x),
 get_scaled_size (खिलाड़ी_y),
 get_scaled_size (PLAYER_WIDTH),
 get_scaled_size (PLAYER_HEIGHT)
)

इसी तरह, स्थिर प्लेटफॉर्म की स्थिति और आकार को निम्नानुसार अपडेट करें:

आयत_1_ड्रा_पोस = पायगम. आयत(
 get_scaled_size (आयत_1.x + कैमरा_ऑफ़सेट_x),
 get_scaled_size (आयत_1.y),
 get_scaled_size (आयत_1.चौड़ाई),
 get_scaled_size (आयत_1.ऊंचाई)
)
pygame.draw.rect (स्क्रीन, RECTANGLE_COLOR_1, आयत_1_draw_pos)
आयत_2_ड्रा_पोस = पायगम. आयत(
 get_scaled_size (आयत_2.x + कैमरा_ऑफ़सेट_x),
 get_scaled_size (आयत_2.y),
 get_scaled_size (आयत_2.चौड़ाई),
 get_scaled_size (आयत_2.ऊंचाई)
)
pygame.draw.rect (स्क्रीन, RECTANGLE_COLOR_2, आयत_2_draw_pos)

जब खिलाड़ी दबाता है तो जूम स्तर को 0.1 से बढ़ा या घटा सकते हैं = या - कुंजी, क्रमशः। वर्तमान ज़ूम स्तर के आधार पर गेम विंडो का नया आकार सेट करें। ऐसा करने के लिए, कीबोर्ड इनपुट को हैंडल करने वाले ईवेंट लूप में निम्न कोड जोड़ें:

अगर event.type == pygame. चाबी नीचे:
अगर event.key == pygame. K_EQUALS:
 ज़ूम + = 0.1
 स्क्रीन = pygame.display.set_mode ((
 int (WINDOW_WIDTH * ज़ूम),
 int (WINDOW_HEIGHT * ज़ूम)
 ))
elif event.key == pygame. के_मिनस:
 जूम -= 0.1
अगर जूम < 0.1:
 जूम = 0.1
 स्क्रीन = pygame.display.set_mode ((
 int (WINDOW_WIDTH * ज़ूम),
 int (WINDOW_HEIGHT * ज़ूम)
 ))

उपरोक्त कोड के साथ, आपने हमारे PyGame गेम में ज़ूमिंग कैमरा प्रभाव सफलतापूर्वक जोड़ा है। इस सुविधा को स्क्रॉलिंग कैमरा प्रभाव के साथ जोड़कर, आप एक गतिशील और आकर्षक गेम अनुभव बना सकते हैं।

कैमरा मूवमेंट के साथ गेमप्ले में सुधार

एक PyGame गेम में स्क्रॉलिंग कैमरा जोड़ने से न केवल दृश्य अनुभव में वृद्धि होती है बल्कि गेमप्ले में भी सुधार होता है। यह खिलाड़ी को खेल की दुनिया को और अधिक देखने की अनुमति देता है, जिससे उन्हें अपने परिवेश की बेहतर समझ मिलती है और नेविगेट करना आसान हो जाता है।

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