आर्केड लाइब्रेरी के साथ पायथन में 2 डी गेम बनाएं

सभी को नमस्कार!

हम आपके साथ छोटे अजगर के बारे में दिलचस्प बातें साझा करना जारी रखते हैं। आज हमने 2 डी गेम से निपटने का फैसला किया। यह, निश्चित रूप से, हम अपने पायथन डेवलपर पाठ्यक्रम में जो कुछ है, उससे थोड़ा सरल है, लेकिन यह निश्चित रूप से कम दिलचस्प नहीं है।

अनुवाद
मूल लेख - opspot.com/article/18/4/easy-2d-game-creation-python-and-aradeade
पॉल विन्सेंट क्रेवन द्वारा पोस्ट किया गया

चलो चलते हैं।

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

मैंने विद्यार्थियों को PyGame लाइब्रेरी की मूल बातें सिखाने के बाद आर्केड पर विकास करना शुरू किया। मैं लगभग 10 वर्षों से PyGames in-person को सिखा रहा हूं, और ऑनलाइन सीखने के लिए ProgramArcadeGames.com भी विकसित किया है। PyGames महान है, लेकिन कुछ बिंदु पर मुझे एहसास हुआ कि मैं बग को ठीक करने वाले समय को बर्बाद करने से थक गया था जो कभी ठीक नहीं होगा ।

मैं इवेंट लूप जैसी चीजों को पढ़ाने के बारे में चिंतित था, जिनका उपयोग लगभग कभी नहीं किया गया था। और एक पूरा खंड था जिसमें मैंने बताया कि क्यों y- निर्देशांक विपरीत दिशा में घुमाए जाते हैं। PyGames शायद ही कभी अद्यतन किया गया था और OpenGL जैसी आधुनिक चीज़ों के बजाय पुराने SDL 1 लाइब्रेरी पर आधारित था। मैं एक उज्ज्वल भविष्य पर भरोसा नहीं करता था।

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

स्थापना

आर्केड, कई अन्य पैकेजों की तरह, PyPi पर उपलब्ध है, जिसका अर्थ है कि आप पाइप (या पिपेनव ) कमांड का उपयोग करके आर्केड स्थापित कर सकते हैं। यदि पायथन पहले से ही स्थापित है, तो सबसे अधिक संभावना है कि आप केवल विंडोज़ कमांड प्रॉम्प्ट खोल सकते हैं और लिख सकते हैं:

pip install arcade 

और लिनक्स और मैकओएस पर:

 pip3 install arcade 

अधिक विस्तृत इंस्टॉलेशन निर्देशों के लिए, आर्केड इंस्टॉलेशन प्रलेखन पढ़ें।

साधारण ड्राइंग

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



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

 import arcade #      SCREEN_WIDTH = 600 SCREEN_HEIGHT = 600 #  .      (  ) arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Drawing Example") #    . #      : # http://arcade.academy/arcade.color.html #      (, , )  # (, , , ) . arcade.set_background_color(arcade.color.WHITE) #   .       arcade.start_render() #   x = 300 y = 300 radius = 200 arcade.draw_circle_filled(x, y, radius, arcade.color.YELLOW) #    x = 370 y = 350 radius = 20 arcade.draw_circle_filled(x, y, radius, arcade.color.BLACK) #    x = 230 y = 350 radius = 20 arcade.draw_circle_filled(x, y, radius, arcade.color.BLACK) #   x = 300 y = 280 width = 120 height = 100 start_angle = 190 end_angle = 350 arcade.draw_arc_outline(x, y, width, height, arcade.color.BLACK, start_angle, end_angle, 10) #      arcade.finish_render() #      ,      “” arcade.run() 

क्रियाओं का उपयोग करना

बेशक, एक वैश्विक संदर्भ में कोड लिखना सबसे अच्छा तरीका नहीं है। सौभाग्य से, फ़ंक्शन का उपयोग करने से आपके कोड को बेहतर बनाने में मदद मिलेगी। नीचे दिए गए निर्देशांक (x, y) में फ़ंक्शन का उपयोग करके पेड़ को कैसे आकर्षित किया जाए, इसका एक उदाहरण है:

 def draw_pine_tree(x, y): """       """ #    . #   x, y    . arcade.draw_triangle_filled(x + 40, y, # Point 1 x, y - 100, # Point 2 x + 80, y - 100, # Point 3 arcade.color.DARK_GREEN) #   arcade.draw_lrtb_rectangle_filled(x + 30, x + 50, y - 100, y - 140, arcade.color.DARK_BROWN) 

एक पूर्ण उदाहरण के लिए, फ़ंक्शन के साथ ड्राइंग देखें।



अधिक अनुभवी प्रोग्रामर जानते हैं कि आधुनिक कार्यक्रम पहले वीडियो कार्ड में ग्राफिक जानकारी अपलोड करते हैं, और फिर इसे बैच फ़ाइल खींचने के लिए कहते हैं। आर्केड का समर्थन किया जाता है । 10,000 आयतों के व्यक्तिगत ड्राइंग में 0.8 सेकंड लगते हैं। एक बैच फ़ाइल के साथ समान राशि आकर्षित करने में 0.001 सेकंड से कम समय लगेगा।

खिड़की वर्ग

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

 import arcade SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 class MyGame(arcade.Window): """   . """ def __init__(self, width, height): super().__init__(width, height) arcade.set_background_color(arcade.color.AMAZON) def setup(self): #    pass def on_draw(self): """   . """ arcade.start_render() #    def update(self, delta_time): """       .""" pass def main(): game = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT) game.setup() arcade.run() if __name__ == "__main__": main() 

विंडो क्लास में कई विधियाँ हैं जिनसे आपके प्रोग्राम कार्यक्षमता प्रदान करने के लिए ओवरराइड कर सकते हैं। यहां उन लोगों की एक सूची दी गई है जो सबसे अधिक उपयोग किए जाते हैं:

• on_draw: स्क्रीन रेंडर करने के लिए सभी कोड यहाँ है।
• अद्यतन: ऑब्जेक्ट्स को स्थानांतरित करने और गेम लॉजिक के लिए सभी कोड यहां है। प्रति सेकंड लगभग 60 बार कॉल किया गया।
• on_key_press: जब बटन दबाया जाता है, तो घटनाओं को संभालता है, उदाहरण के लिए, एक चरित्र की गति।
• on_key_release: जब एक बटन छोड़ा जाता है, तो घटनाओं को संभालता है, जैसे कि किसी पात्र को रोकना।
• on_mouse_motion: हर बार माउस चलने पर कॉल किया जाता है।
• on_mouse_press: माउस बटन क्लिक करने पर कॉल किया जाता है।
• set_viewport: इस फ़ंक्शन का उपयोग स्क्रॉलर में किया जाता है जब दुनिया एक स्क्रीन पर दिखाई देने वाली तुलना में बहुत बड़ी होती है। कॉलिंग set_viewport प्रोग्रामर को स्क्रीन के उस हिस्से को निर्दिष्ट करने की अनुमति देता है जो दिखाई देगा।

स्प्राइट

स्प्राइट्स आर्केड में 2D बिटमैप फीचर बनाने का एक आसान तरीका है। इसमें ऐसी विधियाँ हैं जो इसे आकर्षित करना, स्थानांतरित करना और चेतन को आसान बनाती हैं। आप वस्तुओं के बीच टकराव को ट्रैक करने के लिए स्प्राइट्स का उपयोग भी कर सकते हैं।

स्प्रिट निर्माण

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

 SPRITE_SCALING_COIN = 0.2 coin = arcade.Sprite("coin_01.png", SPRITE_SCALING_COIN) 

यह कोड छवि का उपयोग कर एक प्रेत बनाता है। तस्वीर मूल के 20% तक कम हो जाएगी।

स्प्राइट सूची

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

 def setup(self): """     . """ #    self.player_list = arcade.SpriteList() self.coin_list = arcade.SpriteList() #  self.score = 0 #    #    kenney.nl self.player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING_PLAYER) self.player_sprite.center_x = 50 #   self.player_sprite.center_y = 50 self.player_list.append(self.player_sprite) #   for i in range(COIN_COUNT): #    #     kenney.nl coin = arcade.Sprite("images/coin_01.png", SPRITE_SCALING_COIN) #    coin.center_x = random.randrange(SCREEN_WIDTH) coin.center_y = random.randrange(SCREEN_HEIGHT) #     self.coin_list.append(coin) 

हम सिक्कों की सूची में सभी सिक्कों को आसानी से आकर्षित कर सकते हैं:

 def on_draw(self): """   """ arcade.start_render() self.coin_list.draw() self.player_list.draw() 

ट्रैक स्प्राइट टकराव

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

 def update(self, delta_time): #     ,    . coins_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list) #      ,     . for coin in coins_hit_list: coin.kill() self.score += 1 

एक पूरा उदाहरण collect_coins.py में पाया जा सकता है।

खेल भौतिकी

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

ऊपर से नीचे का खेल

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

 self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list) 

player_sprite को दो विशेषताओं change_x और change_y के साथ एक गति वेक्टर प्राप्त होता है। एक साधारण उपयोग मामला कीबोर्ड का उपयोग करके एक खिलाड़ी को स्थानांतरित कर रहा है।

 MOVEMENT_SPEED = 5 def on_key_press(self, key, modifiers): """    """ if key == arcade.key.UP: self.player_sprite.change_y = MOVEMENT_SPEED elif key == arcade.key.DOWN: self.player_sprite.change_y = -MOVEMENT_SPEED elif key == arcade.key.LEFT: self.player_sprite.change_x = -MOVEMENT_SPEED elif key == arcade.key.RIGHT: self.player_sprite.change_x = MOVEMENT_SPEED def on_key_release(self, key, modifiers): """,    """ if key == arcade.key.UP or key == arcade.key.DOWN: self.player_sprite.change_y = 0 elif key == arcade.key.LEFT or key == arcade.key.RIGHT: self.player_sprite.change_x = 0 

इस तथ्य के बावजूद कि यह कोड खिलाड़ी की गति निर्धारित करता है, वह इसे स्थानांतरित नहीं करता है। विंडो क्लास में अपडेट विधि Phys_engine.update () को कॉल करती है, जो खिलाड़ी को स्थानांतरित कर देगी, लेकिन दीवारों के माध्यम से नहीं।

 def update(self, delta_time): """     """ self.physics_engine.update() 

इसका पूरा उदाहरण sprite_move_walls.py में पाया जा सकता है।

प्लेटफ़ॉर्म

साइड व्यू के साथ प्लेटफ़ॉर्म गेम पर स्विच करना काफी सरल है। प्रोग्रामर को भौतिकी इंजन को PhysicsEnginePlatformer पर स्विच करने और गुरुत्वाकर्षण स्थिरांक को जोड़ने की आवश्यकता है।

 self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite, self.wall_list, gravity_constant=GRAVITY) 

उन टाइलों और ब्लॉकों को जोड़ने के लिए जो स्तर शामिल होंगे, आप टाइलेड जैसे प्रोग्राम का उपयोग कर सकते हैं।

एक उदाहरण sprite_tiled_map.py पर उपलब्ध है ।

एक उदाहरण से जानें

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

आर्केड स्थापित के साथ डेमो चलाना बिल्कुल मुश्किल नहीं है। प्रत्येक उदाहरण के लिए कार्यक्रम की शुरुआत में, कमांड के साथ एक टिप्पणी है कि आपको इस उदाहरण को चलाने के लिए कमांड लाइन पर प्रवेश करने की आवश्यकता है। उदाहरण के लिए:

 python -m arcade.examples.sprite_moving_platforms 

अंत

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