👨🏻‍🚒 👸 ⤵️ bear_hug: PyCon3.6 + में ASCII कला में खेल 🧓🏾 👌🏻 🍹

ASCII कला में अपने खेल के लिए, मैंने एक घटना कतार, विगेट्स का संग्रह, ईसीएस समर्थन और अन्य उपयोगी छोटी चीजों के साथ भालू_ हग लाइब्रेरी लिखी। इस लेख में हम देखेंगे कि इसका उपयोग न्यूनतम काम करने के खेल के लिए कैसे किया जाता है।

त्याग

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

Bear_hug के हुड के तहत, एक छद्म-कंसोल विंडो बनाने के लिए एक SDL लाइब्रेरी है, जो bearlibterminal है। अर्थात्, शुद्ध TTY में, कुछ ncurses की तरह, यह काम नहीं करेगा। लेकिन फिर चित्र विंडोज पर लिनक्स पर समान है, और उपयोगकर्ता टर्मिनल की सेटिंग्स पर निर्भर नहीं करता है। यह विशेष रूप से खेल के लिए महत्वपूर्ण है, क्योंकि जब आप फ़ॉन्ट ASCII- कला को बदलते हैं, तो भगवान अच्छी तरह से बदल सकते हैं:

अपने मूल रूप में एक ही ड्राइंग और विभिन्न कार्यक्रमों के लिए कॉपी-पेस्ट के बाद

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

एक गेमओवर होगा, लेकिन कोई जीत नहीं होगी। क्योंकि जीवन पीड़ा है।

लेख में उपयोग की जाने वाली सभी सामग्री गीथब पर है ; पुस्तकालय भी PyPI (MIT लाइसेंस के तहत) पर है।

सबसे पहले, हमें संपत्ति चाहिए। ASCII कला को आकर्षित करने के लिए, मैं विज्ञान गल्प बैगेल कोगमिंड के विकासकर्ता, जोश जी (उर्फ़ कज़राती) से REXpaint का उपयोग करता हूं । संपादक स्वतंत्र है, हालांकि खुला स्रोत नहीं है; आधिकारिक संस्करण केवल विंडोज के लिए है, लेकिन सब कुछ शराब के तहत ठीक काम करता है। इंटरफ़ेस काफी स्पष्ट और सुविधाजनक है:

हम स्थानीय बाइनरी प्रारूप में सहेजें। भविष्य के गेम के साथ फ़ोल्डर में /path/to/rexpaint/images को कॉपी करें। सिद्धांत रूप में, .txt फ़ाइलों से छवियों को लोड करना भी समर्थित है, लेकिन पाठ फ़ाइल में व्यक्तिगत वर्णों के रंगों को सहेजना स्पष्ट रूप से असंभव है। हां, और नोटबुक में ASCII कला का संपादन मेरे लिए व्यक्तिगत रूप से सुविधाजनक नहीं है। प्रत्येक तत्व के निर्देशांक और आकार को हार्डकोड नहीं करने के लिए, यह डेटा एक अलग JSON फ़ाइल में संग्रहीत है:

battlecity.json

 [ { "name": "player_r", "x": 1, "y": 2, "xsize": 6, "ysize": 6 }, { "name": "player_l", "x": 1, "y": 8, "xsize": 6, "ysize": 6 }, ... ]

इंटरनेट से मुफ्त लाइसेंस डाउनलोड के तहत लगता है। अब तक, केवल .wav समर्थित है। यह सब संपत्ति के साथ है, आप कोडिंग शुरू कर सकते हैं। सबसे पहले, आपको टर्मिनल और इवेंट कतार को इनिशियलाइज़ करने की आवश्यकता है।

game.py

 #  terminal = BearTerminal(font_path='cp437_12x12.png', size='91x60', title='AsciiCity', filter=['keyboard', 'mouse']) #   dispatcher = BearEventDispatcher() # ,         loop = BearLoop(terminal, dispatcher)

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

ईवेंट कतार के लिए, इसका एक बहुत ही सरल इंटरफ़ेस है: dispatcher.add_event (ईवेंट) कतार में ईवेंट जोड़ता है, और dispatcher.register_listener (श्रोता, ईवेंट_टाइप्स) आपको इसकी सदस्यता लेने की अनुमति देता है। एक हस्ताक्षरकर्ता (उदाहरण के लिए, एक विजेट या घटक) के पास एक on_event कॉलबैक होना चाहिए, जो किसी घटना को एक एकल तर्क के रूप में लेता है और या तो कुछ भी नहीं देता है या किसी अन्य घटना या घटनाओं का सेट लौटाता है। घटना में स्वयं प्रकार और मूल्य शामिल हैं; यहाँ प्रकार str या int के अर्थ में नहीं है, बल्कि "विविधता" के अर्थ में है, उदाहरण के लिए, 'key_down' या 'tick'। कतार इसे ज्ञात प्रकारों की केवल घटनाओं को स्वीकार करती है (अंतर्निहित या उपयोगकर्ता द्वारा बनाई गई) और उन्हें उन सभी लोगों को भेजती है जो इस प्रकार की सदस्यता लेते हैं। यह किसी भी तरह से मूल्यों की जांच नहीं करता है, लेकिन प्रत्येक प्रकार के आयोजन के लिए एक मान्य मूल्य क्या है, इसके बारे में पुस्तकालय के भीतर कन्वेंशन हैं।

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

श्रोता

 #       dispatcher.register_listener(ClosingListener(), ['misc_input', 'tick']) #       dispatcher.register_listener(EntityTracker(), ['ecs_create', 'ecs_destroy']) #   jukebox = SoundListener({'shot': 'shot.wav', 'explosion': 'explosion.wav'}) # https://freesound.org/people/EMSIarma/sounds/108852/ # https://freesound.org/people/FlashTrauma/sounds/398283/ dispatcher.register_listener(jukebox, 'play_sound')

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

इवेंट प्रकार पंजीकरण

 #      ,    #   dispatcher.register_event_type('ac_damage') #       logger = LoggingListener(sys.stderr) dispatcher.register_listener(logger, ['ac_damage', 'play_sound'])

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

अभी के लिए श्रोताओं के साथ, आप पहला विजेट जोड़ सकते हैं। हमारे पास यह ECSLayout क्लास प्लेइंग फील्ड है। यह एक ऐसा लेआउट है, जो ईकस_मूव इवेंट्स के जवाब में संस्थाओं पर विगेट्स लगा सकता है और उन्हें स्थानांतरित कर सकता है, और साथ ही साथ टकरावों पर विचार करता है। अधिकांश विगेट्स की तरह, इसमें दो आवश्यक तर्क हैं: वर्णों की एक नेस्टेड सूची (संभवतः खाली - स्थान या कोई नहीं) और प्रत्येक वर्ण के लिए रंगों की एक नेस्टेड सूची। नामित रंगों को रंगों के रूप में स्वीकार किया जाता है, प्रारूप में आरजीबी `0xAARRGGBB` (या` 0xARGB`, `0xRGB`,` 0xRRGGBB`) और प्रारूप '#fff' में। दोनों सूचियों के आकार का मिलान होना चाहिए; अन्यथा, एक अपवाद फेंक दिया जाता है।

पहला विजेट

 #   .  8460,   9160. # 7         chars = [[' ' for x in range(84)] for y in range(60)] colors = copy_shape(chars, 'gray') layout = ECSLayout(chars, colors) # 'all' -  ,      dispatcher.register_listener(layout, 'all')

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

entities.py

 def create_wall(dispatcher, atlas, entity_id, x, y): #   wall = Entity(entity_id) #  wall.add_component(PositionComponent(dispatcher, x, y)) wall.add_component(CollisionComponent(dispatcher)) wall.add_component(PassingComponent(dispatcher)) wall.add_component(DestructorComponent(dispatcher)) #     ,      #    -  /   images_dict = {'wall_3': atlas.get_element('wall_3'), 'wall_2': atlas.get_element('wall_2'), 'wall_1': atlas.get_element('wall_1')} wall.add_component(SwitchWidgetComponent(dispatcher, SwitchingWidget(images_dict=images_dict, initial_image='wall_3'))) wall.add_component(VisualDamageHealthComponent(dispatcher, hitpoints=3, widgets_dict={3: 'wall_3', 2: 'wall_2', 1: 'wall_1'})) #     dispatcher.add_event(BearEvent('ecs_create', wall)) dispatcher.add_event(BearEvent('ecs_add', (wall.id, wall.position.x, wall.position.y)))

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

गैर-निर्मित घटकों में से केवल स्वास्थ्य है। मैंने आधार घटक "स्वास्थ्य घटक" बनाया और विरासत में मिला "स्वास्थ्य घटक बदलने वाला विजेट" (दीवार को अक्षुण्ण और विनाश के कई चरणों में दिखाने के लिए)।

क्लास हेल्थकंपोनेंट

 class HealthComponent(Component): def __init__(self, *args, hitpoints=3, **kwargs): super().__init__(*args, name='health', **kwargs) self.dispatcher.register_listener(self, 'ac_damage') self._hitpoints = hitpoints def on_event(self, event): if event.event_type == 'ac_damage' and event.event_value[0] == self.owner.id: self.hitpoints -= event.event_value[1] @property def hitpoints(self): return self._hitpoints @hitpoints.setter def hitpoints(self, value): if not isinstance(value, int): raise BearECSException( f'Attempting to set hitpoints of {self.owner.id} to non-integer {value}') self._hitpoints = value if self._hitpoints < 0: self._hitpoints = 0 self.process_hitpoint_update() def process_hitpoint_update(self): """ Should be overridden by child classes. """ raise NotImplementedError('HP update processing should be overridden') def __repr__(self): #           return dumps({'class': self.__class__.__name__, 'hitpoints': self.hitpoints})

एक घटक बनाते समय, 'नाम' कुंजी सुपर () .__ init__ को पास कर दी जाती है। जब एक घटक को एक इकाई में जोड़ा जाता है, तो इस कुंजी के नाम के तहत इसे इकाई के __dict__ में जोड़ा जाएगा और इसे Unit_object.health के माध्यम से एक्सेस किया जा सकता है। इंटरफ़ेस की सुविधा के अलावा, यह दृष्टिकोण अच्छा है क्योंकि यह कई सजातीय घटकों की संस्थाओं को जारी करने पर रोक लगाता है। और यह तथ्य कि यह घटक के अंदर हार्डकोड है, आपको गलती से डालने की अनुमति नहीं देता है, उदाहरण के लिए, स्वास्थ्य घटक के स्लॉट में WidgetComponent। निर्माण के तुरंत बाद, घटक इस मामले में ब्याज की घटना वर्गों की सदस्यता लेता है, इस मामले में ac_damage। इस तरह की घटना प्राप्त होने के बाद, on_event विधि यह जांच करेगी कि क्या यह एक घंटे के लिए इसके मालिक के बारे में है। यदि ऐसा है, तो वह हिट बिंदुओं से वांछित मूल्य को घटाएगा और स्वास्थ्य को बदलने के लिए कॉलबैक को खींचेगा, बेस क्लास सार है। __Repr__ विधि भी है, जिसका उपयोग JSON में क्रमांकन के लिए किया जाता है (उदाहरण के लिए, बचत के लिए)। इसे जोड़ना आवश्यक नहीं है, लेकिन सभी अंतर्निहित घटकों और अधिकांश अंतर्निहित विजेट में यह है।

VisualDamageHealthComponent के अंतर्निहित स्वास्थ्य घटक से इनहेरिट करना स्वास्थ्य परिवर्तन पर कॉलबैक को ओवरराइड करता है:

क्लास विजुअलडैमेजहेल्थकॉप्टेंट

 class VisualDamageHealthComponent(HealthComponent): """       .    HP=0 """ def __init__(self, *args, widgets_dict={}, **kwargs): super().__init__(*args, **kwargs) self.widgets_dict = OrderedDict() for x in sorted(widgets_dict.keys()): self.widgets_dict[int(x)] = widgets_dict[x] def process_hitpoint_update(self): if self.hitpoints == 0 and hasattr(self.owner, 'destructor'): self.owner.destructor.destroy() for x in self.widgets_dict: if self.hitpoints >= x: self.owner.widget.switch_to_image(self.widgets_dict[x])

जबकि स्वास्थ्य 0 से ऊपर है, वह विजेट को वांछित स्थिति में दीवार खींचने के लिए जिम्मेदार घटक पूछता है। यहां, ऊपर वर्णित कॉल का उपयोग इकाई वस्तु की विशेषता के माध्यम से किया जाता है। हिटपॉइंट खत्म होने के बाद, इकाई के सही विनाश के लिए जिम्मेदार घटक और सभी घटकों को उसी तरह से बुलाया जाएगा।

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

बुलेट कंपोनेंट कोलाइडर

 def collided_into(self, entity): if not entity: self.owner.destructor.destroy() elif hasattr(EntityTracker().entities[entity], 'collision'): self.dispatcher.add_event(BearEvent(event_type='ac_damage', event_value=( entity, self.damage))) self.owner.destructor.destroy()

यह सुनिश्चित करने के लिए कि शिकार प्राप्त करना वास्तव में संभव है (उदाहरण के लिए, पृष्ठभूमि तत्वों के लिए गलत हो सकता है), प्रक्षेप्य EntityTracker () का उपयोग करता है। यह एक सिंगलटन है जो सभी निर्मित और नष्ट किए गए संस्थाओं को ट्रैक करता है; इसके माध्यम से, आप नाम से एक इकाई वस्तु प्राप्त कर सकते हैं और इसके घटकों के साथ कुछ कर सकते हैं। इस स्थिति में, यह सत्यापित किया जाता है कि Unit.collision (पीड़ित टक्कर हैंडलर) बिल्कुल मौजूद है।

अब खेल की मुख्य फ़ाइल में, हम बस संस्थाओं को बनाने के लिए सभी आवश्यक कार्य कहते हैं:

वापस गेमहोम में

 #  , -     atlas = Atlas(XpLoader('battlecity.xp'), 'battlecity.json') #   create_player_tank(dispatcher, atlas, 30, 50) #    wall_array = [[0 for _ in range(14)], [0 for _ in range(14)], [1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0], [1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1], [1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0], [0 for _ in range(14)], [0 for _ in range(14)], [0 for _ in range(14)] ] for y in range(10): for x in range(14): if wall_array[y][x] == 1: create_wall(dispatcher, atlas, f'wall{x}{y}', x*6, y*6) #   -  .     . create_spawner_house(dispatcher, atlas, 35, 0)

प्वाइंट और हिट प्वाइंट काउंटर इकाइयां नहीं हैं और युद्ध के मैदान में नहीं हैं। इसलिए, उन्हें ECSLayout में नहीं जोड़ा जाता है, लेकिन नक्शे के दाईं ओर सीधे टर्मिनल में। प्रासंगिक विगेट्स लेबल (पाठ आउटपुट विजेट) से प्राप्त होते हैं और उनके हितों का पता लगाने के लिए एक on_event विधि है। लेआउट के विपरीत, टर्मिनल स्वचालित रूप से हर टिक को विजेट अपडेट नहीं करता है, इसलिए पाठ को बदलने के बाद, विजेट उसे ऐसा करने के लिए कहते हैं:

listeners.py

 class ScoreLabel(Label): """   """ def __init__(self, *args, **kwargs): super().__init__(text='Score:\n0') self.score = 0 def on_event(self, event): if event.event_type == 'ecs_destroy' and 'enemy' in event.event_value and 'bullet' not in event.event_value: #    self.score += 10 self.text = f'Score:\n{self.score}' self.terminal.update_widget(self) class HPLabel(Label): """   """ def __init__(self, *args, **kwargs): super().__init__(text='HP:\n5') self.hp = 5 def on_event(self, event): if event.event_type == 'ac_damage' and event.event_value[0] == 'player': self.hp -= event.event_value[1] self.text = f'HP:\n{self.hp}' self.terminal.update_widget(self)

दुश्मन जनरेटर और "GAME OVER" के उत्पादन के लिए जिम्मेदार वस्तु बिल्कुल भी प्रदर्शित नहीं होती है, इसलिए वे श्रोता से विरासत में मिलते हैं। सिद्धांत समान है: ऑब्जेक्ट कतार में सुनते हैं, सही क्षण की प्रतीक्षा करते हैं, और फिर एक इकाई या विजेट बनाते हैं।

geymover

 #    - . . . class GameOverListener(Listener): """       """ def __init__(self, *args, widget=None, **kwargs): print (args) super().__init__(*args, *kwargs) self.widget = widget def on_event(self, event): if event.event_type == 'ecs_destroy' and event.event_value == 'player': self.terminal.add_widget(self.widget, pos=(20, 20), layer=5)

अब हमने अपनी जरूरत की हर चीज बनाई है, और हम खेल शुरू कर सकते हैं।

हम लॉन्च करते हैं

 #      ,   Listeners    terminal.start() terminal.add_widget(layout) terminal.add_widget(score, pos=(85, 10)) terminal.add_widget(hp, pos=(85, 15))

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

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

bear_hug: PyCon3.6 + में ASCII कला में खेल

More articles: